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

Timestamp:

Feb 8, 2015, 9:20:45 PM (10 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/classif/classif.py (modified) (5 diffs)

soft/giet_vm/applications/classif/classif.py

@@ -3 +3 @@
 from mapping import *
 
-######################################################################################
+###################################################################################
 #   file   : classif.py  
 #   date   : november 2014
 #   author : Alain Greiner
-#######################################################################################
+###################################################################################
 #  This file describes the mapping of the multi-threaded "classif" 
 #  application on a multi-clusters, multi-processors architecture.
 #  The mapping of tasks on processors is the following:
-#  - one "load" task per cluster, 
-#  - one "store" task per cluster, 
-#  - (nprocs-2) "analyse" task per cluster.
-#  The mapping of virtual segments on the clusters is the following:
-#    - The code vsegs are replicated on all clusters.
+#    - one "load" task per cluster containing processors, 
+#    - one "store" task per cluster containing processors, 
+#    - (nprocs-2) "analyse" task per cluster containing processors.
+#  The mapping of virtual segments is the following:
 #    - There is one shared data vseg in cluster[0][0]
-#    - There is one heap vseg per cluster.
-#    - The stacks vsegs are distibuted on all clusters.
+#    - The code vsegs are replicated on all clusters containing processors.
+#    - There is one heap vseg per cluster containing processors.
+#    - The stacks vsegs are distibuted on all clusters containing processors.
 #  This mapping uses 5 platform parameters, (obtained from the "mapping" argument)
 #    - x_size    : number of clusters in a row
@@ -28 +28 @@
 #  WARNING: The target architecture cannot contain less
 #           than 3 processors per cluster.
-####################################################################################
+##################################################################################
 
 #########################
@@ -49 +49 @@
 
     heap_base  = 0x30000000
-    heap_size  = 0x00008000     # 32 Kbytes (per cluster)      
+    heap_size  = 0x00040000     # 256 Kbytes (per cluster)      
 
     stack_base = 0x40000000 
@@ -63 +63 @@
                      local = False )
 
-    # heap_x_y vsegs : shared / one per cluster 
+    # heap vsegs : shared (one per cluster) 
     for x in xrange (x_size):
         for y in xrange (y_size):
-            base = heap_base + ( (4*x + y) * heap_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, 'classif_heap_%d_%d' %(x,y), base , heap_size, 
-                             'C_WU', vtype = 'HEAP', x = x, y = y, pseg = 'RAM', 
-                             local = False )
+                mapping.addVseg( vspace, 'classif_heap_%d_%d' %(x,y), base , size, 
+                                 'C_WU', vtype = 'HEAP', x = x, y = y, pseg = 'RAM', 
+                                 local = False )
 
     # code vsegs : local (one copy in each cluster)
     for x in xrange (x_size):
         for y in xrange (y_size):
+            cluster_id = (x * y_size) + y
+            if ( mapping.clusters[cluster_id].procs ):
 
-            mapping.addVseg( vspace, 'classif_code_%d_%d' %(x,y), code_base , code_size,
-                             'CXWU', vtype = 'ELF', x = x, y = y, pseg = 'RAM', 
-                             binpath = 'build/classif/classif.elf',
-                             local = True )
+                mapping.addVseg( vspace, 'classif_code_%d_%d' %(x,y), 
+                                 code_base , code_size,
+                                 'CXWU', vtype = 'ELF', x = x, y = y, pseg = 'RAM', 
+                                 binpath = 'build/classif/classif.elf',
+                                 local = True )
 
-    # stacks vsegs: local (one stack per processor => nprocs stacks per cluster)            
+    # stacks vsegs: local (one stack per processor => nprocs stacks per cluster)
     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) & 0xFFFFF000
-                base    = stack_base + (proc_id * 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) & 0xFFFFF000
+                    base    = stack_base + (proc_id * size)
 
-                mapping.addVseg( vspace, 'classif_stack_%d_%d_%d' % (x,y,p), base, size,
-                                 'C_WU', vtype = 'BUFFER', x = x , y = y , pseg = 'RAM',
-                                 local = True, big = True )
+                    mapping.addVseg( vspace, 'classif_stack_%d_%d_%d' % (x,y,p), 
+                                     base, size, 'C_WU', vtype = 'BUFFER', 
+                                     x = x , y = y , pseg = 'RAM',
+                                     local = True, 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
-                if  ( p== 0 ):                              # task load
-                    task_index = 0
-                    task_name  = 'load_%d_%d_%d' %(x,y,p)            
-                elif  ( p== 1 ):                            # task store
-                    task_index = 1
-                    task_name  = 'store_%d_%d_%d' %(x,y,p)            
-                else :                                      # task analyse
-                    task_index = 2
-                    task_name  = 'analyse_%d_%d_%d' % (x,y,p)
+            cluster_id = (x * y_size) + y
+            if ( mapping.clusters[cluster_id].procs ):
+                for p in xrange( nprocs ):
+                    trdid = (((x * y_size) + y) * nprocs) + p
+                    if  ( p== 0 ):                              # task load
+                        task_index = 0
+                        task_name  = 'load_%d_%d_%d' %(x,y,p)            
+                    elif  ( p== 1 ):                            # task store
+                        task_index = 1
+                        task_name  = 'store_%d_%d_%d' %(x,y,p)            
+                    else :                                      # task analyse
+                        task_index = 2
+                        task_name  = 'analyse_%d_%d_%d' % (x,y,p)
 
-                mapping.addTask( vspace, task_name, trdid, x, y, p,
-                                 'classif_stack_%d_%d_%d' % (x,y,p), 
-                                 'classif_heap_%d_%d' % (x,y),
-                                 task_index )
+                    mapping.addTask( vspace, task_name, trdid, x, y, p,
+                                     'classif_stack_%d_%d_%d' % (x,y,p), 
+                                     'classif_heap_%d_%d' % (x,y),
+                                     task_index )
 
     # extend mapping name
@@ -118 +129 @@
     return vspace  # useful for test
             
-################################ test ######################################################
+################################ test ################################################
 
 if __name__ == '__main__':