Changeset 393

Timestamp:

Aug 11, 2014, 9:29:28 PM (10 years ago)

Author:

alain

Message:

Cosmetic

File:

• soft/giet_vm/transpose/main.c (modified) (10 diffs)

soft/giet_vm/transpose/main.c

@@ -14 +14 @@
 //
 // For each image the application makes a self test (checksum for each line).
-// The actual display on the frame buffer is optional (controled by DISPLAY_OK define)
+// The actual display on the frame buffer depends on frame buffer availability.
 ///////////////////////////////////////////////////////////////////////////////////////////////
 
@@ -26 +26 @@
 #define FILE_PATHNAME       "misc/images.raw"   // file pathname on disk
 #define NB_CLUSTERS         (X_SIZE * Y_SIZE)   // number of clusters
-#define INSTRUMENTATION_OK  1                   // display statistics on TTY when non zero
+#define INSTRUMENTATION_OK  0                   // display statistics on TTY when non zero
 
 ///////////////////////////////////////////////////////
@@ -64 +64 @@
     unsigned int l;                                                // line index for loops
     unsigned int p;                                                // pixel index for loops
+    unsigned int c;                                                // cluster index for loops
 
     unsigned int proc_id    = giet_procid();                       // global processor id
     unsigned int lpid       = proc_id % NB_PROCS_MAX;              // local processor id
-    unsigned int cluster_xy = proc_id / NB_PROCS_MAX;              // cluster index (8 bits format)
+    unsigned int cluster_xy = proc_id / NB_PROCS_MAX;              // 8 bits format
     unsigned int x          = cluster_xy >> Y_WIDTH;               // x coordinate
     unsigned int y          = cluster_xy & ((1<<Y_WIDTH)-1);       // y coordinate
@@ -75 +76 @@
     unsigned int image      = 0;                                   // image counter
 
-    unsigned int nclusters  = X_SIZE * Y_SIZE;                     // clusters with procs
-    unsigned int cluster_id = (x * Y_SIZE) + y;                    // "continuous" cluster index   
-    unsigned int ntasks     = nclusters * NB_PROCS_MAX;            // number of tasks
+    unsigned int cluster_id = (x * Y_SIZE) + y;                    // "continuous" index   
+    unsigned int ntasks     = NB_CLUSTERS * NB_PROCS_MAX;          // number of tasks
     unsigned int task_id    = (cluster_id * NB_PROCS_MAX) + lpid;  // "continuous" task index
 
-    // processor [0,0,0] makes parameters checking and barriers initialization
+    // processor [0,0,0] makes nitialisation
+    // It includes parameters checking, barriers initialization,
+    // distributed buffers allocation, and file open
     if ( proc_id == 0 )
     {
+        // Parameters checking
         if ((NB_PROCS_MAX != 1) && (NB_PROCS_MAX != 2) && (NB_PROCS_MAX != 4))
         { 
             giet_exit("[TRANSPOSE ERROR] NB_PROCS_MAX must be 1, 2 or 4");
         }
-        if ((nclusters != 1) && (nclusters != 2) && (nclusters != 4) && (nclusters != 8) &&
-            (nclusters != 16) && (nclusters != 32) )
-        {
-            giet_exit("[TRANSPOSE ERROR] number of clusters must be 2,4,8,16,32");
+        if ((NB_CLUSTERS != 1) && (NB_CLUSTERS != 2) && (NB_CLUSTERS != 4) && 
+            (NB_CLUSTERS != 8) && (NB_CLUSTERS != 16) && (NB_CLUSTERS != 32) )
+        {
+            giet_exit("[TRANSPOSE ERROR] number of clusters must be 1,2,4,8,16,32");
         }
         if ( ntasks > NN )
@@ -97 +100 @@
         }
 
+        giet_shr_printf("\n[TRANSPOSE] Processor[0,0,0] starts at cycle %d\n"
+                        " - x_size    = %d\n"
+                        " - y_size    = %d\n"
+                        " - nprocs    = %d\n"
+                        " - nclusters = %d\n"
+                        " - ntasks    = %d\n",
+                        giet_proctime(), X_SIZE, Y_SIZE, NB_PROCS_MAX, NB_CLUSTERS, ntasks );
+
+        // Barrier initialisation
         barrier_init( &barrier, ntasks );
 
-        giet_shr_printf("\n[TRANSPOSE] Proc [%d,%d,%d] completes barrier init at cycle %d\n",
-                        x, y, lpid, giet_proctime() );
-
-        giet_shr_printf(" - x_size    = %d\n", X_SIZE );
-        giet_shr_printf(" - y_size    = %d\n", Y_SIZE );
-        giet_shr_printf(" - y_size    = %d\n", Y_SIZE );
-        giet_shr_printf(" - nprocs    = %d\n", NB_PROCS_MAX );
-        giet_shr_printf(" - nclusters = %d\n", nclusters );
-        giet_shr_printf(" - ntasks    = %d\n", ntasks );
-
+        giet_shr_printf("\n[TRANSPOSE] Proc [0,0,0] completes barrier init at cycle %d\n",
+                        giet_proctime() );
+
+        // Distributed buffers allocation
+        // The buffers containing one image are distributed in clusters
+        // (one buf_in and one buf_out per cluster).
+        // Each buffer contains (NN*NN / NB_CLUSTERS) bytes.
+        for ( c = 0 ; c < NB_CLUSTERS ; c++ )
+        {
+            unsigned int rx = c / Y_SIZE;
+            unsigned int ry = c % Y_SIZE;
+
+            buf_in[c]  = remote_malloc( npixels/NB_CLUSTERS, rx, ry );
+            buf_out[c] = remote_malloc( npixels/NB_CLUSTERS, rx, ry );
+
+            giet_shr_printf("\n[TRANSPOSE] Proc [0,0,0] completes buffer allocation"
+                            " for cluster[%d,%d] at cycle %d\n"
+                            " - buf_in  = %x\n"
+                            " - buf_out = %x\n",
+                            rx, ry, giet_proctime(), 
+                            (unsigned int)buf_in[c], 
+                            (unsigned int)buf_out[c] );
+        }
+
+        // open file containing images
+        file = giet_fat_open( "misc/images.raw", 0);
+
+        if (file < 0)
+        { 
+            giet_shr_printf("\n[TRANSPOSE ERROR] Processor[%d,%d,%d]"
+                            " cannot open file misc/images.raw",
+                            x, y, lpid );
+            giet_exit(" open() failure");
+        }
+        else
+        {
+            giet_shr_printf("\n[TRANSPOSE] Processor[0,0,0] open file misc/images.raw\n");
+        }
         init_ok = 0;
     }
