Changeset 383 for soft/giet_vm/transpose

Timestamp:

Aug 7, 2014, 12:27:17 PM (10 years ago)

Author:

alain

Message:

Update the transpose application to use the new malloc.h and barrier.h libraries.

Location:

soft/giet_vm/transpose

Files:

• main.c (modified) (12 diffs)
• transpose.py (modified) (1 diff)

soft/giet_vm/transpose/main.c

@@ -20 +20 @@
 #include "stdio.h"
 #include "barrier.h"
+#include "malloc.h"
 
 #define NN                  128                 // image size : nlines = npixels = 128
 #define NB_IMAGES           5                   // number of images to be handled
 #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
 
@@ -34 +35 @@
 // for each processor (up to 4 processors)
 // in each cluster (up to 32 clusters)
-unsigned int LOAD_START[32][4];
-unsigned int LOAD_END  [32][4];
-unsigned int TRSP_START[32][4];
-unsigned int TRSP_END  [32][4];
-unsigned int DISP_START[32][4];
-unsigned int DISP_END  [32][4];
+unsigned int LOAD_START[NB_CLUSTERS][NB_PROCS_MAX];
+unsigned int LOAD_END  [NB_CLUSTERS][NB_PROCS_MAX];
+unsigned int TRSP_START[NB_CLUSTERS][NB_PROCS_MAX];
+unsigned int TRSP_END  [NB_CLUSTERS][NB_PROCS_MAX];
+unsigned int DISP_START[NB_CLUSTERS][NB_PROCS_MAX];
+unsigned int DISP_END  [NB_CLUSTERS][NB_PROCS_MAX];
 
 // arrays of pointers on distributed buffers
 // one input buffer & one output buffer per cluster
-unsigned char*  buf_in [32];
-unsigned char*  buf_out[32];
+unsigned char*  buf_in [NB_CLUSTERS];
+unsigned char*  buf_out[NB_CLUSTERS];
 
 // checksum variables 
@@ -50 +51 @@
 unsigned check_line_after[NN];
 
-// synchronisation barriers
-giet_barrier_t barrier_0;
-giet_barrier_t barrier_1;
-giet_barrier_t barrier_2;
-giet_barrier_t barrier_3;
-giet_barrier_t barrier_4;
-giet_barrier_t barrier_5;
+// global synchronisation barrier
+giet_barrier_t barrier;
 
 volatile unsigned int init_ok = 1;
@@ -62 +58 @@
 //////////////////////////////////////////
 __attribute__ ((constructor)) void main()
+//////////////////////////////////////////
 {
 
@@ -100 +97 @@
         }
 
-        barrier_init( &barrier_0, ntasks );
-        barrier_init( &barrier_1, ntasks );
-        barrier_init( &barrier_2, ntasks );
-        barrier_init( &barrier_3, ntasks );
-        barrier_init( &barrier_4, ntasks );
-        barrier_init( &barrier_5, ntasks );
+        barrier_init( &barrier, ntasks );
 
         giet_shr_printf("\n[TRANSPOSE] Proc [%d,%d,%d] completes barrier init at cycle %d\n",
@@ -135 +127 @@
  
         // allocate buffers in cluster[x,y]
-        buf_in[cluster_id]  = ((unsigned char*)heap_base) + (cluster_xy << 20);
-        buf_out[cluster_id] = buf_in[cluster_id] + NN*NN/nclusters;
+        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"
@@ -163 +155 @@
     }
 
-    ///////////////////////////
-    barrier_wait( &barrier_0 );
+    /////////////////////////
+    barrier_wait( &barrier );
 
     // Main loop (on images)
@@ -188 +180 @@
         LOAD_END[cluster_id][lpid] = giet_proctime();
 
-        ///////////////////////////
-        barrier_wait( &barrier_1 );
+        /////////////////////////
+        barrier_wait( &barrier );
 
         // parallel transpose from buf_in to buf_out
@@ -243 +235 @@
         TRSP_END[cluster_id][lpid] = giet_proctime();
 
-        ///////////////////////////
-        barrier_wait( &barrier_2 );
+        /////////////////////////
+        barrier_wait( &barrier );
 
         // optional parallel display from local buf_out to frame buffer
@@ -268 +260 @@
             DISP_END[cluster_id][lpid] = giet_proctime();
 
-            ///////////////////////////
-            barrier_wait( &barrier_3 );
+            /////////////////////////
+            barrier_wait( &barrier );
         }
 
@@ -312 +304 @@
         }
 
-        ///////////////////////////
-        barrier_wait( &barrier_4 );
+        /////////////////////////
+        barrier_wait( &barrier );
 
         // instrumentation done by processor [0,0,0]
@@ -382 +374 @@
         // all tasks must wait instrumentation completion 
         //////////////////////////////////////////////////
-        barrier_wait( &barrier_5 );
+        barrier_wait( &barrier );
 
     } // end while image      

soft/giet_vm/transpose/transpose.py

@@ -31 +31 @@
     # define vsegs base & size
     code_base  = 0x10000000
-    code_size  = 0x00010000     # 64 Kbytes
+    code_size  = 0x00010000     # 64 Kbytes (replicated in each cluster)
     
     data_base  = 0x20000000
-    data_size  = 0x00010000     # 64 Kbytes
+    data_size  = 0x00010000     # 64 Kbytes (non replicated)
 
     ptab_base  = 0x30000000
