Changeset 2316525


Ignore:
Timestamp:
Jan 19, 2020, 4:16:27 PM (20 months ago)
Author:
Peter A. Buhr <pabuhr@…>
Branches:
arm-eh, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr
Children:
f090750
Parents:
9e63a2b
Message:

update benchmarks for concurrency paper

Location:
benchmark
Files:
25 edited

Legend:

Unmodified
Added
Removed
  • benchmark/Makefile.am

    r9e63a2b r2316525  
    1111## Created On       : Sun May 31 09:08:15 2015
    1212## Last Modified By : Peter A. Buhr
    13 ## Last Modified On : Fri Jan 10 11:29:52 2020
    14 ## Update Count     : 230
     13## Last Modified On : Sun Jan 19 12:55:02 2020
     14## Update Count     : 232
    1515###############################################################################
    1616
     
    8383basic_loop_DURATION = 15000000000
    8484basic_function_DURATION = 10000000000
     85basic_tls_fetch_add_DURATION = 10000000000
    8586basic_DURATION = 250000000
    8687
     
    291292ctxswitch-nodejs_coroutine$(EXEEXT):
    292293        echo "#!/bin/sh" > a.out
    293         echo "node $(srcdir)/ctxswitch/node_cor.js" >> a.out
     294        echo "nodejs $(srcdir)/ctxswitch/node_cor.js" >> a.out
    294295        chmod a+x a.out
    295296
     
    434435creation-nodejs_coroutine$(EXEEXT):
    435436        echo "#!/bin/sh" > a.out
    436         echo "node $(srcdir)/creation/node_cor.js" >> a.out
     437        echo "nodejs $(srcdir)/creation/node_cor.js" >> a.out
    437438        chmod a+x a.out
    438439
  • benchmark/Makefile.in

    r9e63a2b r2316525  
    421421basic_loop_DURATION = 15000000000
    422422basic_function_DURATION = 10000000000
     423basic_tls_fetch_add_DURATION = 10000000000
    423424basic_DURATION = 250000000
    424425ctxswitch_pthread_DURATION = 25000000
     
    933934ctxswitch-nodejs_coroutine$(EXEEXT):
    934935        echo "#!/bin/sh" > a.out
    935         echo "node $(srcdir)/ctxswitch/node_cor.js" >> a.out
     936        echo "nodejs $(srcdir)/ctxswitch/node_cor.js" >> a.out
    936937        chmod a+x a.out
    937938
     
    10681069creation-nodejs_coroutine$(EXEEXT):
    10691070        echo "#!/bin/sh" > a.out
    1070         echo "node $(srcdir)/creation/node_cor.js" >> a.out
     1071        echo "nodejs $(srcdir)/creation/node_cor.js" >> a.out
    10711072        chmod a+x a.out
    10721073
  • benchmark/creation/cfa_cor.cfa

    r9e63a2b r2316525  
    55
    66coroutine MyCoroutine {};
    7 void ?{} (MyCoroutine & this) {
     7void ?{}( MyCoroutine & this ) {
    88#ifdef EAGER
    9         resume(this);
     9        resume( this );
    1010#endif
    1111}
    12 void main(MyCoroutine &) {}
     12void main( MyCoroutine & ) {}
    1313
    1414int main( int argc, char * argv[] ) {
    1515        BENCH_START()
    1616        BENCH(
    17                 for ( i; times ) {
    18                         MyCoroutine m;
     17                for ( times ) {
     18                        MyCoroutine c;
    1919                },
    2020                result
  • benchmark/creation/cfa_thrd.cfa

    r9e63a2b r2316525  
    1010        BENCH_START()
    1111        BENCH(
    12                 for ( i; times ) {
     12                for ( times ) {
    1313                        MyThread m;
    1414                },
  • benchmark/creation/node_cor.js

    r9e63a2b r2316525  
    44if ( argc == 3 ) times = Number( process.argv[2] )
    55
    6 function * coroutine() {
    7 }
     6function * coroutine() {}
    87var hrstart = process.hrtime()
    98for ( var i = 0; i < times; i += 1 ) {
  • benchmark/ctxswitch/cfa_cor.cfa

    r9e63a2b r2316525  
    44#include "bench.h"
    55
    6 coroutine GreatSuspender {};
    7 void main( __attribute__((unused)) GreatSuspender & this ) {
    8         while ( true ) {
     6coroutine C {} c;
     7void main( __attribute__((unused)) C & ) {
     8        while () {
    99                suspend();
    1010        }
     
    1212int main( int argc, char * argv[] ) {
    1313        BENCH_START()
    14         GreatSuspender s;
    1514        BENCH(
    16                 for ( i; times ) {
    17                         resume( s );
     15                for ( times ) {
     16                        resume( c );
    1817                },
    1918                result
  • benchmark/ctxswitch/cfa_cor_then.cfa

    r9e63a2b r2316525  
    66void noOp(void) {}
    77
    8 coroutine GreatSuspender {};
     8coroutine C {} c;
    99
    10 void ?{}( GreatSuspender & this ) {
     10void ?{}( C & this ) {
    1111        prime(this);
    1212}
    1313
    14 void main( __attribute__((unused)) GreatSuspender & this ) {
    15         while( true ) {
     14void main( __attribute__((unused)) C & this ) {
     15        while () {
    1616                suspend_then(noOp);
    1717        }
     
    2020int main( int argc, char * argv[] ) {
    2121        BENCH_START()
    22         GreatSuspender s;
    2322        BENCH(
    24                 for ( i; times ) {
    25                         resume( s );
     23                for ( times ) {
     24                        resume( c );
    2625                },
    2726                result
  • benchmark/ctxswitch/cfa_gen.cfa

    r9e63a2b r2316525  
    33typedef struct {
    44        void * next;
    5 } GreatSuspender;
     5} C;
    66
    7 void comain( GreatSuspender * this ) {
    8         if ( __builtin_expect(this->next != 0, 1) ) goto *(this->next);
    9         this->next = &&s1;
     7void comain( C * c ) {
     8        if ( __builtin_expect(c->next != 0, 1) ) goto *(c->next);
     9        c->next = &&s1;
    1010        for () {
    1111                return;
     
    1616int main( int argc, char * argv[] ) {
    1717        BENCH_START()
    18         GreatSuspender s = { 0 };
     18        C c = { 0 };
    1919        BENCH(
    20                 for ( i; times ) {
    21                         comain( &s );
     20                for ( times ) {
     21                        comain( &c );
    2222                },
    2323                result
  • benchmark/ctxswitch/cfa_thrd.cfa

    r9e63a2b r2316525  
    66        BENCH_START()
    77        BENCH(
    8                 for ( i; times ) {
     8                for ( times ) {
    99                        yield();
    1010                },
  • benchmark/ctxswitch/cfa_thrd2.cfa

    r9e63a2b r2316525  
    88
    99void main(__attribute__((unused)) Fibre & this) {
    10         while(!done) {
     10        while ( ! done ) {
    1111                yield();
    1212        }
     
    1717        Fibre f1;
    1818        BENCH(
    19                 for ( i; times ) {
     19                for ( times ) {
    2020                        yield();
    2121                },
  • benchmark/ctxswitch/python_cor.py

    r9e63a2b r2316525  
    99        times = int( sys.argv[1] )
    1010
    11 def GreatSuspender():
     11def C():
    1212        while True:
    1313                yield
    1414
    15 s = GreatSuspender()
     15c = C()
    1616
    1717start = time.time_ns()
    1818for i in range( 10000000 ):
    19         next( s )  # resume
     19        next( c )  # resume
    2020end = time.time_ns()
    2121print( (end - start) / times )
  • benchmark/ctxswitch/upp_cor.cc

    r9e63a2b r2316525  
    33#include "bench.h"
    44
    5 _Coroutine GreatSuspender {
     5_Coroutine C {
    66        void main() {
    77                while( true ) {
     
    1313                resume();
    1414        }
    15 };
     15} c;
    1616int main( int argc, char * argv[] ) {
    1717        BENCH_START()
    18         GreatSuspender s;
    1918        BENCH(
    2019                for (size_t i = 0; i < times; i++) {
    21                         s.do_resume();
     20                        c.do_resume();
    2221                },
    2322                result
  • benchmark/mutex/cfa1.cfa

    r9e63a2b r2316525  
    44#include "bench.h"
    55
    6 monitor M {};
    7 void __attribute__((noinline)) call( M & mutex m ) {}
     6monitor M {} m1;
     7void __attribute__((noinline)) call( M & mutex p1 ) {}
    88
    99int main( int argc, char * argv[] ) {
    1010        BENCH_START()
    11         M m;
    1211        BENCH(
    13                 for ( i; times ) {
    14                         call( m );
     12                for ( times ) {
     13                        call( m1 );
    1514                },
    1615                result
  • benchmark/mutex/cfa2.cfa

    r9e63a2b r2316525  
    44#include "bench.h"
    55
    6 monitor M {};
    7 void __attribute__((noinline)) call( M & mutex m1, M & mutex m2 ) {}
     6monitor M {} m1, m2;
     7
     8void __attribute__((noinline)) call( M & mutex p1, M & mutex p2 ) {}
    89
    910int main( int argc, char * argv[] ) {
    1011        BENCH_START()
    11         M m1, m2;
    1212        BENCH(
    13                 for ( i; times ) {
     13                for ( times ) {
    1414                        call( m1, m2 );
    1515                },
  • benchmark/mutex/cfa4.cfa

    r9e63a2b r2316525  
    55
    66
    7 monitor M {};
    8 void __attribute__((noinline)) call( M & mutex m1, M & mutex m2, M & mutex m3, M & mutex m4 ) {}
     7monitor M {} m1, m2, m3, m4;
     8void __attribute__((noinline)) call( M & mutex p1, M & mutex p2, M & mutex p3, M & mutex p4 ) {}
    99
    1010int main( int argc, char * argv[] ) {
    1111        BENCH_START()
    12         M m1, m2, m3, m4;
    1312        BENCH(
    14                 for ( i; times ) {
     13                for ( times ) {
    1514                        call( m1, m2, m3, m4 );
    1615                },
  • benchmark/mutexC/cfa1.cfa

    r9e63a2b r2316525  
    1111void call() {
    1212        go = true;
    13         for ( i; times ) {
     13        for ( times ) {
    1414                call( m );
    1515        }
  • benchmark/mutexC/cfa2.cfa

    r9e63a2b r2316525  
    1111void call() {
    1212        go = true;
    13         for ( i; times ) {
     13        for ( times ) {
    1414                call( m1, m2 );
    1515        }
  • benchmark/mutexC/cfa4.cfa

    r9e63a2b r2316525  
    1111void call() {
    1212        go = true;
    13         for ( i; times ) {
     13        for ( times ) {
    1414                call( m1, m2, m3, m4 );
    1515        }
  • benchmark/schedext/cfa1.cfa

    r9e63a2b r2316525  
    44#include <stdio.h>
    55
    6 #include "bench.h"
     6#include "../bench.h"
    77
    88volatile int go = 0;
    99
    10 monitor M {};
    11 M m1;
     10monitor M {} m1;
    1211
    13 void __attribute__((noinline)) call( M & mutex a1 ) {}
     12void __attribute__((noinline)) call( M & mutex p1 ) {}
    1413
    15 int  __attribute__((noinline)) wait( M & mutex a1 ) {
     14void __attribute__((noinline)) wait( M & mutex p1 ) {
    1615        go = 1;
    17         for ( i; times ) {
    18                 waitfor(call : a1);
     16        for ( times ) {
     17                waitfor( call : p1 );
    1918        }
    2019        go = 0;
    21         return 0;
    2220}
    2321
    2422thread T {};
    25 void ^?{}( T & mutex this ) {}
    2623void main( T & ) {
    27         while(go == 0) { yield(); }
     24        while ( go == 0 ) { yield(); }
    2825        BENCH(
    29                 while(go == 1) { call(m1); },
     26                while ( go == 1 ) { call( m1 ); },
    3027                result
    3128        )
     
    3633        BENCH_START()
    3734        T t;
    38         return wait( m1 );
     35        wait( m1 );
    3936}
    4037
  • benchmark/schedext/cfa2.cfa

    r9e63a2b r2316525  
    88volatile int go = 0;
    99
    10 monitor M {};
    11 M m1, m2;
     10monitor M {} m1, m2;
    1211
    13 void __attribute__((noinline)) call( M & mutex a1, M & mutex a2 ) {}
     12void __attribute__((noinline)) call( M & mutex p1, M & mutex p2 ) {}
    1413
    15 int  __attribute__((noinline)) wait( M & mutex a1, M & mutex a2 ) {
     14void __attribute__((noinline)) wait( M & mutex p1, M & mutex p2 ) {
    1615        go = 1;
    17         for ( i; times ) {
    18                 waitfor(call : a1, a2);
     16        for ( times ) {
     17                waitfor( call : p1, p2 );
    1918        }
    2019        go = 0;
    21         return 0;
    2220}
    2321
    2422thread T {};
    25 void ^?{}( T & mutex this ) {}
    2623void main( T & ) {
    27         while(go == 0) { yield(); }
     24        while( go == 0 ) { yield(); }
    2825        BENCH(
    29                 while(go == 1) { call(m1, m2); },
     26                while ( go == 1 ) { call( m1, m2 ); },
    3027                result
    3128        )
     
    3633        BENCH_START()
    3734        T t;
    38         return wait( m1, m2 );
     35        wait( m1, m2 );
    3936}
    4037
  • benchmark/schedext/cfa4.cfa

    r9e63a2b r2316525  
    88volatile int go = 0;
    99
    10 monitor M {};
    11 M m1, m2, m3, m4;
     10monitor M {} m1, m2, m3, m4;
    1211
    13 void __attribute__((noinline)) call( M & mutex a1, M & mutex a2, M & mutex a3, M & mutex a4 ) {}
     12void __attribute__((noinline)) call( M & mutex p1, M & mutex p2, M & mutex p3, M & mutex p4 ) {}
    1413
    15 int  __attribute__((noinline)) wait( M & mutex a1, M & mutex a2, M & mutex a3, M & mutex a4 ) {
     14void __attribute__((noinline)) wait( M & mutex p1, M & mutex p2, M & mutex p3, M & mutex p4 ) {
    1615        go = 1;
    17         for ( i; times ) {
    18                 waitfor( call : a1, a2, a3, a4 );
     16        for ( times ) {
     17                waitfor( call : p1, p2, p3, p4 );
    1918        }
    2019        go = 0;
    21         return 0;
    2220}
    2321
    2422thread T {};
    25 void ^?{}( T & mutex this ) {}
    2623void main( T & ) {
    27         while(go == 0) { yield(); }
     24        while( go == 0 ) { yield(); }
    2825        BENCH(
    29                 while(go == 1) { call(m1, m2, m3, m4); },
     26                while( go == 1 ) { call( m1, m2, m3, m4 ); },
    3027                result
    3128        )
     
    3633        BENCH_START()
    3734        T t;
    38         return wait( m1, m2, m3, m4 );
     35        wait( m1, m2, m3, m4 );
    3936}
    4037
  • benchmark/schedext/upp.cc

    r9e63a2b r2316525  
    1111        int __attribute__((noinline)) wait() {
    1212                go = 1;
    13                 for (size_t i = 0; i < times; i++) {
     13                for ( size_t i = 0; i < times; i++ ) {
    1414                        _Accept(call);
    1515                }
     
    1717                return 0;
    1818        }
    19 };
    20 
    21 M m;
     19} m;
    2220
    2321_Task T {
    2422        void main() {
    25                 while(go == 0) { yield(); }
     23                while ( go == 0 ) { yield(); }
    2624                BENCH(
    27                         while(go == 1) { m.call(); },
     25                        while ( go == 1 ) { m.call(); },
    2826                        result
    2927                )
  • benchmark/schedint/cfa1.cfa

    r9e63a2b r2316525  
    44#include <stdio.h>
    55
    6 #include "bench.h"
     6#include "../bench.h"
    77
    88volatile int go = 0;
     9condition c;
     10monitor M {} m1;
    911
    10 condition c;
    11 monitor M {};
    12 M m1;
    13 
    14 void __attribute__((noinline)) call( M & mutex a1 ) {
    15         signal(c);
     12void __attribute__((noinline)) call( M & mutex p1 ) {
     13        signal( c );
    1614}
    1715
    18 int  __attribute__((noinline)) wait( M & mutex a1 ) {
     16void __attribute__((noinline)) wait( M & mutex p1 ) {
    1917        go = 1;
     18        for ( times ) {
     19                wait( c );
     20        }
     21        go = 0;
     22}
     23
     24thread T {};
     25void main( T & ) {
     26        while ( go == 0 ) { yield(); }
    2027        BENCH(
    21                 for ( i; times ) {
    22                         wait(c);
    23                 },
     28                while ( go == 1 ) { call( m1 ); },
    2429                result
    2530        )
    2631        printf( "%g\n", result );
    27         go = 0;
    28         return 0;
    29 }
    30 
    31 thread T {};
    32 void ^?{}( T & mutex ) {}
    33 void main( T & ) {
    34         while(go == 0) { yield(); }
    35         while(go == 1) { call(m1); }
    36 
    3732}
    3833
     
    4035        BENCH_START()
    4136        T t;
    42         return wait(m1);
     37        wait( m1 );
    4338}
    4439
  • benchmark/schedint/cfa2.cfa

    r9e63a2b r2316525  
    44#include <stdio.h>
    55
    6 #include "bench.h"
     6#include "../bench.h"
    77
    88volatile int go = 0;
     9condition c;
     10monitor M {} m1, m2;
    911
    10 condition c;
    11 monitor M {};
    12 M m1, m2;
    13 
    14 void __attribute__((noinline)) call( M & mutex a1, M & mutex a2 ) {
    15         signal(c);
     12void __attribute__((noinline)) call( M & mutex p1, M & mutex p2 ) {
     13        signal( c );
    1614}
    1715
    18 int  __attribute__((noinline)) wait( M & mutex a1, M & mutex a2 ) {
     16void __attribute__((noinline)) wait( M & mutex p1, M & mutex p2 ) {
    1917        go = 1;
     18        for ( times ) {
     19                wait( c );
     20        }
     21        go = 0;
     22}
     23
     24thread T {};
     25void main( T & ) {
     26        while ( go == 0 ) { yield(); }
    2027        BENCH(
    21                 for ( i; times ) {
    22                         wait(c);
    23                 },
     28                while ( go == 1 ) { call( m1, m2 ); },
    2429                result
    2530        )
    2631        printf( "%g\n", result );
    27         go = 0;
    28         return 0;
    29 }
    30 
    31 thread T {};
    32 void ^?{}( T & mutex this ) {}
    33 void main( T & ) {
    34         while(go == 0) { yield(); }
    35         while(go == 1) { call(m1, m2); }
    36 
    3732}
    3833
     
    4035        BENCH_START()
    4136        T t;
    42         return wait(m1, m2);
     37        wait( m1, m2 );
    4338}
    4439
  • benchmark/schedint/cfa4.cfa

    r9e63a2b r2316525  
    77
    88volatile int go = 0;
     9condition c;
     10monitor M {} m1, m2, m3, m4;
    911
    10 condition c;
    11 monitor M {};
    12 M m1, m2, m3, m4;
    13 
    14 void __attribute__((noinline)) call( M & mutex a1, M & mutex a2, M & mutex a3, M & mutex a4 ) {
    15         signal(c);
     12void __attribute__((noinline)) call( M & mutex p1, M & mutex p2, M & mutex p3, M & mutex p4 ) {
     13        signal( c );
    1614}
    1715
    18 int  __attribute__((noinline)) wait( M & mutex a1, M & mutex a2, M & mutex a3, M & mutex a4 ) {
     16void __attribute__((noinline)) wait( M & mutex p1, M & mutex p2, M & mutex p3, M & mutex p4 ) {
    1917        go = 1;
     18        for ( times ) {
     19                wait( c );
     20        }
     21        go = 0;
     22}
     23
     24thread T {};
     25void main( T & ) {
     26        while ( go == 0 ) { yield(); }
    2027        BENCH(
    21                 for ( i; times ) {
    22                         wait(c);
    23                 },
     28                while ( go == 1 ) { call( m1, m2, m3, m4 ); },
    2429                result
    2530        )
    2631        printf( "%g\n", result );
    27         go = 0;
    28         return 0;
    29 }
    30 
    31 thread T {};
    32 void ^?{}( T & mutex this ) {}
    33 void main( T & ) {
    34         while(go == 0) { yield(); }
    35         while(go == 1) { call(m1, m2, m3, m4); }
    36 
    3732}
    3833
     
    4035        BENCH_START()
    4136        T t;
    42         return wait(m1, m2, m3, m4);
     37        wait( m1, m2, m3, m4 );
    4338}
    4439
Note: See TracChangeset for help on using the changeset viewer.