Changeset 502 for soft/giet_vm/applications/sort/sort.py

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/sort.py (modified) (2 diffs)

soft/giet_vm/applications/sort/sort.py

@@ -33 +33 @@
     # define vsegs base & size
     code_base  = 0x10000000
-    code_size  = 0x00200000     # 2 Mbytes (replicated in each cluster)
+    code_size  = 0x00010000     # 64 Kbytes (replicated in each cluster)
 
     data_base  = 0x20000000
-    data_size  = 0x00100000     # 1 Mbyte (non replicated)
-
-    args_base  = 0x20100000
-    args_size  = 0x00000004     # 4 bytes (non replicated)
+    data_size  = 0x00010000     # 64 Kbyte (non replicated)
 
     stack_base = 0x40000000
@@ -54 +51 @@
                      'C_WU', vtype = 'ELF', x = 0, y = 0, pseg = 'RAM',
                      binpath = 'build/sort/sort.elf',
-                     local = False, big = True )
-
-    # args vseg : non local (only in cluster[0,0])
-    mapping.addVseg( vspace, 'sort_args', args_base , args_size,
-                     'C_WU', vtype = 'CONST', x = 0, y = 0, pseg = 'RAM',
-                     init = ntasks,
-                     local = False, big = True )
+                     local = False )
 
     # code vsegs : local (one copy per cluster)
     for x in xrange (x_size):
         for y in xrange (y_size):
-            mapping.addVseg( vspace, 'sort_code', code_base , code_size,
-                             'CXWU', vtype = 'ELF', x = x, y = y, pseg = 'RAM',
-                             binpath = 'build/sort/sort.elf',
-                             local = True, big = True )
+            cluster_id = (x * y_size) + y
+            if ( mapping.clusters[cluster_id].procs ):
+
+                mapping.addVseg( vspace, 'sort_code', code_base , code_size,
+                                 'CXWU', vtype = 'ELF', x = x, y = y, pseg = 'RAM',
+                                 binpath = 'build/sort/sort.elf',
+                                 local = True )
 
     # stacks vsegs : local (one stack per task)
     for x in xrange (x_size):
         for y in xrange (y_size):
-            for p in xrange (nprocs):
-                proc_id = (((x * y_size) + y) * nprocs) + p
-                size    = stack_size / nprocs
-                base    = stack_base + (proc_id * size)
-                mapping.addVseg( vspace, 'sort_stack_%d_%d_%d' % (x,y,p), base, size,
+            cluster_id = (x * y_size) + y
+            if ( mapping.clusters[cluster_id].procs ):
+                for p in xrange (nprocs):
+                    proc_id = (((x * y_size) + y) * nprocs) + p
+                    size    = stack_size / nprocs
+                    base    = stack_base + (proc_id * size)
+
+                    mapping.addVseg( vspace, 'sort_stack_%d_%d_%d' % (x,y,p), 
+                                     base, size, 'C_WU', vtype = 'BUFFER',
+                                     x = x, y = y, pseg = 'RAM',
+                                     local = True, big = True )
+
+    # heap vsegs : distributed but non local (all tasks can access all heap vsegs)
+    for x in xrange (x_size):
+        for y in xrange (y_size):
+            cluster_id = (x * y_size) + y
+            if ( mapping.clusters[cluster_id].procs ):
+                size       = heap_size
+                base       = heap_base + (cluster_id * size)
+
+                mapping.addVseg( vspace, 'sort_heap_%d_%d' % (x,y), base, size,
                                  'C_WU', vtype = 'BUFFER', x = x, y = y, pseg = 'RAM',
-                                 local = True, big = True )
-
-            # heap vsegs : distributed but non local (all tasks can access all heap vsegs)
-            cluster_id = (x * y_size) + y
-            size       = heap_size
-            base       = heap_base + (cluster_id * size)
-            mapping.addVseg( vspace, 'sort_heap_%d_%d' % (x,y), base, size,
-                             'C_WU', vtype = 'BUFFER', x = x, y = y, pseg = 'RAM',
-                             local = False, big = True )
+                                 local = False, big = True )
 
     # distributed tasks / one task per processor
     for x in xrange (x_size):
         for y in xrange (y_size):
-            for p in xrange( nprocs ):
-                trdid = (((x * y_size) + y) * nprocs) + p
-                mapping.addTask( vspace, 'sort_%d_%d_%d' % (x,y,p), trdid, x, y, p,
-                                 'sort_stack_%d_%d_%d' % (x,y,p),
-                                 'sort_heap_%d_%d' % (x,y), 0 )
+            cluster_id = (x * y_size) + y
+            if ( mapping.clusters[cluster_id].procs ):
+                for p in xrange( nprocs ):
+                    trdid = (((x * y_size) + y) * nprocs) + p
+
+                    mapping.addTask( vspace, 'sort_%d_%d_%d' % (x,y,p),
+                                     trdid, x, y, p,
+                                     'sort_stack_%d_%d_%d' % (x,y,p),
+                                     'sort_heap_%d_%d' % (x,y), 0 )
 
     # extend mapping name