Which version of JVM is the fastest?

This article uses open source Chronicle Queue Two threads of , Exchange with each other 256 Bytes of message data , Which version of JVM The fastest .

Chronicle Queue Is a persistent low latency Java Messaging framework . It is suitable for critical applications with high performance . because Chronicle Queue Run on memory mapped locally , So it eliminates the need for garbage collection , And provides developers with certainty and high performance .

This article will use open source Chronicle Queue Two threads of , Exchange with each other 256 Bytes of message data . meanwhile , To minimize the impact on the disk subsystem , All messages will be stored in shared memory --/dev/shm in .

Usually , In such benchmarks , A single producer （producer） The thread writes the message with a nanosecond timestamp （nanosecond timestamp） Of the queue . Another consumer thread reads messages from the queue , And record the time increment in the histogram . The producer keeps every second 100,000 Continuous output rate of messages . among , The payload in each message is 256 byte . Because the data will be in 100 Measured over a span of seconds , Therefore, most of the jitters can be reflected in the measurement , And it ensures that those with higher percentiles , Fall within a reasonable confidence interval .

Our target host is to have a AMD Ryzen 9 5950X Of 16 Nuclear processor , And take 3.4 GHz Running on the Linux 5.11.0-49-generic #55-Ubuntu SMP On . Because of the CPU Of 2-8 The nucleus is isolated , Therefore, the operating system will not automatically schedule any user processes , And will avoid most of the interruptions on these cores .

PART 01

Java Code  

The following shows part of the code for the producer's internal loop ：

Java

Log in and copy

      
      

       
       // Pin the producer thread to CPU 2
       
       
Affinity.setAffinity(2);
       
       

       
       
try (ChronicleQueue cq = SingleChronicleQueueBuilder.binary(tmp)
       
       
.blockSize(blocksize)
       
       
.rollCycle(ROLL_CYCLE)
       
       
.build()) {
       
       

       
       
ExcerptAppender appender = cq.acquireAppender();
       
       

       
       
final long nano_delay = 1_000_000_000L/MSGS_PER_SECOND;
       
       
for (int i = -WARMUP; i < COUNT; ++i) {
       
       
long startTime = System.nanoTime();
       
       

       
       
try (DocumentContext dc = appender.writingDocument()) {
       
       
Bytes bytes = dc.wire().bytes();
       
       
data.writeLong(0, startTime);
       
       
bytes.write(data,0, MSGSIZE);
       
       
}
       
       
long delay = nano_delay - (System.nanoTime() - startTime);
       
       

       
       
spin_wait(delay);
       
       
}
       
       
}
      
      
      
      

       
       
1.
       
       
2.
       
       
3.
       
       
4.
       
       
5.
       
       
6.
       
       
7.
       
       
8.
       
       
9.
       
       
10.
       
       
11.
       
       
12.
       
       
13.
       
       
14.
       
       
15.
       
       
16.
       
       
17.
       
       
18.
       
       
19.
       
       
20.
       
       
21.
       
       
22.
       
       
23.
       
       
24.
      
      

Slide left and right to see the full code

And in another thread , consumer （consumer） The thread will pass the following code （ The following is only a shortened part ）, In its internal circulation

Java

Log in and copy

      
      

       
       // Pin the consumer thread to CPU 4
       
       
Affinity.setAffinity(4);
       
       

       
       
try (ChronicleQueue cq = SingleChronicleQueueBuilder.binary(tmp)
       
       
.blockSize(blocksize)
       
       
.rollCycle(ROLL_CYCLE)
       
       
.build()) {
       
       

       
       
ExcerptTailer tailer = cq.createTailer();
       
       

       
       
int idx = -APPENDERS * WARMUP;
       
       

       
       
while(idx < APPENDERS * COUNT) {
       
       
try (DocumentContext dc = tailer.readingDocument()) {
       
       
if(!dc.isPresent())
       
       
continue;
       
       

       
       
Bytes bytes = dc.wire().bytes();
       
       
data.clear();
       
       
bytes.read(data, (int)MSGSIZE);
       
       
long startTime = data.readLong(0);
       
       

       
       
if(idx >= 0)
       
       
deltas[idx] = System.nanoTime() - startTime;
       
       
++idx;
       
       
}
       
       
}
       
       
}
      
      
      
      

       
       
1.
       
       
2.
       
       
3.
       
       
4.
       
       
5.
       
       
6.
       
       
7.
       
       
8.
       
       
9.
       
       
10.
       
       
11.
       
       
12.
       
       
13.
       
       
14.
       
       
15.
       
       
16.
       
       
17.
       
       
18.
       
       
19.
       
       
20.
       
       
21.
       
       
22.
       
       
23.
       
       
24.
       
       
25.
       
       
26.
       
       
27.
       
       
28.
      
      

Slide left and right to see the full code