-    ptab_size  = 0x00040000     # 256 Kbytes
+    ptab_size  = 0x00040000     # 256 Kbytes (replicated in each cluster)
 
     stack_base = 0x40000000 
-    stack_size = 0x00010000     # 64 Kbytes
+    stack_size = 0x00100000     # 1 Mbytes (to be divided between all tasks)
 
     heap_base  = 0x50000000 
-    heap_size  = 0x00010000     # 64 Kbytes
+    heap_size  = 0x00010000     # 64 Kbytes (to be shared by all tasks)
 
-    # create Vspace
+    # create vspace
     vspace = mapping.addVspace( name = 'transpose', startname = 'trsp_data' )
     
-    # non replicated vsegs in cluster[0,0]
-    mapping.addVseg( vspace, 'trsp_code', code_base , code_size, 'CXWU', vtype = 'ELF', 
-                     x = 0, y = 0, pseg = 'RAM', binpath = 'build/transpose/transpose.elf' )
+    # data vseg : shared (only in cluster[0,0])
+    mapping.addVseg( vspace, 'trsp_data', data_base , data_size, 
+                     'C_WU', vtype = 'ELF', x = 0, y = 0, pseg = 'RAM', 
+                     binpath = 'build/transpose/transpose.elf',
+                     local = False )
 
-    mapping.addVseg( vspace, 'trsp_data', data_base , data_size, 'C_WU', vtype = 'ELF',
-                     x = 0, y = 0, pseg = 'RAM', binpath = 'build/transpose/transpose.elf' )
+    # code vsegs : local (one copy in each cluster)
+    for x in xrange (x_size):
+        for y in xrange (y_size):
+            mapping.addVseg( vspace, 'trsp_code_%d_%d' %(x,y), code_base , code_size,
+                             'CXWU', vtype = 'ELF', x = x, y = y, pseg = 'RAM', 
+                             binpath = 'build/transpose/transpose.elf',
+                             local = True )
 
-    mapping.addVseg( vspace, 'trsp_ptab', ptab_base , ptab_size, 'C_WU', vtype = 'PTAB',
-                     x = 0, y = 0, pseg = 'RAM', align = 13 )
+    # ptab vsegs : local (one specific ptab per cluster)
+    for x in xrange (x_size):
+        for y in xrange (y_size):
+            mapping.addVseg( vspace, 'trsp_ptab_%d_%d' %(x,y), ptab_base , ptab_size,
+                            'C_WU', vtype = 'PTAB', x = x, y = y, pseg = 'RAM', 
+                            align = 13,
+                            local = True )
 
-    # distributed vsegs: one stack per processor/task, one heap per cluster
-    for x_rep in xrange (x_size):
-        for y_rep in xrange (y_size):
-            cluster_offset = ((x_rep << y_width) + y_rep) << 20  # 1 Mbytes per cluster
-            mapping.addVseg( vspace, 'trsp_heap_%d_%d' % (x_rep, y_rep), 
-                             heap_base + cluster_offset, heap_size, 'C_WU', 
-                             vtype = 'BUFFER', x = x_rep, y = y_rep, pseg = 'RAM' )
-            
+    # stacks vsegs: local (one stack per processor, procs_max stacks per cluster)            
+    for x in xrange (x_size):
+        for y in xrange (y_size):
             for p in xrange( procs_max ):
-                proc_offset = cluster_offset + (p << 18)         # 256 Kbytes per proc
-                mapping.addVseg( vspace, 'trsp_stack_%d_%d_%d' % (x_rep, y_rep, p),
-                                 stack_base + proc_offset, stack_size, 'C_WU',
-                                 vtype = 'BUFFER', x = x_rep, y = y_rep, pseg = 'RAM' )
-            
+                proc_id = (((x * y_size) + y) * procs_max) + p
+                size    = stack_size / (x_size * y_size * procs_max)
+                base    = stack_base + (proc_id * size)
+                mapping.addVseg( vspace, 'trsp_stack_%d_%d_%d' % (x,y,p), base, size,
+                                 'C_WU', vtype = 'BUFFER', x = x , y = y , pseg = 'RAM',
+                                 local = True )
+
+    # heap vsegs: shared (all heap segments can be accessed by all tasks)
+    for x in xrange (x_size):
+        for y in xrange (y_size):
+            cluster_id = (x * y_size) + y
+            size  = heap_size / (x_size * y_size)
+            base  = heap_base + (cluster_id * size)
+            mapping.addVseg( vspace, 'trsp_heap_%d_%d' % (x,y), base, size, 
+                             'C_WU', vtype = 'BUFFER', x = x, y = y, pseg = 'RAM',
+                             local = False )
+
     # distributed tasks / one task per processor
     for x in xrange (x_size):
         for y in xrange (y_size):
             for p in xrange( procs_max ):
-
                 trdid = (((x * y_size) + y) * procs_max) + p
-                mapping.addTask( vspace, 'sort_%d_%d_%d' % (x,y,p), trdid, x, y, p,
+                mapping.addTask( vspace, 'trsp_%d_%d_%d' % (x,y,p), trdid, x, y, p,
                                  'trsp_stack_%d_%d_%d' % (x,y,p),
                                  'trsp_heap_%d_%d' % (x,y), 0 )