Changes in src/tests/concurrent/examples/boundedBufferINT.c [58caf150:88f15ae]

File:

• src/tests/concurrent/examples/boundedBufferINT.c (modified) (5 diffs)

src/tests/concurrent/examples/boundedBufferINT.c

@@ -8 +8 @@
 // Created On       : Mon Oct 30 12:45:13 2017
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Apr 20 22:18:18 2018
-// Update Count     : 78
+// Last Modified On : Tue Jan  2 12:18:18 2018
+// Update Count     : 33
 //
 
-#include <stdlib>                                                                               // random
-#include <fstream>
+#include <stdlib>
+#include <fstream>                                                                              // random
 #include <kernel>
 #include <thread>
 #include <unistd.h>                                                                             // getpid
 
-//Duration default_preemption() { return 0; }
-
-enum { BufferSize = 50 };
-
-forall( otype T )
 monitor Buffer {
         condition full, empty;
         int front, back, count;
-        T elements[BufferSize];
+        int elements[20];
 };
 
-forall( otype T )
-void ?{}( Buffer(T) & buffer ) with( buffer ) { [front, back, count] = 0; }
+void ?{}( Buffer & buffer ) {
+        buffer.front = buffer.back = buffer.count = 0;
+}
 
-forall( otype T )
-int query( Buffer(T) & buffer ) { return buffer.count; }
+int query( Buffer & buffer ) { return buffer.count; }
 
-forall( otype T )
-void insert( Buffer(T) & mutex buffer, T elem ) with( buffer ) {
-        if ( count == BufferSize ) wait( empty );
+void insert( Buffer & mutex buffer, int elem ) with( buffer ) {
+        if ( count == 20 ) wait( empty );
         elements[back] = elem;
-        back = ( back + 1 ) % BufferSize;
+        back = ( back + 1 ) % 20;
         count += 1;
         signal( full );
 }
 
-forall( otype T )
-T remove( Buffer(T) & mutex buffer ) with( buffer ) {
+int remove( Buffer & mutex buffer ) with( buffer ) {
         if ( count == 0 ) wait( full );
-        T elem = elements[front];
-        front = ( front + 1 ) % BufferSize;
+        int elem = elements[front];
+        front = ( front + 1 ) % 20;
         count -= 1;
         signal( empty );
@@ -54 +47 @@
 }
 
-const int Sentinel = -1;
-
 thread Producer {
-        Buffer(int) & buffer;
+        Buffer & buffer;
         unsigned int N;
 };
-void main( Producer & prod ) with( prod ) {
-        for ( int i = 1; i <= N; i += 1 ) {
+void main( Producer & prod ) {
+        for ( int i = 1; i <= prod.N; i += 1 ) {
                 yield( random( 5 ) );
-                insert( buffer, 1 );
+                insert( prod.buffer, 1 );
         } // for
+        insert( prod.buffer, -1 );
 }
-void ?{}( Producer & prod, Buffer(int) * buffer, int N ) {
+void ?{}( Producer & prod, Buffer * buffer, unsigned int N ) {
         &prod.buffer = buffer;
         prod.N = N;
@@ -72 +64 @@
 
 thread Consumer {
-        Buffer(int) & buffer;
-        int & sum;                                                                                      // summation of producer values
+        Buffer & buffer;
+        int & sum;                                              // summation of producer values
 };
-void main( Consumer & cons ) with( cons ) {
-        sum = 0;
+void main( Consumer & cons ) {
+        cons.sum = 0;
         for ( ;; ) {
                 yield( random( 5 ) );
-                int item = remove( buffer );
-          if ( item == Sentinel ) break;                                        // sentinel ?
-                sum += item;
+                int item = remove( cons.buffer );
+                if ( item == -1 ) break;                                // sentinel ?
+                cons.sum += item;
         } // for
 }
-void ?{}( Consumer & cons, Buffer(int) * buffer, int & sum ) {
+void ?{}( Consumer & cons, Buffer * buffer, int * sum ) {
         &cons.buffer = buffer;
-        &cons.sum = &sum;
+        &cons.sum = sum;
 }
 
 int main() {
-        Buffer(int) buffer;
-        enum { Prods = 4, Cons = 5 };
+        Buffer buffer;
+        enum { Prods = 5, Cons = 5 };
         Producer * prods[Prods];
         Consumer * cons[Cons];
+        const int Sentinel = -1;
         int sums[Cons];
         int i;
@@ -101 +94 @@
         srandom( 1003 );
 
-        for ( i = 0; i < Cons; i += 1 ) {                                       // create consumers
-                cons[i] = new( &buffer, sums[i] );
+        for ( i = 0; i < Cons; i += 1 ) {                       // create consumers
+                cons[i] = new( &buffer, &sums[i] );
         } // for
-        for ( i = 0; i < Prods; i += 1 ) {                                      // create producers
-                prods[i] = new( &buffer, 100000 );
+        for ( i = 0; i < Prods; i += 1 ) {                      // create producers
+                prods[i] = new( &buffer, 100000u );
         } // for
 
-        for ( i = 0; i < Prods; i += 1 ) {                                      // wait for producers to finish
+        for ( i = 0; i < Prods; i += 1 ) {                      // wait for producers to finish
                 delete( prods[i] );
         } // for
-        for ( i = 0; i < Cons; i += 1 ) {                                       // generate sentinal values to stop consumers
+        for ( i = 0; i < Cons; i += 1 ) {                       // generate sentinal values to stop consumers
                 insert( buffer, Sentinel );
         } // for
         int sum = 0;
-        for ( i = 0; i < Cons; i += 1 ) {                                       // wait for consumers to finish
+        for ( i = 0; i < Cons; i += 1 ) {                       // wait for consumers to finish
                 delete( cons[i] );
                 sum += sums[i];
@@ -124 +117 @@
 // Local Variables: //
 // tab-width: 4 //
-// compile-command: "cfa boundedBufferINT.c" //
+// compile-command: "cfa boundedBuffer.c" //
 // End: //