It can be seen that , The consumer thread reads each nano timestamp , And record the corresponding delay in an array . These timestamps will be used later when the benchmark is completed , Put into the histogram for printing . and , Only in JVM Be correctly “ preheating ”、 as well as C2 The compiler has JIT（Just-In-Time） After the hot execution path of , Measurement will begin .

PART 02

JVM Various variant versions of

at present ,Chronicle Queue The ability to formally support includes Java 8、Java 11 and Java 17 Inside , All recent LTS（Light Task Schedule） edition , So they can all be used for benchmarking . meanwhile , We will also use GraalVM Community and enterprise . The following are some of the specific JVM List of variant versions ：

surface 1, Lists the specific JVM Variant version

PART 03

measurement     

Because the benchmark will run 100 second , And every second 100,000 Messages are generated , So during each benchmark , We will have 100,000 * 100 = 1000 Ten thousand messages need to be sampled . The histogram places each sample in 50%（ Median ）、90%、99%、 as well as 99.9% Wait for a specific percentile . The following table shows the tests for these percentiles , The total number of messages received ：

surface 2, Displays the number of messages per percentile

For the above table , We lock in the range where the change of the measured value is relatively small , For up to 99.99% Percentile of , The confidence interval may be reasonable . and 99.999% Percentile of , It may need to run for at least half an hour , Instead of just using 100 The second time , To collect data , To generate any data with a reasonable confidence interval .

PART 04

Benchmark results

For each Java Variant version , We all ran the following benchmarks ：

Log in and copy

      
      

       
       Shell
       
       
mvn exec:[email protected]
      
      
      
      

       
       
1.
       
       
2.
      
      

Be careful , Our producer and consumer threads will be locked , So that they can be separated from each other CPU Of 2 and 4 Run on the core . The following are typical process characteristics after they have been running for a period of time ：

Log in and copy

      
      

       
       Shell
       
       
$ top
       
       

       
       
PID USER      PR  NI    VIRT    RES    SHR S  %CPU  %MEM     TIME+ COMMAND
       
       
3216555 per.min+  20   0   92.3g   1.5g   1.1g S 200.0   2.3   0:50.15 java
      
      
      
      

       
       
1.
       
       
2.
       
       
3.
       
       
4.
       
       
5.
      
      

Slide left and right to see the full code

It can be seen that , The producer and consumer threads rotate and wait between each message （spin-wait）, So each consumes the whole CPU The kernel of . If CPU The consumption of is a potential problem , Then the delay and certainty can be achieved by , Pause the thread for a short time ( for example LockSupport.parkNanos(1000)), To reduce power consumption .

Usually , We'll be in nanoseconds （ns） Measure test results in units . Of course , Many other types of delay measurements are also measured in microseconds （= 1,000 ns）、 Even milliseconds （= 1,000,000 ns） Unit of measurement . Here 1 ns Roughly corresponding to CPU 1 Level cache access time .

All the following test values are based on ns Benchmark results in units ：

surface 3, Shows the various JDK Delay results for

(*) Indicates that it has not been Chronicle Queue Formal support

PART 05

Typical delay （ Median ）

It can be known from the above table , For typical （ Median ） value , Various JDK There is no significant difference between , It's just OpenJDK 11 Will be slower than other versions 30%. The fastest one is GraalVM EE 17, It is associated with OpenJDK 8、 as well as OpenJDK 17 The difference is small .

The chart shown below includes the use of various JDK Variant version , Processing 256 Typical delay for byte messages （ Of course, the lower the better ）：

chart 1, Shows various JDK Median of variant versions （ A typical ） Delay （ With ns In units of ）

It can be seen from the picture that , A typical （ Median ） The delay will vary slightly depending on the operating environment , Their numbers vary by about 5%.

PART 06

Higher percentile

Here is another chart , It shows a variety of JDK Variant version of 99.99% Percentile delay （ Of course, the lower the better ）. From the higher percentile , Various supported JDK Between variant versions , There is not much difference .GraalVM EE A little faster again , But the relative difference here becomes smaller . and OpenJDK 11 It seems to be a little worse than other variants （-5%）, However, the error increment is still within the acceptable range .

chart 2, Shows various JDK Variant version of 99.99% Percentile delay （ With ns In units of ）

PART 07

Summary     

According to the execution logic of the above code ： Access from main memory 64 A data , About need 100 A cycle （ namely , On current hardware, it is equivalent to about 30 ns）. Compare with the above test , We can see that , Chronicle Queue Get data from producers , And persistent data by writing memory mapped files , For inter thread communication and happens-before Guarantee , Apply appropriate memory protection , Then provide the data to the consumer . And in 30 ns Single in 64 Bit memory access compared to , All this usually happens in 600 ns Left and right 256 Bytes on the message . These are Chronicle Queue The resulting delay comparison results are impressive .

so ,OpenJDK 17 and GraalVM EE 17 Both provide the best delay results , It belongs to the preference of the application . Of course , If you need to suppress outliers 、 Or reduce the overall delay as much as possible , that GraalVM EE 17 It will be more suitable for .