hotspot heap and L1 and L2 cache misses

[Andy Nuss]

Hi,

Lets say I have a function which mutates a finite automata.  It creates lots of small objects (my own link and double-link structures).  It also does a lot of puts in my own maps.   The objects and maps in turn have references to arrays and some immutable objects.

My question is, all these arrays and objects created in one function that has to do a ton of construction, are there any things to watchout for so that hotspot will try to create all the objects in this one function/thread colocated on the heap so that L1/L2 cache misses are reduced when the finite automata is executed against data?

Ideally, someone could tell me that when my class constructors in turn creates new instances of other various size other objects and arrays, they are all colocated on the heap.

Ideally, someone could tell me that when I have a looping function that creates alot of very small Linked List objects in succession, again they are colocated.

In general, how does hotspot try with creating new objects to help the L1/L2 caches?

By the way, I did a test port of my automata to C++ where for objects like the above, I had big memory chunks that my inplace constructors just subdivided the memory chunk that it owned so that all the subobjects were absolutely as colocated as possible.

This C++ ported automata out-performed my java version by 5x in execution against data.  And in cases where I tested the performance of construction-time cost of the automata where the comparison is between the hotspot new, versus my simple inplace C++ member functions which basically just return the current chunk cursor, after calculating the size of the object, and updating the chunk cursor to point beyond the new size, in those cases I saw 25x performance differences (5 yrs ago).


Andy
-------------- next part --------------
An HTML attachment was scrubbed...
URL: http://mail.openjdk.java.net/pipermail/hotspot-compiler-dev/attachments/20120915/5b48a4c3/attachment.html