Changeset 58fe85a for benchmark/ctxswitch

Timestamp:

Jan 7, 2021, 3:27:00 PM (5 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

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

Children:

2b4daf2, 64aeca0

Parents:

3c64c668 (diff), eef8dfb (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' into park_unpark

Location:

benchmark/ctxswitch

Files:

• JavaThread.java (modified) (2 diffs)
• cfa_cor.cfa (modified) (1 diff)
• cfa_gen.cfa (modified) (1 diff)
• rust_await.rs (added)
• rust_tokio_thrd.rs (added)

benchmark/ctxswitch/JavaThread.java

@@ -1 +1 @@
 public class JavaThread {
         // Simplistic low-quality Marsaglia Shift-XOR pseudo-random number generator.
-        // Bijective   
+        // 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 ; 
+        static volatile int Ticket = 0 ;
 
         private static int nextRandom (int x) {
-                if (x == 0) { 
+                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 ; 
+                        // 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 ;   
+                return x ;
         }
         static int x = 2;
 
-        static private int times = Integer.parseInt("100000");
+        static private long times = Long.parseLong("100000");
 
         public static void helper() {
-                for(int i = 1; i <= times; i += 1) {
+                for(long i = 1; i <= times; i += 1) {
                         Thread.yield();
                 }
@@ -40 +40 @@
         }
         public static void main(String[] args) throws InterruptedException {
-                if ( args.length > 2 ) System.exit( 1 );
-                if ( args.length == 2 ) { times = Integer.parseInt(args[1]); }
+                if ( args.length > 1 ) System.exit( 1 );
+                if ( args.length == 1 ) { times = Long.parseLong(args[0]); }
 
                 for (int i = Integer.parseInt("5"); --i >= 0 ; ) {

benchmark/ctxswitch/cfa_cor.cfa

@@ -2 +2 @@
 #include <thread.hfa>
 
-#include "bench.h"
+#include "../bench.h"
 
-coroutine C {} c;
+coroutine C {};
 void main( __attribute__((unused)) C & ) {
-        while () {
-                suspend();
+        for () {
+                suspend;
         }
 }
 int main( int argc, char * argv[] ) {
+        C c;
         BENCH_START()
         BENCH(

benchmark/ctxswitch/cfa_gen.cfa

@@ -1 +1 @@
 #include "../bench.h"
 
-typedef struct {
-        void * next;
-} C;
-
-void comain( C * c ) {
-        if ( __builtin_expect(c->next != 0, 1) ) goto *(c->next);
-        c->next = &&s1;
+generator G {};
+void main( G & ) {
         for () {
-                return;
-          s1: ;
+                suspend;
         }
 }
 
 int main( int argc, char * argv[] ) {
+        G g;
         BENCH_START()
-        C c = { 0 };
         BENCH(
                 for ( times ) {
-                        comain( &c );
+                        resume( g );
                 },
                 result