Changeset 652 for trunk/user/sort/sort.c

Timestamp:

Nov 14, 2019, 3:56:51 PM (4 years ago)

Author:

alain

Message:

Introduce the three placement modes in "transpose", "convol', "fft" applications.

File:

• trunk/user/sort/sort.c (modified) (16 diffs)

trunk/user/sort/sort.c

@@ -69 +69 @@
 #define INSTRUMENTATION     1               // register computation times on file
 
-///////////////////////////////////////////////////////////////////////////////////
-//            Arguments for the sort() function 
-///////////////////////////////////////////////////////////////////////////////////
-
-typedef struct
-{
-    unsigned int        tid;                // continuous thread index
-    unsigned int        threads;            // total number of threads
-    pthread_barrier_t * parent_barrier;     // pointer on termination barrier
-}
-sort_args_t;
-
 ////////////////////////////////////////////////////////////////////////////////////
 //            Sort specific global variables
@@ -88 +76 @@
 int                 array1[ARRAY_LENGTH];    
 
+unsigned int        threads;                // total number of working threads
+
 pthread_barrier_t   barrier;                 // synchronisation variables
 
@@ -93 +83 @@
 //             Global variables required by parallel_pthread_create()
 /////////////////////////////////////////////////////////////////////////////////////
-
-// 2D arrays of input arguments for the <sort> threads
-// These arrays are initialised by the application main thread
-
-sort_args_t       sort_args[CLUSTERS_MAX][CORES_MAX];  // sort function arguments 
-sort_args_t     * sort_ptrs[CLUSTERS_MAX][CORES_MAX];  // pointers on arguments 
-
-// 1D array of barriers to allow the <sort> threads to signal termination 
-// this array is initialised by the pthread_parallel_create() function
-  
-pthread_barrier_t parent_barriers[CLUSTERS_MAX];       // termination barrier
 
 
@@ -174 +153 @@
 }  // end merge()
 
