Changeset edb6f79 for src/tests/concurrent/examples/quickSort.c

Timestamp:

Dec 13, 2017, 6:24:17 PM (5 years ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

ADT, aaron-thesis, arm-eh, 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:

a1ecdd1

Parents:

2db79e5

Message:

generic quicksort, not working

File:

• src/tests/concurrent/examples/quickSort.c (modified) (7 diffs)

src/tests/concurrent/examples/quickSort.c

@@ -9 +9 @@
 // Created On       : Wed Dec  6 12:15:52 2017
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Dec 11 17:00:25 2017
-// Update Count     : 126
+// Last Modified On : Wed Dec 13 18:20:18 2017
+// Update Count     : 138
 // 
 
@@ -19 +19 @@
 #include <string.h>                                                                             // strcmp
 
+forall( otype T | { T ?<?( T, T ); } )
 thread Quicksort {
-        int * values;                                                                           // communication variables
+        T * values;                                                                                     // communication variables
         int low, high, depth;
 };
 
-void ?{}( Quicksort & qs, int values[], int size, int depth ) {
+forall( otype T | { T ?<?( T, T ); } )
+void ?{}( Quicksort(T) & qs, T values[], int size, int depth ) {
         qs.values = values;  qs.low = 0;  qs.high = size;  qs.depth = depth;
 } // Quicksort
 
-void main( Quicksort & qs ) {
+forall( otype T | { T ?<?( T, T ); } )
+void main( Quicksort(T) & qs ) {
         // nested routines: information hiding
 
-        void ?{}( Quicksort & qs, int values[], int low, int high, int depth ) {
+        void ?{}( Quicksort(T) & qs, T values[], int low, int high, int depth ) {
                 qs.values = values;  qs.low = low;  qs.high = high;  qs.depth = depth;
         } // Quicksort
 
-        void sort( int values[], int low, int high, int depth ) {
+        void sort( T values[], int low, int high, int depth ) {
                 int left, right;                                                                // index to left/right-hand side of the values
-                int pivot;                                                                              // pivot value of values
-                int swap;                                                                               // temporary
+                T pivot;                                                                                // pivot value of values
+                T swap;                                                                                 // temporary
 
                 //verify();                                                                             // check for stack overflow due to recursion
@@ -65 +68 @@
                                 depth -= 1;
                                 //sout << &uThisTask() << " " << depth << endl;
-                                Quicksort rqs = { values, low, right, depth }; // concurrently sort upper half
+                                Quicksort(T) rqs = { values, low, right, depth }; // concurrently sort upper half
                                 //Quicksort lqs( values, left, high, depth ); // concurrently sort lower half
                                 sort( values, left, high, depth );              // concurrently sort lower half
@@ -92 +95 @@
         exit( EXIT_FAILURE );                                                           // TERMINATE!
 } // usage
+
+
+#define ELEMTYPE int
 
 int main( int argc, char * argv[] ) {
@@ -134 +140 @@
                         unsortedfile | size;                                            // read number of elements in the list
                   if ( eof( unsortedfile ) ) break;
-                        int * values = anew( size );                            // values to be sorted, too large to put on stack
+                        ELEMTYPE * values = anew( size );                       // values to be sorted, too large to put on stack
                         for ( int counter = 0; counter < size; counter += 1 ) { // read unsorted numbers
                                 unsortedfile | values[counter];
@@ -143 +149 @@
                         sortedfile | endl;
                         if ( size > 0 ) {                                                       // values to sort ?
-                                Quicksort QS = { values, size - 1, 0 }; // sort values
+                                Quicksort(ELEMTYPE) QS = { values, size - 1, 0 }; // sort values
                         } // wait until sort tasks terminate
                         for ( int counter = 0; counter < size; counter += 1 ) { // print sorted list
@@ -159 +165 @@
                 processor processors[ (1 << depth) - 1 ] __attribute__(( unused )); // create 2^depth-1 kernel threads
 
-                int * values = anew( size );                                    // values to be sorted, too large to put on stack
+                ELEMTYPE * values = anew( size );                               // values to be sorted, too large to put on stack
                 for ( int counter = 0; counter < size; counter += 1 ) { // generate unsorted numbers
                         values[counter] = size - counter;                       // descending values
                 } // for
                 {
-                        Quicksort QS = { values, size - 1, depth }; // sort values
+                        Quicksort(ELEMTYPE) QS = { values, size - 1, depth }; // sort values
                 } // wait until sort tasks terminate