Changeset 269

Timestamp:

Jan 13, 2014, 3:23:38 PM (10 years ago)

Author:

cfuguet

Message:

Modifying the sort application to use the giet_thread_id()
function instead of the giet_proc_id(). This allows this
application to be executed in any processor.

File:

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

soft/giet_vm/sort/main.c

@@ -31 +31 @@
 //            processor id and the first processor must have id 0.
 //
-//      TODO: Replace processor id based identification mechanism by one based
-//            on thread id
-//
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -39 +36 @@
 #include "hard_config.h"
 #include "barrier.h"
-#include "spin_lock.h"
 
 //////////////////////////////////////////////////////////////////////////
@@ -60 +56 @@
 
 #if (VERBOSE == 1)
-#   if (NB_TTY_CHANNELS > 1)
-#       define printf(...)     giet_tty_printf(__VA_ARGS__)
-#       define puts(...)       giet_tty_puts(__VA_ARGS__)
-
-#   else    // NB_TTY_CHANNELS == 0
-#       define printf(...) \
-        lock_acquire(&tty_lock); \
-        giet_tty_printf(__VA_ARGS__); \
-        lock_release(&tty_lock);  
-#   endif
+#   define printf(...)     giet_tty_printf(__VA_ARGS__)
+#   define puts(...)       giet_tty_puts(__VA_ARGS__)
 #else       // VERBOSE == 0
 #   define printf(...)
@@ -75 +63 @@
 #endif
 
-#define task0_printf(...) if(procid() == 0) giet_tty_printf(__VA_ARGS__)
+#define task0_printf(...) if(thread_id == 0) giet_tty_printf(__VA_ARGS__)
 
 #define exit    giet_exit
@@ -104 +92 @@
 
 giet_barrier_t barrier[8];
-giet_lock_t tty_lock;
 
 __attribute__ ((constructor)) void sort()
 {
-    int proc_id = procid();
+    int thread_id = giet_thread_id();
+
     int * src_array;
     int * dst_array;
     int i;
 
-    task0_printf("Starting SORT application\n");
+    task0_printf("[ Thread 0 ] Starting SORT application\n");
+
+    ///////////////////////////
+    // Barriers Initialization
+
+    for (i = 0; i < __builtin_ctz(NPROCS); i++)
+    {
+        barrier_init(&barrier[i], NPROCS >> i);
+    }
 
     ////////////////////////
     // Array Initialization
 
-    for (i = IPP * proc_id; i < IPP * (proc_id + 1); i++)
+    for (i = IPP * thread_id; i < IPP * (thread_id + 1); i++)
     {
         array0[i] = rand();
     }
-
-    ///////////////////////////
-    // Barriers Initialization
-
-    while((proc_id != 0) && (init_ok == 0));
-
-    if (proc_id == 0)
-    {
-        for (i = 0; i < __builtin_ctz(NPROCS); i++)
-        {
-            task0_printf("Initializing barrier %d with %d\n", i, NPROCS >> i);
-            barrier_init(&barrier[i], NPROCS >> i);
-        }
-
-        asm volatile ("sync");
-        init_ok = 1;
-    }
-
-    asm volatile ("sync");
-    barrier_wait(&barrier[0]);
 
     ///////////////////////////////////
     // Parallel sort of array elements
 
-    printf("Proc %d Stage 0: Processor Sorting...\n\r", proc_id);
-
-    bubbleSort(array0, IPP, IPP * proc_id);
-
-    printf("Proc %d Finishing Stage 0...\n\r", proc_id);
+    printf("[ Thread %d ] Stage 0: Processor Sorting...\n\r", thread_id);
+
+    bubbleSort(array0, IPP, IPP * thread_id);
+
+    printf("[ Thread %d ] Finishing Stage 0\n\r", thread_id);
 
     for (i = 0; i < __builtin_ctz(NPROCS); i++)
@@ -157 +133 @@
         barrier_wait(&barrier[i]);
 
-        printf("Proc %d Stage %d: Starting...\n\r", proc_id, i+1);
-
-        if((proc_id % (2 << i)) != 0) exit();
+        if((thread_id % (2 << i)) != 0)
+        {
+            printf("[ Thread %d ] Quits\n\r", thread_id);
+            exit();
+        }
+
+        printf("[ Thread %d ] Stage %d: Starting...\n\r", thread_id, i+1);
 
         if((i % 2) == 0)
@@ -174 +154 @@
         merge(src_array, dst_array
                 , IPP << i
-                , IPP * proc_id
-                , IPP * (proc_id + (1 << i))
-                , IPP * proc_id
+                , IPP * thread_id
+                , IPP * (thread_id + (1 << i))
+                , IPP * thread_id
                 );
 
-        printf("Proc %d Finishing Stage %d...\n\r", proc_id, i + 1);
+        printf("[ Thread %d ] Finishing Stage %d\n\r", thread_id, i + 1);
     }
 
@@ -188 +168 @@
     // Verify the resulting array
 
-    if(proc_id == 0)
+    if(thread_id == 0)
     {
         success = 1;
@@ -205 +185 @@
         if (success)
         {
-            printf("Success!!\n\r");
+            printf("[ Thread 0 ] Success!!\n\r");
         }
         else
         {
-            printf("Failure!! Incorrect element: %d\n\r", failure_index);
+            printf("[ Thread 0 ] Failure!! Incorrect element: %d\n\r", failure_index);