FULL PRODUCT VERSION :
Java(TM) SE Runtime Environment (build 1.8.0_92)
Java(TM) SE Runtime Environment (build 1.8.0_121)

FULL OS VERSION :
Windows 10 professional Version 10.0.14393 Build 14393
Linux 2.6.32-358.11.1.el6.x86_64 #1 SMP Wed Jun 12 03:34:52 UTC 2013 x86_64 x86_64 x86_64 GNU/Linux

A DESCRIPTION OF THE PROBLEM :
When running the attached source code we experience random performance dropouts.

Running the same code snippet on jre-7, or with "-Xint" flag or inlining the "gradient" method, fixed the problem.

Also we found out that the overall runtime of our code went up by a factor of 4 when switching from JRE-7 to JRE-8. Any explanation for this?


THE PROBLEM WAS REPRODUCIBLE WITH -Xint FLAG: No

THE PROBLEM WAS REPRODUCIBLE WITH -server FLAG: Yes

REGRESSION. Last worked in version 7u76

STEPS TO FOLLOW TO REPRODUCE THE PROBLEM :
Run the attached code on JRE-8 and inspect the output.

EXPECTED VERSUS ACTUAL BEHAVIOR :
There should be no performance drop on any of the threads running in parallel. In particular the numerical computation should not influence the Logger thread in out example.
ERROR MESSAGES/STACK TRACES THAT OCCUR :
Instead we observe this output:

Start
........
-> levels took: 2.2 sec.
...........................
-> levels took: 6.6 sec.
............................................
-> levels took: 11.0 sec.
..................................
-> levels took: 8.3 sec.
..................
-> levels took: 10.7 sec.

Log-131 took: 6.3 sec., expected 250 ms.
....
-> levels took: 13.1 sec.

Log-136 took: 12.1 sec., expected 250 ms.
........................................................
Log-193 took: 1.5 sec., expected 250 ms.

-> levels took: 15.5 sec.
....
Log-198 took: 16.9 sec., expected 250 ms.
-> levels took: 17.9 sec.

............
Log-211 took: 17.3 sec., expected 250 ms.
-> levels took: 20.3 sec.

...........................................................................................
-> levels took: 22.7 sec.
.........................................................
-> levels took: 25.1 sec.
Log-360 took: 10.8 sec., expected 250 ms.
..............................................................................................................
-> levels took: 27.4 sec.


REPRODUCIBILITY :
This bug can be reproduced always.

---------- BEGIN SOURCE ----------
/**
 * @author Marc Flesch
 */
public class MSSTest {

public static void main(String[] args) {
submit(new MSS(), "MSS");
submit(new BusyLog(250), "Log");
}

private static void submit(Runnable r, String name) { new Thread(r, name).start();}
private static String dt(long t1, long t2) { return ((t2 - t1) / 100) / 10.0 + " sec."; }

private static final class BusyLog implements Runnable {
private final long timeout;

BusyLog(long timeout) {
this.timeout = timeout;
}

@Override
public void run() {
int counter = -1;
while (true) {
long t1 = System.currentTimeMillis();
while(System.currentTimeMillis() - t1 < timeout) {
Math.log(Float.NaN);
}
long t2 = System.currentTimeMillis();
counter++;
String dt = dt(t1, t2);
if (dt.equals(dt(0, timeout))) {
System.out.print(".");
} else {
System.err.println("\nLog-" + counter + " took: " + dt + ", expected " + timeout + " ms.");
}
}
}
}

private static class MSS implements Runnable {

public void run() {
System.out.println("Start");
int binCount = 2000000;
float mean = 0.76f;
float sigma = 0.75f;
float[] levels = new float[binCount];

for (int binWindow = 2; binWindow < 64; binWindow+=4) {
int n = levels.length;
float[] gradient = new float[n];
float inv2BinWidth = 1f / (binWindow * binWindow);
float mean4 = mean / 4;
float sigma2 = 4 / (sigma * sigma);
float ms2 = mean / (sigma * sigma);
int window = 3 * binWindow;
float[] exponents = new float[window + 1];
for (int i = 0; i <= window; i++) {
exponents[i] = (float) (i * Math.exp(-0.5 * i * i * inv2BinWidth));
}
long t1 = System.currentTimeMillis();
gradient(levels, n, gradient, mean4, sigma2, ms2, window, exponents);
long t2 = System.currentTimeMillis();
System.out.println("\n-> levels took: " + dt(t1, t2));
}
System.err.println("Done.");
System.exit(0);
}

private void gradient(float[] levels, int n, float[] gradient, float mean4, float sigma2, float ms2, int window, float[] exponents) {
for (int i = 0; i < n; i++) {
float invB;
int d = 0;
if (levels[i] < mean4) {
invB = sigma2;
} else {
invB = ms2 / levels[i];
}
for (int j = i + 1; j < n; j++) {
d++;
float inv_i;
if (levels[j] < mean4) {
inv_i = sigma2;
} else {
inv_i = ms2 / levels[j];
}
float r = levels[j] - levels[i];
float val = -0.5f * r * r;
gradient[i] += exponents[d] * Math.exp(val * invB);
gradient[j] -= exponents[d] * Math.exp(val * inv_i);
if (d == window) {
break;
}
}
}
}
}
}

---------- END SOURCE ----------

CUSTOMER SUBMITTED WORKAROUND :
If you could provide a work around for us that would be great. Thanks.