-//////////////////////////////
-void sort( sort_args_t * ptr )
+///////////////////////////////////////////////
+void sort( pthread_parallel_work_args_t * ptr )
 {
     unsigned int        i;
@@ -183 +162 @@
     // get arguments
     unsigned int        tid            = ptr->tid;
-    unsigned int        threads        = ptr->threads;
-    pthread_barrier_t * parent_barrier = ptr->parent_barrier;
+    pthread_barrier_t * parent_barrier = ptr->barrier;
 
     unsigned int        items      = ARRAY_LENGTH / threads;
@@ -190 +168 @@
 
 #if DEBUG_SORT
-printf("\n[sort] start : ptr %x / tid %d / threads %d / barrier %x\n",
+printf("\n[sort] start : ptr %x / tid %d / threads %d / parent_barrier %x\n",
 ptr, tid, threads, parent_barrier );
 #endif
@@ -249 +227 @@
     }  // en for stages 
 
-    // sort thread signal completion to main thread
+    // sort thread signal completion to pthtread_parallel_create()
     pthread_barrier_wait( parent_barrier );
 
@@ -269 +247 @@
     unsigned int           y_size;             // number of columns
     unsigned int           ncores;             // number of cores per cluster
-    unsigned int           total_threads;      // total number of threads
-    unsigned int           x;                  // X coordinate for a sort thread
-    unsigned int           y;                  // Y coordinate for a sort thread
-    unsigned int           cxy;                // cluster identifier for a sort thead
-    unsigned int           lid;                // core local index for a thread
-    unsigned int           tid;                // sort thread continuous index
     pthread_barrierattr_t  barrier_attr;       // barrier attributes (used for DQT)
     unsigned int           n;                  // index in array to sort
@@ -285 +257 @@
     get_cycle( &start_cycle );
  
-    // compute number of threads (one thread per core)
+    // compute number of working threads (one thread per core)
     get_config( &x_size , &y_size , &ncores );
-    total_threads = x_size * y_size * ncores;
+    threads = x_size * y_size * ncores;
 
     // compute covering DQT size an level
@@ -294 +266 @@
 
     // checks number of threads
-    if ( (total_threads != 1)   && (total_threads != 2)   && (total_threads != 4)   && 
-         (total_threads != 8)   && (total_threads != 16 ) && (total_threads != 32)  && 
-         (total_threads != 64)  && (total_threads != 128) && (total_threads != 256) && 
-         (total_threads != 512) && (total_threads != 1024) )
+    if ( (threads != 1)   && (threads != 2)   && (threads != 4)   && 
+         (threads != 8)   && (threads != 16 ) && (threads != 32)  && 
+         (threads != 64)  && (threads != 128) && (threads != 256) && 
+         (threads != 512) && (threads != 1024) )
     {
         printf("\n[sort] ERROR : number of cores must be power of 2\n");
@@ -304 +276 @@
 
     // check array size
-    if ( ARRAY_LENGTH % total_threads) 
+    if ( ARRAY_LENGTH % threads) 
     {
         printf("\n[sort] ERROR : array size must be multiple of number of threads\n");
@@ -311 +283 @@
 
     printf("\n[sort] main starts / %d threads / %d items / pid %x / cycle %d\n",
-    total_threads, ARRAY_LENGTH, getpid(), (unsigned int)start_cycle );
+    threads, ARRAY_LENGTH, getpid(), (unsigned int)start_cycle );
 
     // initialize barrier
@@ -319 +291 @@
         barrier_attr.y_size   = y_size;
         barrier_attr.nthreads = ncores;
-        error = pthread_barrier_init( &barrier, &barrier_attr , total_threads );
+        error = pthread_barrier_init( &barrier, &barrier_attr , threads );
     }
     else // use SIMPLE_BARRIER
     {
-        error = pthread_barrier_init( &barrier, NULL , total_threads );
+        error = pthread_barrier_init( &barrier, NULL , threads );
     }
 
@@ -352 +324 @@
 #endif
 
-    // build array of arguments for the <sort> threads
-    for (x = 0 ; x < x_size ; x++)
-    {
-        for (y = 0 ; y < y_size ; y++)
-        {
-            // compute cluster identifier
-            cxy = HAL_CXY_FROM_XY( x , y );
-
-            for ( lid = 0 ; lid < ncores ; lid++ )
-            {
-                // compute thread continuous index
-                tid = (((x * y_size) + y) * ncores) + lid;
-
-                // initialize 2D array of arguments
-                sort_args[cxy][lid].tid            = tid;
-                sort_args[cxy][lid].threads        = total_threads;
-                sort_args[cxy][lid].parent_barrier = &parent_barriers[cxy];
-
-                // initialize 2D array of pointers
-                sort_ptrs[cxy][lid] = &sort_args[cxy][lid];
-            }
-        }
-    }
-
     ///////////////////////////
     get_cycle( &seq_end_cycle );
@@ -386 +334 @@
     // create and execute the working threads
     if( pthread_parallel_create( root_level,
-                                 &sort,
-                                 &sort_ptrs[0][0],
-                                 &parent_barriers[0] ) )
+                                 &sort ) )
     {
         printf("\n[sort] ERROR : cannot create threads\n");
@@ -412 +358 @@
 #if CHECK_RESULT
     int    success = 1;
-    int *  res_array = ( (total_threads ==   2) ||
-                         (total_threads ==   8) || 
-                         (total_threads ==  32) || 
-                         (total_threads == 128) || 
-                         (total_threads == 512) ) ? array1 : array0;
+    int *  res_array = ( (threads ==   2) ||
+                         (threads ==   8) || 
+                         (threads ==  32) || 
+                         (threads == 128) || 
+                         (threads == 512) ) ? array1 : array0;
 
     for( n=0 ; n<(ARRAY_LENGTH-2) ; n++ )