Changeset 683 for soft/giet_vm/applications/raycast/raycast.py

Timestamp:

Aug 3, 2015, 7:07:02 PM (9 years ago)

Author:

guerin

Message:

raycast: initial distributed implementation

The main task runs on processor (0,0,0). It manages game logic and
initialization, and participates in the rendering process.
The render task runs on all other processors. It tries to render a frame
slice when available, which is raycasting + pixel drawing for a pixel
column of the frame.

File:

• soft/giet_vm/applications/raycast/raycast.py (modified) (4 diffs)

soft/giet_vm/applications/raycast/raycast.py

@@ -8 +8 @@
 #   author : Alain Greiner
 #######################################################################################
-#  This file describes the mapping of the single thread "raycast" application 
-#  on processor[0][0][0] of a multi-clusters, multi-processors architecture.
+#  This file describes the mapping of the multi-threaded "raycast" application 
+#  on a multi-clusters, multi-processors architecture.
+#  The mapping of tasks on processors is the following:
+#    - one "main" task on (0,0,0)
+#    - one "render" task per processor but (0,0,0)
+#  The mapping of virtual segments is the following:
+#    - There is one shared data vseg in cluster[0][0]
+#    - 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
+#    - y_size    : number of clusters in a column
+#    - x_width   : number of bits for x field
+#    - y_width   : number of bits for y field
+#    - nprocs    : number of processors per cluster
 ####################################################################################
 
@@ -15 +29 @@
 def extend( mapping ):
 
+    x_size    = mapping.x_size
+    y_size    = mapping.y_size
     nprocs    = mapping.nprocs
-    x_width   = mapping.x_width
-    y_width   = mapping.y_width
 
     # define vsegs base & size
@@ -35 +49 @@
     vspace = mapping.addVspace( name = 'raycast', startname = 'raycast_data', active = False )
     
-    # data vseg
+    # data vseg : shared / cluster[0][0]
     mapping.addVseg( vspace, 'raycast_data', data_base , data_size, 
                      'C_WU', vtype = 'ELF', x = 0, y = 0, pseg = 'RAM', 
@@ -41 +55 @@
                      local = False )
 
-    # code vseg
-    mapping.addVseg( vspace, 'raycast_code', code_base , code_size,
-                     'CXWU', vtype = 'ELF', x = 0, y = 0, pseg = 'RAM', 
-                     binpath = 'bin/raycast/appli.elf',
-                     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, 'raycast_code_%d_%d' %(x,y), 
+                                 code_base , code_size,
+                                 'CXWU', vtype = 'ELF', x = x, y = y, pseg = 'RAM', 
+                                 binpath = 'bin/raycast/appli.elf',
+                                 local = True )
 
-    # stack vseg             
-    mapping.addVseg( vspace, 'raycast_stack', stack_base, stack_size,
-                     'C_WU', vtype = 'BUFFER', x = 0 , y = 0 , pseg = 'RAM',
-                     local = False, big = True )
+    # stacks vsegs: local (one stack per processor => nprocs stacks per 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 ):
+                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, 'raycast_stack_%d_%d_%d' % (x,y,p), 
+                                     base, size, 'C_WU', vtype = 'BUFFER', 
+                                     x = x , y = y , pseg = 'RAM',
+                                     local = True, big = True )   
 
-    # heap vseg
-    mapping.addVseg( vspace, 'raycast_heap', heap_base, heap_size,
-                     'C_WU', vtype = 'BUFFER', x = 0 , y = 0 , pseg = 'RAM',
-                     local = False )
+    # heap vsegs : shared (one per 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 ):
+                size  = heap_size
+                base  = heap_base + (cluster_id * size)
+                mapping.addVseg( vspace, 'raycast_heap_%d_%d' %(x,y), base , size, 
+                                 'C_WU', vtype = 'HEAP', x = x, y = y, pseg = 'RAM', 
+                                 local = False )
 
-    # task 
-    mapping.addTask( vspace, 'raycast', 0, 0, 0, 0, 'raycast_stack', 'raycast_heap', 0 )
+    # distributed tasks / one task per processor
+    for x in xrange (x_size):
+        for y in xrange (y_size):
+            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  ( x == 0 and y == 0 and p == 0 ):       # main task
+                        task_index = 1
+                        task_name  = 'main_%d_%d_%d' %(x,y,p)
+                    else:                                       # render task
+                        task_index = 0
+                        task_name  = 'render_%d_%d_%d' % (x,y,p)
+
+                    mapping.addTask( vspace, task_name, trdid, x, y, p,
+                                     'raycast_stack_%d_%d_%d' % (x,y,p), 
+                                     'raycast_heap_%d_%d' % (x,y),
+                                     task_index )
 
     # extend mapping name