Instruction Cache Optimization for Transaction Based Workloads

[Xin Tong]

Hello

I am new to the openJDK community. I have an research project I will be
doing this summer, I would like to seek some advices.

In a transaction based java workload, i.e. daytrader, specjbb.
instructions for transactions typically do not fit in the first level
instruction cache.  i.e. the instructions used at the beginning of the
transaction is usually kicked out of the cache when the transaction
reaches its middle point or later. when the next transaction running
similar instructions comes in. It will suffer the compulsory icache
misses for the evicted instructions.

The idea is as follow. what if we begin to spread the transaction code
among icache of multiple processor cores. say transaction A comes in,
the first part of it is executed on core #1, the second part of it is
executed on core #2, etc. and when transaction B comes in, assuming it
is executing the same code as transaction A, the first part of it will
execute on core #1 and second part execute on core #2, etc. This way,
we save on a lot of cache misses.

However, there are two things we do suffer. 1. data misses. the
transaction is moving from core to core. 2. transition overhead. the
overhead involves in moving a transaction from core to core. I do not
want to argue how much these two factors will account for and whether
this approach will give any beneficial results at all at the moment.
I just would like to know whether this is doable in openJDK. what about
Jikes RVM ? What are some of the advantages openJDK has over RVM in this
project, and vice versa.

Any comments, suggestions, ideas are welcome and will be greatly appreciated.

Any comments on the possible results/improvements/regressions are also
welcome and greatly appreciated.

Cheers