Changeset c352893 for src/benchmark


Ignore:
Timestamp:
May 5, 2017, 3:42:38 PM (9 years ago)
Author:
Andrew Beach <ajbeach@…>
Branches:
ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc
Children:
f04288f
Parents:
f57668a (diff), 982ed5b (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' of plg.uwaterloo.ca:software/cfa/cfa-cc

Quick save while I switch computers.

Location:
src/benchmark
Files:
3 added
6 edited

Legend:

Unmodified
Added
Removed

  • src/benchmark/CorCtxSwitch.c

    rf57668a rc352893  
    33#include <thread>
    44
    5 #include <unistd.h>                                     // sysconf
    6 #include <sys/times.h>                                  // times
    7 #include <time.h>
    8 
    9 inline unsigned long long int Time() {
    10     timespec ts;
    11     clock_gettime(
    12 #if defined( __linux__ )
    13          CLOCK_THREAD_CPUTIME_ID,
    14 #elif defined( __freebsd__ )
    15          CLOCK_PROF,
    16 #elif defined( __solaris__ )
    17          CLOCK_HIGHRES,
    18 #else
    19     #error uC++ : internal error, unsupported architecture
    20 #endif
    21          &ts );
    22     return 1000000000LL * ts.tv_sec + ts.tv_nsec;
    23 } // Time
     5#include "bench.h"
    246
    257coroutine GreatSuspender {};
    … …  
    4224}
    4325
    44 #ifndef N
    45 #define N 100000000
    46 #endif
    47 
    4826int main() {
    4927        const unsigned int NoOfTimes = N;

  • src/benchmark/Makefile.am

    rf57668a rc352893  
    4444        @rm -f ./a.out
    4545
     46sched-int:
     47        ${CC} ${AM_CFLAGS} ${CFLAGS} ${ccflags} @CFA_FLAGS@ -nodebug -lrt -DN=10000000 SchedInt.c
     48        @for number in 1 2 3 4 5 6 7 8 9 10; do \
     49                ./a.out ; \
     50        done
     51        @rm -f ./a.out
     52
     53monitor:
     54        ${CC} ${AM_CFLAGS} ${CFLAGS} ${ccflags} @CFA_FLAGS@ -nodebug -lrt -DN=10000000 Monitor.c
     55        @for number in 1 2 3 4 5 6 7 8 9 10; do \
     56                ./a.out ; \
     57        done
     58        @rm -f ./a.out
     59
    4660csv-data:
    4761        @${CC} ${AM_CFLAGS} ${CFLAGS} ${ccflags} @CFA_FLAGS@ -nodebug -lrt -quiet -DN=10000000 csv-data.c

  • src/benchmark/Makefile.in

    rf57668a rc352893  
    492492        @rm -f ./a.out
    493493
     494sched-int:
     495        ${CC} ${AM_CFLAGS} ${CFLAGS} ${ccflags} @CFA_FLAGS@ -nodebug -lrt -DN=10000000 SchedInt.c
     496        @for number in 1 2 3 4 5 6 7 8 9 10; do \
     497                ./a.out ; \
     498        done
     499        @rm -f ./a.out
     500
     501monitor:
     502        ${CC} ${AM_CFLAGS} ${CFLAGS} ${ccflags} @CFA_FLAGS@ -nodebug -lrt -DN=10000000 Monitor.c
     503        @for number in 1 2 3 4 5 6 7 8 9 10; do \
     504                ./a.out ; \
     505        done
     506        @rm -f ./a.out
     507
    494508csv-data:
    495509        @${CC} ${AM_CFLAGS} ${CFLAGS} ${ccflags} @CFA_FLAGS@ -nodebug -lrt -quiet -DN=10000000 csv-data.c

  • src/benchmark/ThrdCtxSwitch.c

    rf57668a rc352893  
    33#include <thread>
    44
    5 #include <unistd.h>                                     // sysconf
    6 #include <sys/times.h>                                  // times
    7 #include <time.h>
    8 
    9 inline unsigned long long int Time() {
    10     timespec ts;
    11     clock_gettime(
    12 #if defined( __linux__ )
    13          CLOCK_THREAD_CPUTIME_ID,
    14 #elif defined( __freebsd__ )
    15          CLOCK_PROF,
    16 #elif defined( __solaris__ )
    17          CLOCK_HIGHRES,
    18 #else
    19     #error uC++ : internal error, unsupported architecture
    20 #endif
    21          &ts );
    22     return 1000000000LL * ts.tv_sec + ts.tv_nsec;
    23 } // Time
    24  
    25 #ifndef N
    26 #define N 100000000
    27 #endif
     5#include "bench.h"
    286
    297int main() {

  • src/benchmark/bench.c

    rf57668a rc352893  
    44#include <thread>
    55
    6 #include <unistd.h>                                     // sysconf
    7 #include <sys/times.h>                                  // times
    8 #include <time.h>
    9 
    10 inline unsigned long long int Time() {
    11     timespec ts;
    12     clock_gettime(
    13 #if defined( __linux__ )
    14          CLOCK_THREAD_CPUTIME_ID,
    15 #elif defined( __freebsd__ )
    16          CLOCK_PROF,
    17 #elif defined( __solaris__ )
    18          CLOCK_HIGHRES,
    19 #else
    20     #error uC++ : internal error, unsupported architecture
    21 #endif
    22          &ts );
    23     return 1000000000LL * ts.tv_sec + ts.tv_nsec;
    24 } // Time
     6#include "bench.h"
    257
    268//=======================================

  • src/benchmark/csv-data.c

    rf57668a rc352893  
    11#include <fstream>
     2#include <monitor>
    23#include <stdlib>
    34#include <thread>
    45
    5 extern "C" {
    6 #include <unistd.h>                                     // sysconf
    7 #include <sys/times.h>                                  // times
    8 #include <time.h>
    9 }
    10 
    11 inline unsigned long long int Time() {
    12     timespec ts;
    13     clock_gettime(
    14 #if defined( __linux__ )
    15          CLOCK_THREAD_CPUTIME_ID,
    16 #elif defined( __freebsd__ )
    17          CLOCK_PROF,
    18 #elif defined( __solaris__ )
    19          CLOCK_HIGHRES,
    20 #else
    21     #error uC++ : internal error, unsupported architecture
    22 #endif
    23          &ts );
    24     return 1000000000LL * ts.tv_sec + ts.tv_nsec;
    25 } // Time
     6#include "bench.h"
    267
    278coroutine GreatSuspender {};
    … …  
    4829#endif
    4930
    50 
    51 
     31//-----------------------------------------------------------------------------
     32// coroutine context switch
    5233long long int measure_coroutine() {
    5334        const unsigned int NoOfTimes = N;
    … …  
    6748}
    6849
     50//-----------------------------------------------------------------------------
     51// thread context switch
    6952long long int measure_thread() {
    7053        const unsigned int NoOfTimes = N;
    … …  
    8063}
    8164
     65//-----------------------------------------------------------------------------
     66// single monitor entry
     67monitor mon_t {};
     68void dummy( mon_t * mutex m ) {}
     69
     70long long int measure_1_monitor_entry() {
     71        const unsigned int NoOfTimes = N;
     72        long long int StartTime, EndTime;
     73        mon_t mon;
     74
     75        StartTime = Time();
     76        for ( volatile unsigned int i = 0; i < NoOfTimes; i += 1 ) {
     77                dummy( &mon );
     78        }
     79        EndTime = Time();
     80
     81        return ( EndTime - StartTime ) / NoOfTimes;
     82}
     83
     84//-----------------------------------------------------------------------------
     85// multi monitor entry
     86void dummy( mon_t * mutex m1,  mon_t * mutex m2 ) {}
     87
     88long long int measure_2_monitor_entry() {
     89        const unsigned int NoOfTimes = N;
     90        long long int StartTime, EndTime;
     91        mon_t mon1, mon2;
     92
     93        StartTime = Time();
     94        for ( volatile unsigned int i = 0; i < NoOfTimes; i += 1 ) {
     95                dummy( &mon1, &mon2 );
     96        }
     97        EndTime = Time();
     98
     99        return ( EndTime - StartTime ) / NoOfTimes;
     100}
     101
     102//-----------------------------------------------------------------------------
     103// single internal sched entry
     104mon_t mon1;
     105
     106condition cond1a;
     107condition cond1b;
     108
     109thread thrd1a { long long int * out; };
     110thread thrd1b {};
     111
     112void ?{}( thrd1a * this, long long int * out ) {
     113        this->out = out;
     114}
     115
     116void side1A( mon_t * mutex a, long long int * out ) {
     117        long long int StartTime, EndTime;
     118
     119        StartTime = Time();
     120        for( int i = 0;; i++ ) {
     121                signal(&cond1a);
     122                if( i > N ) break;
     123                wait(&cond1b);
     124        }
     125        EndTime = Time();
     126
     127        *out = ( EndTime - StartTime ) / N;
     128}
     129
     130void side1B( mon_t * mutex a ) {
     131        for( int i = 0;; i++ ) {
     132                signal(&cond1b);
     133                if( i > N ) break;
     134                wait(&cond1a);
     135        }
     136}
     137
     138void main( thrd1a * this ) { side1A( &mon1, this->out ); }
     139void main( thrd1b * this ) { side1B( &mon1 ); }
     140
     141long long int measure_1_sched_int() {
     142        long long int t;
     143        {
     144                thrd1a a = { &t };
     145                thrd1b b;
     146        }
     147        return t;
     148}
     149
     150//-----------------------------------------------------------------------------
     151// multi internal sched entry
     152mon_t mon2;
     153
     154condition cond2a;
     155condition cond2b;
     156
     157thread thrd2a { long long int * out; };
     158thread thrd2b {};
     159
     160void ?{}( thrd2a * this, long long int * out ) {
     161        this->out = out;
     162}
     163
     164void side2A( mon_t * mutex a, mon_t * mutex b, long long int * out ) {
     165        long long int StartTime, EndTime;
     166
     167        StartTime = Time();
     168        for( int i = 0;; i++ ) {
     169                signal(&cond2a);
     170                if( i > N ) break;
     171                wait(&cond2b);
     172        }
     173        EndTime = Time();
     174
     175        *out = ( EndTime - StartTime ) / N;
     176}
     177
     178void side2B( mon_t * mutex a, mon_t * mutex b ) {
     179        for( int i = 0;; i++ ) {
     180                signal(&cond2b);
     181                if( i > N ) break;
     182                wait(&cond2a);
     183        }
     184}
     185
     186void main( thrd2a * this ) { side2A( &mon1, &mon2, this->out ); }
     187void main( thrd2b * this ) { side2B( &mon1, &mon2 ); }
     188
     189long long int measure_2_sched_int() {
     190        long long int t;
     191        {
     192                thrd2a a = { &t };
     193                thrd2b b;
     194        }
     195        return t;
     196}
     197
     198//-----------------------------------------------------------------------------
     199// main loop
    82200int main()
    83201{
    84         sout | time(NULL) | ',' | measure_coroutine() | ',' | measure_thread() | endl;
    85 }
     202        sout | time(NULL) | ',';
     203        sout | measure_coroutine() | ',';
     204        sout | measure_thread() | ',';
     205        sout | measure_1_monitor_entry() | ',';
     206        sout | measure_2_monitor_entry() | ',';
     207        sout | measure_1_sched_int() | ',';
     208        sout | measure_2_sched_int() | endl;
     209}
Note: See TracChangeset for help on using the changeset viewer.