The document discusses various optimizations that can be applied to code to improve performance, including reordering operations, removing null checks, inlining polymorphic method calls, and using SIMD instructions. It provides examples of code before and after applying these optimizations in languages like C, C#, Java, and JavaScript. For example, summing the squares of floating point values can be optimized in C by using SIMD instructions, dropping the time from 17 milliseconds to 17 milliseconds, but similar optimizations may not be applied by JIT compilers for languages like Java and JavaScript.

1. OverOps JVM Performance
Magic Tricks
Adam Feldscher
CS I699 Performance Design Patterns II

2. Reordering Optimization
StringBuilder sb = new StringBuilder("Ingredients: ");
for (int i = 0; i < ingredients.length; i++) {
if (i > 0) {
sb.append(", ");
}
sb.append(ingredients[i]);
}
return sb.toString();
StringBuilder sb = new StringBuilder("Ingredients: ");
if (ingredients.length > 0) {
sb.append(ingredients[0]);
for (int i = 1; i < ingredients.length; i++) {
sb.append(", ");
sb.append(ingredients[i]);
}
}
return sb.toString();
Original Optimized
• Removed branch within loop

3. Null Check
public static String l33tify(String phrase) {
if (phrase == null) {
throw new IllegalArgumentException("phrase mus
t not be null");
}
return phrase.replace('e', '3');
}
public static String l33tify(String phrase) {
return phrase.replace('e', '3');
}
Original Optimized
• Removed null check, after many iterations of no nulls
• Removes a branch
• If a null shows up, a segfault will catch it. JVM will decompile the code and throw the
exception

4. Polymorphic Method Dispatch
public interface Song {
void sing();
}
public class GangnamStyle implements Song {
@Override
public void sing() {
System.out.println("Oppan gangnam style!");
}
}
public class Baby implements Song {
@Override
public void sing() {
System.out.println("And I was like baby, baby, baby, oh
");
}
}
public class Main {
public static void perform(Song s) {
s.sing();
}
}
public static void perform(Song s) {
if (s fastnativeinstanceof GangnamStyle) {
System.out.println("Oppan gangnam style!");
} else {
s.sing();
}
}
Original Optimized
• If GangnamStyle is shown to be
passed in 95% of the time
• Inline virtual call

5. Making the obvious code fast
By Jack Mott

6. The Test
 32 million 64bit floating point values
 Calculate the sum of their squares

7. C – 17 milliseconds
double sum = 0.0;
for (int i = 0; i < COUNT; i++)
{
double v = values[i] * values[i];
sum += v;
}

8. C – SIMD – 17 milliseconds
__m256d vsum = _mm256_setzero_pd();
for(int i = 0; i < COUNT/4; i=i+1) {
__m256d v = values[i];
vsum = _mm256_add_pd(vsum,_mm256_mul_pd(v,v));
}
double *tsum = &vsum;
double sum = tsum[0]+tsum[1]+tsum[2]+tsum[3];

9. C Compiler converted base version to
SIMD
double sum = 0.0;
for (int i = 0; i < COUNT; i++) {
00007FF7085C1120 vmovupd ymm0,ymmword ptr [rcx]
00007FF7085C1124 lea rcx,[rcx+40h]
double v = values[i] * values[i]; //square em
00007FF7085C1128 vmulpd ymm2,ymm0,ymm0
00007FF7085C112C vmovupd ymm0,ymmword ptr [rcx-20h]
00007FF7085C1131 vaddpd ymm4,ymm2,ymm4
00007FF7085C1135 vmulpd ymm2,ymm0,ymm0
00007FF7085C1139 vaddpd ymm3,ymm2,ymm5
00007FF7085C113D vmovupd ymm5,ymm3
00007FF7085C1141 sub rdx,1
00007FF7085C1145 jne imperative+80h (07FF7085C1120h)
sum += v;
}

10. C#
var sum = values.Sum(x => x * x);
Linq Select Sum - 260 milliseconds
Linq Aggregate - 280 milliseconds
var sum = values.Aggregate(0.0,(acc, x) => acc + x * x);
for loop - 34 milliseconds
double sum = 0.0;
foreach (var v in values)
{
double square = v * v;
sum += square;
}
JIT decides its not worth it to do SIMD
C# SIMD Explicit - 17 milliseconds
Vector<double> vsum = new Vector<double>(0.0);
for (int i = 0; i < COUNT; i += Vector<double>.Count)
{
var value = new Vector<double>(values, i);
vsum = vsum + (value * value);
}
double sum = 0;
for(int i = 0; i < Vector<double>.Count;i++)
{
sum += vsum[i];
}

11. Java
double sum = Arrays.stream(values)
.map(x -> x*x)
.sum();
Streams Map Sum 138 milliseconds
Streams Reduce 34 milliseconds
double sum = Arrays.stream(values)
.reduce(0,(acc,x) -> acc+x*x);
Java Streams Map Reduce 34 milliseconds
double sum = Arrays.stream(values)
.map(x -> x*x)
.reduce(0,(acc,x) -> acc+x);
.sum is doing something fancy,
use reduce instead
Java won’t do SIMD

12. JavaScript
var sum = values.map(x => x*x)
.reduce( (total,num,index,array)
=> total+num,0.0);
map reduce (node.js) 10,000ms
reduce (node.js) 800 and then 300 milliseconds
var sum = values.reduce( (total,num,index,array)
=> total+num*num,0.0)
foreach (node.js) 800 and then 300 milliseconds
var sum = 0.0;
array.forEach( (element,index,array)
=> sum += element*element )
JIT kicks in after 3 or 4 iterations, drops to 300
imperative (node.js) 37 milliseconds
var sum = 0.0;
for (var i = 0; i < values.length;i++){
var x = values[i];
sum += x*x;
}