Changeset a91dcc2 for src/examples

Timestamp:

Jan 30, 2017, 12:57:57 PM (8 years ago)

Author:

Thierry Delisle <tdelisle@…>

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:

6dc78dee, a9fc180

Parents:

059531a6

Message:

Modified benchmark to only display relevant information

File:

• src/examples/Bench.c (modified) (6 diffs)

src/examples/Bench.c

@@ -1 @@
-
 
 #include <fstream>
+#include <stdlib>
 #include <threads>
 
@@ -25 +25 @@
 
 //=======================================
+// time struct
+//=======================================
+
+// prevent dead-code removal
+struct StructDummy {
+        volatile int i;
+};
+
+void ?{}(StructDummy * this) __attribute__(( noinline )) {
+        this->i = 2;
+}
+
+int get_i(StructDummy * this) {
+        return this->i;
+}
+
+forall( dtype T | { int get_i(T*); } )
+int bidirectional( StructDummy * this ) __attribute__(( noinline )) {
+        return get_i( this );
+}
+
+void BlockStructCreateDelete( int N ) {
+    long long int StartTime, EndTime;
+
+    StartTime = Time();
+    for ( int i = 0; i < N; i += 1 ) {
+        StructDummy dummy;
+    }
+    EndTime = Time();
+    sout | "\t " | ( EndTime - StartTime ) / N;
+}
+
+void DynamicStructCreateDelete( int N ) {
+    long long int StartTime, EndTime;
+
+    StartTime = Time();
+    for ( int i = 0; i < N; i += 1 ) {
+        StructDummy *dummy = new();
+        delete(dummy);
+    }
+    EndTime = Time();
+    sout | "\t " | ( EndTime - StartTime ) / N;
+}
+
+void StructBidirectional( int N ) {
+    long long int StartTime, EndTime;
+    StructDummy dummy;
+    volatile int rv __attribute__(( unused ));
+
+    StartTime = Time();
+    for ( int i = 0; i < N; i += 1 ) {
+        rv = bidirectional( &dummy ); 
+    }
+    EndTime = Time();
+    sout | "\t " | ( EndTime - StartTime ) / N;
+}
+
+//=======================================
 // time coroutine
 //=======================================
+
+struct CoroutineDummy { coroutine c; };
+DECL_COROUTINE(CoroutineDummy)
+void main(CoroutineDummy * this) {}
+
+void ?{}(CoroutineDummy * this) {
+        prime(this);
+}
+
+void BlockCoroutineCreateDelete( int N ) {
+    long long int StartTime, EndTime;
+
+    StartTime = Time();
+    for ( int i = 0; i < N; i += 1 ) {
+        CoroutineDummy dummy;
+    }
+    EndTime = Time();
+    sout | "\t " | ( EndTime - StartTime ) / N;
+}
+
+void DynamicCoroutineCreateDelete( int N ) {
+    long long int StartTime, EndTime;
+
+    StartTime = Time();
+    for ( int i = 0; i < N; i += 1 ) {
+        CoroutineDummy * dummy = new();
+        delete(dummy);
+    }
+    EndTime = Time();
+    sout | "\t " | ( EndTime - StartTime ) / N;
+}
 
 struct CoroutineResume {
@@ -33 +122 @@
 };
 
-coroutine* get_coroutine(CoroutineResume* this);
-void co_main(CoroutineResume* this);
+DECL_COROUTINE(CoroutineResume)
 
 void ?{}(CoroutineResume* this, int N) {
@@ -41 +129 @@
 }
 
-coroutine* get_coroutine(CoroutineResume* this) {
-      return &this->c;
-}
-
-void co_main(CoroutineResume* this) {
+void main(CoroutineResume* this) {
         for ( int i = 1; i <= this->N; i += 1 ) {
                 suspend();
-        } // for
-} // CoroutineResume::main
+        }
+}
 
 void resumer(CoroutineResume* this) {
@@ -57 +141 @@
         for ( int i = 1; i <= this->N; i += 1 ) {
                 resume(this);
+        }
+        EndTime = Time();
+        sout | "\t " | ( EndTime - StartTime ) / this->N;
+}
+
+//=======================================
+// time task
+//=======================================
+
+struct ThreadDummy { thread t; };
+DECL_THREAD(ThreadDummy)
+void main(ThreadDummy * this) {}
+
+void BlockTaskCreateDelete( int N ) {
+    long long int StartTime, EndTime;
+
+    StartTime = Time();
+    for ( int i = 0; i < N; i += 1 ) {
+        scoped(ThreadDummy) dummy;
+    }
+    EndTime = Time();
+    sout | "\t " | ( EndTime - StartTime ) / N;
+}
+
+void DynamicTaskCreateDelete( int N ) {
+    long long int StartTime, EndTime;
+
+    StartTime = Time();
+    for ( int i = 0; i < N; i += 1 ) {
+        scoped(ThreadDummy) * dummy = new();
+        delete(dummy);
+    }
+    EndTime = Time();
+    sout | "\t " | ( EndTime - StartTime ) / N;
+}
+
+struct ContextSwitch {
+    int N;
+    long long result;
+    thread t;
+};
+
+DECL_THREAD(ContextSwitch)
+
+void main(ContextSwitch * this) {    
+        long long int StartTime, EndTime;
+
+        StartTime = Time();
+        for ( int i = 1; i <= this->N; i += 1 ) {
+            yield();
         } // for
         EndTime = Time();
-        sout | "\t " | ( EndTime - StartTime ) / this->N;
-} // CoroutineResume::resumer
+        this->result = ( EndTime - StartTime ) / this->N;
+}
+
+void ?{}(ContextSwitch * this, int N) {
+        this->N = N;
+}
+
+void ^?{}(ContextSwitch * this) {
+        sout | "\t " | this->result;
+}
+
+//=======================================
+// benchmark driver
+//=======================================
 
 
@@ -71 +217 @@
 #endif // __U_DEBUG__
 
-        sout | "\t\tcreate\tcreate\t16i/4o\t16i/4o\tresume/\tsignal/" | endl;
+        sout | "\t\tcreate\tcreate\tcall/" | endl;
         sout | "(nsecs)";
-        sout | "\t\tdelete/\tdelete/\tbytes\tbytes\tsuspend\twait" | endl;
-        sout | "\t\tblock\tdynamic\tdirect\taccept\tcycle\tcycle" | endl;
-
-        sout | "class\t";
-        sout | "\t N/A\t N/A\t N/A";
-        sout | "\t N/A\t N/A\t N/A";
-        sout | "\t" | endl;
+        sout | "\t\tdelete/\tdelete/\tctx" | endl;
+        sout | "\t\tblock\tdynamic\tcycle" | endl;
+
+        sout | "object\t";
+        BlockStructCreateDelete( NoOfTimes );
+        DynamicStructCreateDelete( NoOfTimes );
+        StructBidirectional( NoOfTimes );
+        sout | endl;
 
         sout | "coroutine";
-        sout | "\t N/A\t N/A\t N/A";
-        sout | "\t N/A";
+        BlockCoroutineCreateDelete( NoOfTimes );
+        DynamicCoroutineCreateDelete( NoOfTimes );
         {
                 CoroutineResume resumer = { NoOfTimes };
                 resumer(&resumer);
         }
-        sout | "\t N/A";
-
+        sout | endl;
+
+        sout | "task\t";
+        BlockTaskCreateDelete( NoOfTimes );
+        DynamicTaskCreateDelete( NoOfTimes );
+        {
+                scoped(ContextSwitch) dummy = { (int)NoOfTimes };               // context switch
+        }
         sout | "\t" | endl;
 }