@@ -116 +156 @@
     }
     
-    // The buffers containing the images are distributed in clusters
-    // (one buf_in and one buf_out per cluster).
-    // Each buffer contains (NN*NN / nclusters) bytes.
-    // They are allocated in the cluster[x,y] heap by processor[x,y,0]
-    if ( lpid == 0 )
-    {
-        // get heap vaddr in cluster[0,0]
-        unsigned int heap_base;         
-        giet_vobj_get_vbase( "transpose", "trsp_heap_0_0", &heap_base );
- 
-        // allocate buffers in cluster[x,y]
-        buf_in[cluster_id]  = remote_malloc( npixels/NB_CLUSTERS, x, y);
-        buf_out[cluster_id] = remote_malloc( npixels/NB_CLUSTERS, x, y);
-
-        giet_shr_printf("\n[TRANSPOSE] Proc [%d,%d,%d] completes buffer allocation at cycle %d\n"
-                        " - buf_in  = %x\n"
-                        " - buf_out = %x\n",
-                        x, y, 0, giet_proctime(), 
-                        (unsigned int)buf_in[cluster_id], 
-                        (unsigned int)buf_out[cluster_id] );
-
-        // open file containing images
-        file = giet_fat_open( "misc/images.raw", 0);
-
-        if (file < 0)
-        { 
-            giet_shr_printf("[TRANSPOSE ERROR] Processor[%d,%d,%d]"
-                            " cannot open file misc/images.raw",
-                            x, y, lpid );
-            giet_exit(" open() failure");
-        }
-        else
-        {
-            giet_shr_printf("\n[TRANSPOSE] Processor[%d,%d,%d]"
-                            " open file misc/images.raw\n",
-                            x, y, lpid );
-        }
-    }
 
     /////////////////////////
-    barrier_wait( &barrier );
-
     // Main loop (on images)
     while (image < NB_IMAGES)
     {
-        // pseudo parallel load from disk to buf_in buffer : nblocks/nclusters blocks
+        // pseudo parallel load from disk to buf_in buffer : nblocks/NB_CLUSTERS blocks
         // only task running on processor with (lpid == 0) does it
 
@@ -170 +170 @@
             giet_fat_read( file,
                            buf_in[cluster_id],
-                           (nblocks / nclusters),
-                           ((image*nblocks) + ((nblocks*cluster_id)/nclusters)) );
+                           (nblocks / NB_CLUSTERS),
+                           ((image*nblocks) + ((nblocks*cluster_id)/NB_CLUSTERS)) );
 
             giet_shr_printf("\n[TRANSPOSE] Proc [%d,%d,0] completes load"
@@ -192 +192 @@
 
         unsigned int nlt   = NN / ntasks;      // number of lines per task
-        unsigned int nlc   = NN / nclusters;   // number of lines per cluster
+        unsigned int nlc   = NN / NB_CLUSTERS;   // number of lines per cluster
 
         unsigned int src_cluster;
@@ -325 +325 @@
             unsigned int max_disp_ended = 0;
 
-            for (cc = 0; cc < nclusters; cc++)
+            for (cc = 0; cc < NB_CLUSTERS; cc++)
             {
                 for (pp = 0; pp < NB_PROCS_MAX; pp++)
@@ -371 +371 @@
         image++;
 
-        //////////////////////////////////////////////////
-        // all tasks must wait instrumentation completion 
-        //////////////////////////////////////////////////
+        /////////////////////////
         barrier_wait( &barrier );