Changeset be53b87

Timestamp:

Jul 29, 2019, 1:46:24 PM (5 years ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

ADT, arm-eh, ast-experimental, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

5453237

Parents:

033ff37

git-author:

Peter A. Buhr <pabuhr@…> (07/29/19 12:40:16)

git-committer:

Peter A. Buhr <pabuhr@…> (07/29/19 13:46:24)

Message:

update Java benchmarks with multiple mechanisms to trick the JIT

Location:

benchmark

Files:

• creation/JavaThread.java (modified) (1 diff)
• ctxswitch/JavaThread.java (modified) (1 diff)
• mutex/JavaThread.java (modified) (1 diff)
• schedint/JavaThread.java (modified) (5 diffs)

benchmark/creation/JavaThread.java

@@ -1 +1 @@
 public class JavaThread {
+        // Simplistic low-quality Marsaglia Shift-XOR pseudo-random number generator.
+        // Bijective   
+        // Cycle length for non-zero values is 4G-1.
+        // 0 is absorbing and should be avoided -- fixed point.
+        // The returned value is typically masked to produce a positive value.
+        static volatile int Ticket = 0 ; 
+
+        private static int nextRandom (int x) {
+                if (x == 0) { 
+                        // reseed the PRNG
+                        // Ticket is accessed infrequently and does not constitute a coherence hot-spot. 
+                        // Note that we use a non-atomic racy increment -- the race is rare and benign. 
+                        // If the race is a concern switch to an AtomicInteger.  
+                        // In addition accesses to the RW volatile global "Ticket"  variable are not 
+                        // (readily) predictable at compile-time so the JIT will not be able to elide 
+                        // nextRandom() invocations.  
+                        x = ++Ticket ; 
+                        if (x == 0) x = 1 ; 
+                }
+                x ^= x << 6;
+                x ^= x >>> 21;
+                x ^= x << 7;
+                return x ;   
+        }
+        static int x = 2;
+
+        static private final int NoOfTimes = Integer.parseInt("10000") ;
+
         public static class MyThread extends Thread {
                 @Override
                 public void run() {}
         }
-
-        public static void main(String[] args) throws InterruptedException {
-                int NoOfTimes = 50000;
-                long start = System.nanoTime();
+        public static void helper() throws InterruptedException {
                 for(int i = 1; i <= NoOfTimes; i += 1) {
-                        JavaThread.MyThread m = new JavaThread.MyThread();
-                        m.start();
+                        MyThread m = new MyThread();
+                        x = nextRandom( x );
+                        m.start();
                         m.join();
                 }
+        }
+        public static void InnerMain() throws InterruptedException {
+                long start = System.nanoTime();
+                helper();
                 long end = System.nanoTime();
-                System.out.println( (end - start) / NoOfTimes);
+                System.out.println( (end - start) / NoOfTimes );
+        }
+        public static void main(String[] args) throws InterruptedException {
+                for (int n = Integer.parseInt("5"); --n >= 0 ; ) { 
+                        InnerMain();
+                        Thread.sleep(2000);     // 2 seconds
+                        x = nextRandom(x);
+                }
+                if ( x == 0 ) System.out.println(x);
         }
 }

benchmark/ctxswitch/JavaThread.java

@@ -1 +1 @@
 public class JavaThread {
-        public static void main(String[] args) {
-                int NoOfTimes = 5000000;
-                long start = System.nanoTime();
+        // Simplistic low-quality Marsaglia Shift-XOR pseudo-random number generator.
+        // Bijective   
+        // Cycle length for non-zero values is 4G-1.
+        // 0 is absorbing and should be avoided -- fixed point.
+        // The returned value is typically masked to produce a positive value.
+        static volatile int Ticket = 0 ; 
+
+        private static int nextRandom (int x) {
+                if (x == 0) { 
+                        // reseed the PRNG
+                        // Ticket is accessed infrequently and does not constitute a coherence hot-spot. 
+                        // Note that we use a non-atomic racy increment -- the race is rare and benign. 
+                        // If the race is a concern switch to an AtomicInteger.  
+                        // In addition accesses to the RW volatile global "Ticket"  variable are not 
+                        // (readily) predictable at compile-time so the JIT will not be able to elide 
+                        // nextRandom() invocations.  
+                        x = ++Ticket ; 
+                        if (x == 0) x = 1 ; 
+                }
+                x ^= x << 6;
+                x ^= x >>> 21;
+                x ^= x << 7;
+                return x ;   
+        }
+        static int x = 2;
+
+        static private final int NoOfTimes = Integer.parseInt("1000000") ;
+
+        public static void helper() {
                 for(int i = 1; i <= NoOfTimes; i += 1) {
                         Thread.yield();
                 }
+        }
+        public static void InnerMain() {
+                long start = System.nanoTime();
+                helper();
                 long end = System.nanoTime();
-                System.out.println( (end - start) / NoOfTimes);
+                System.out.println( (end - start) / NoOfTimes );
+        }
+        public static void main(String[] args) throws InterruptedException {
+                for (int n = Integer.parseInt("5"); --n >= 0 ; ) { 
+                        InnerMain();
+                        Thread.sleep(2000);     // 2 seconds
+                        x = nextRandom(x);
+                }
+                if ( x == 0 ) System.out.println(x);
         }
 }

benchmark/mutex/JavaThread.java

@@ -1 +1 @@
 public class JavaThread {
-        public synchronized void noop() {}
+        // Simplistic low-quality Marsaglia Shift-XOR pseudo-random number generator.
+        // Bijective   
+        // Cycle length for non-zero values is 4G-1.
+        // 0 is absorbing and should be avoided -- fixed point.
+        // The returned value is typically masked to produce a positive value.
+        static volatile int Ticket = 0 ; 
 
-        public static void main(String[] args) {
-                int NoOfTimes = 5000000;
+        private static int nextRandom (int x) {
+                if (x == 0) { 
+                        // reseed the PRNG
+                        // Ticket is accessed infrequently and does not constitute a coherence hot-spot. 
+                        // Note that we use a non-atomic racy increment -- the race is rare and benign. 
+                        // If the race is a concern switch to an AtomicInteger.  
+                        // In addition accesses to the RW volatile global "Ticket"  variable are not 
+                        // (readily) predictable at compile-time so the JIT will not be able to elide 
+                        // nextRandom() invocations.  
+                        x = ++Ticket ; 
+                        if (x == 0) x = 1 ; 
+                }
+                x ^= x << 6;
+                x ^= x >>> 21;
+                x ^= x << 7;
+                return x ;   
+        }
+        static int x = 2;
+
+        static private final int NoOfTimes = Integer.parseInt("100000000") ;
+
+        public synchronized void noop() {
+                x = nextRandom( x );
+        }
+        public static void helper() throws InterruptedException {
                 JavaThread j = new JavaThread();
-                long start = System.nanoTime();
+                // Inhibit biased locking ...
+                x = (j.hashCode() ^ System.identityHashCode(j)) | 1 ;     
                 for(int i = 1; i <= NoOfTimes; i += 1) {
+                        x = nextRandom(x);
                         j.noop();
                 }
+        }
+        public static void InnerMain() throws InterruptedException {
+                long start = System.nanoTime();
+                helper();
                 long end = System.nanoTime();
-                System.out.println( (end - start) / NoOfTimes);
+                System.out.println( (end - start) / NoOfTimes );
+        }
+        public static void main(String[] args) throws InterruptedException {
+                for (int n = Integer.parseInt("5"); --n >= 0 ; ) { 
+                        InnerMain();
+                        Thread.sleep(2000);     // 2 seconds
+                        x = nextRandom(x);
+                }
+                if ( x == 0 ) System.out.println(x);
         }
 }

benchmark/schedint/JavaThread.java

@@ -1 +1 @@
 class Monitor {
         public static volatile Boolean go = false;
+        public static volatile Boolean next = false;
 }
 
@@ -13 +14 @@
                 while( Monitor.go ) {
                         synchronized(this.m) {
+                                Monitor.next = false;
                                 this.m.notify();
                         }
+                        while( ! Monitor.next && Monitor.go );  // spin until woken
                 }
         }
@@ -20 +23 @@
 
 public class JavaThread {
-        public static void main(String[] args) throws InterruptedException {
-                int NoOfTimes = 50000;
+        // Simplistic low-quality Marsaglia Shift-XOR pseudo-random number generator.
+        // Bijective   
+        // Cycle length for non-zero values is 4G-1.
+        // 0 is absorbing and should be avoided -- fixed point.
+        // The returned value is typically masked to produce a positive value.
+        static volatile int Ticket = 0 ; 
+
+        private static int nextRandom (int x) {
+                if (x == 0) { 
+                        // reseed the PRNG
+                        // Ticket is accessed infrequently and does not constitute a coherence hot-spot. 
+                        // Note that we use a non-atomic racy increment -- the race is rare and benign. 
+                        // If the race is a concern switch to an AtomicInteger.  
+                        // In addition accesses to the RW volatile global "Ticket"  variable are not 
+                        // (readily) predictable at compile-time so the JIT will not be able to elide 
+                        // nextRandom() invocations.  
+                        x = ++Ticket ; 
+                        if (x == 0) x = 1 ; 
+                }
+                x ^= x << 6;
+                x ^= x >>> 21;
+                x ^= x << 7;
+                return x ;   
+        }
+        static int x = 2;
+
+        static private final int NoOfTimes = Integer.parseInt("1000000") ;
+
+        public static void helper( Monitor m ) throws InterruptedException {
+                for(int i = 1; i <= NoOfTimes; i += 1) {
+                        m.wait();               // relase monitor lock
+                        m.next = true;
+                }
+        }
+        public static void InnerMain() throws InterruptedException {
                 Monitor m = new Monitor();
                 long start, end;
@@ -31 +67 @@
                         }
                         start = System.nanoTime();
-                        for(int i = 1; i <= NoOfTimes; i += 1) {
-                                m.wait();
-                        }
+                        helper( m );
                         end = System.nanoTime();
                 }
@@ -40 +74 @@
                 System.out.println( (end - start) / NoOfTimes);
         }
+        public static void main(String[] args) throws InterruptedException {
+                for (int n = Integer.parseInt("5"); --n >= 0 ; ) { 
+                        InnerMain();
+                        Thread.sleep(2000);     // 2 seconds
+                        x = nextRandom(x);
+                }
+                if ( x == 0 ) System.out.println(x);
+        }
 }