CODEWITHSUNDEEP
javaoptimizationmemory-managementjvmjavac
vach
vach

Reputation: 11377

Java Object[] and cache strading

As we know when memory is moved to L caches on cpu it is moved with cachelines, thus the whole cache strading performance optimization...

Well in java when we define an array jmm guarantees that memory for each element will be allocated sequentially. However if we have array of references, those references can point randomly to different places in the memory.

My question is does java allocate actual objects memory sequentially? What optimizations do we have under the hood for this?

For example if we declare int[] we are confident those are all actually sequential in memory, but if we define a NewType (like struct) that has two int fields in it, and declare NewType[] will java figure out and keep actual memory sequentially or not?

Upvotes: 4

Views: 251

Answers (2)

the8472
the8472

Reputation: 43052

but if we define a NewType (like struct) that has two int fields in it, and declare NewType[] will java figure out and keep actual memory sequentially or not?

In this scenario java is not very cache-friendly because apart from primitive types java arrays are not packed data structures, they are arrays of references pointing to objects allocated elsewhere in memory.

I.e. there will be at least one level of indirection from the array to the object itself. This problem is often referred to as "pointer chasing".

I.e. usually the memory layout will look like this:

HlRRRRRRRRRRRRRRRRRRRRRRRRR0HR0iii0HR0iii0HR0iii0HR0iii0HR0iii0HR0iii0HR0iii0
         Array             | Obj  | Obj  | Obj  | Obj  | Obj  | Obj  | Obj  |

H = object header
l = array length
R = reference
i = int
0 = various types of padding

You can use jol to inspect the memory layout of objects.

The JDK devs are working on Value types as part of project valhalla that will eventually allow packed arrays to exist, which may be needed as part of project panama, but this still is far off into the future.

In the meantime there are 3rd-party projects aim to provide similar features:

Other projects either use off-heap storage (e.g. via sun.misc.Unsafe) or views on ByteBuffer / byte[] arrays to create packed, cache-friendly data structures at the expense of more complicated APIs.

Upvotes: 1

Peter Lawrey
Peter Lawrey

Reputation: 533580

My question is does java allocate actual objects memory sequentially?

This is not guaranteed, but most of the time the OpenJDK/Oracle JVM does. Some of the times it doesn't are;

  • when you allocate a large object in tenured space,
  • your TLAB is full and you need to get another one.

However, within the TLAB, it just allocates sequentially in memory.

declare NewType[] will java figure out and keep actual memory sequentially or not?

Java doesn't figure out anything, nor does it go out of it's way to allocate objects randomly in memory. In general, each new object will be immediately after the last one.

Upvotes: 3

Related Questions