Changeset 502 for soft/giet_vm/applications/sort/main.c

Timestamp:

Feb 8, 2015, 9:20:45 PM (9 years ago)

Author:

alain

Message:

1) Introduce distributed barriers in the multi-threads applications
(classif) transpose, convol, sort, gameoflife)

2) Introducing support for architectures containing empty clusters
in the mapping of these multi-threaded applications.

3) Removing the "command line arguments" in the sort application
(replaced by the giet_procs_number() system call.

File:

• soft/giet_vm/applications/sort/main.c (modified) (13 diffs)

soft/giet_vm/applications/sort/main.c

@@ -9 +9 @@
 //      barrier routines to apply a sort algorithm in several stages.
 //
-//      Considerations :
-//
-//          - It supports up to 256 processors and the number of processors
-//            must be a power of 2.
-//
-//          - If there is only one TTY available, this application uses a spin
-//            lock to avoid several threads writting at the same time.
-//
-//          - This application must be executed on a cache coherent
-//            architecture. Otherwise some modifications must be applied
-//
-//          - The processors executing this application must have a contiguous
-//            processor id and the first processor must have id 0.
+//      Constraints :
+//
+//      - It supports up to 1024 processors and the number of processors
+//        must be a power of 2.
+//
+//      _ The array of values to be sorted (ARRAY_LENGTH) must be power of 2 
+//        larger than the number of processors.
+//
+//      - This application must be executed on a cache coherent architecture. 
 //
 ///////////////////////////////////////////////////////////////////////////////
@@ -28 +24 @@
 #include "mapping_info.h"
 #include "hard_config.h"
-#include "barrier.h"
-
-#define ARRAY_LENGTH    512 
-#define IPT             (ARRAY_LENGTH / *nb_thread) // ITEMS PER THREAD
+#include "user_barrier.h"
+
+#define ARRAY_LENGTH    4096
+#define IPT             (ARRAY_LENGTH / threads) // ITEMS PER THREAD
 
 ////////////////////////////////////////////////////////////////////////////////
-// Processors other than 0 display algorithm state
-// The processor 0 always displays some information so this does not affect him 
+// Processors other than 0 display algorithm state if VERBOSE non zero
 
 #define VERBOSE         1
 
 ////////////////////////////////////////////////////////////////////////////////
-// Define printf according to verbosity option and number of available
-// TTY
+// Define printf according to verbosity option and number of available TTY
 
 #if (VERBOSE == 1)
@@ -50 +44 @@
 
 #define task0_printf(...) if(thread_id == 0) giet_shr_printf(__VA_ARGS__)
-
-#define exit    giet_exit
-#define procid  giet_procid
-#define rand    giet_rand
 
 int array0[ARRAY_LENGTH];
@@ -73 +63 @@
         int init_pos_result);
 
-///////////////////////////////////////////////////
-// This application support at most 256 processors
-// Number of barriers = log2(nb_thread)
-
-giet_barrier_t barrier[8];
+///////////////////////////////////////////////////////
+// This application supports at most 1024 processors
+// Number of barriers = log2(threads)
+
+giet_barrier_t barrier[10];
 
 //////////////////////////////////////////
@@ -83 +73 @@
 {
     int thread_id = giet_thread_id();
-    unsigned int* nb_thread;
     int * src_array = NULL;
     int * dst_array = NULL;
@@ -91 +80 @@
     unsigned int time_end;   
 
-    giet_vobj_get_vbase( "sort" , 
-                         "sort_args", 
-                         (unsigned int*)&nb_thread );
-    
-    task0_printf("\n[ Thread 0 ] Starting sort application with %u threads "
-                 "at cycle %u\n", *nb_thread, time_start);
+    // compute number of threads (one thread per proc)
+    unsigned int x_size;
+    unsigned int y_size;
+    unsigned int nprocs;
+    unsigned int threads;
+    giet_procs_number( &x_size , &y_size , &nprocs );
+    threads = x_size * y_size * nprocs;
+
+    if ( (threads != 1)   && (threads != 2)   && (threads != 4)   && 
+         (threads != 8)   && (threads != 16 ) && (threads != 32)  && 
+         (threads != 64)  && (threads != 128) && (threads != 256) && 
+         (threads != 512) && (threads != 1024) )
+    {
+        task0_printf("[SORT ERROR] Number of processors must be power of 2\n"
+                     "  x_size = %d / y_size = %d / nprocs = %d\n",
+                     x_size , y_size , nprocs );
+        giet_exit("error");
+    }
+
+    task0_printf("\n[ Thread 0 ] Starting sort application with %d threads "
+                 "at cycle %d\n", threads, time_start);
 
     ///////////////////////////
@@ -103 +107 @@
     if (thread_id == 0)
     {
-        for (i = 0; i < __builtin_ctz(*nb_thread); i++)
-        {
-            barrier_init(&barrier[i], *nb_thread >> i);
+        for (i = 0; i < __builtin_ctz( threads ); i++)
+        {
+            barrier_init(&barrier[i], threads >> i);
         }
 
@@ -120 +124 @@
     for (i = IPT * thread_id; i < IPT * (thread_id + 1); i++)
     {
-        array0[i] = rand();
+        array0[i] = giet_rand();
     }
 
@@ -132 +136 @@
     printf("[ Thread %d ] Finishing Stage 0\n\r", thread_id);
 
-    for (i = 0; i < __builtin_ctz(*nb_thread); i++)
+    for (i = 0; i < __builtin_ctz( threads ); i++)
     {
         barrier_wait(&barrier[i]);
@@ -139 +143 @@
         {
             printf("[ Thread %d ] Quit\n\r", thread_id );
-            exit("Completed");
+            giet_exit("Completed");
         }
 
@@ -173 +177 @@
     if(thread_id != 0)
     {
-        exit("error: only thread 0 should get here");
+        giet_exit("error: only thread 0 should get here");
     }
 
@@ -196 +200 @@
     if (success)
     {
-        exit("!!! Success !!!");
+        giet_exit("!!! Success !!!");
     }
     else
@@ -206 +210 @@
             printf("array[%d] = %d\n", i, dst_array[i]);
         }
-        exit("!!!  Failure !!!");
-    }
-
-    exit("Completed");
+        giet_exit("!!!  Failure !!!");
+    }
+
+    giet_exit("Completed");
 }