Changeset 683 for soft/giet_vm/applications/raycast

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.

Location:

soft/giet_vm/applications/raycast

Files:

• disp.c (modified) (6 diffs)
• disp.h (modified) (1 diff)
• game.c (modified) (2 diffs)
• game.h (modified) (1 diff)
• main.c (modified) (1 diff)
• raycast.py (modified) (4 diffs)

soft/giet_vm/applications/raycast/disp.c

@@ -6 +6 @@
 #include <math.h>
 #include <hard_config.h>
+#include <user_sqt_lock.h>
 
 #define FIELD_OF_VIEW   (70.f * M_PI / 180.f)   // Camera field of view
@@ -14 +15 @@
 // Globals
 
-static unsigned char* buf[2];
-static void *         sts[2];
-static unsigned int   cur_buf;
+static unsigned char*           buf[2];         // framebuffer
+static void *                   sts[2];         // for fbf_cma
+static unsigned int             cur_buf;        // current framebuffer
+static volatile unsigned int    slice_x;        // slice index (shared)
+static sqt_lock_t               slice_x_lock;   // slice index lock
+static volatile unsigned int    slice_cnt;      // slice count (shared)
 
 // Textures indexed by block number
@@ -168 +172 @@
 }
 
-static unsigned char *loadTexture(char *path)
+static unsigned char *dispLoadTexture(char *path)
 {
     int fd;
@@ -191 +195 @@
 void dispInit()
 {
-    // allocate framebuffer
+    unsigned int w, h, p;
+
+    // Initialize lock
+    giet_procs_number(&w, &h, &p);
+    sqt_lock_init(&slice_x_lock, w, h, p);
+
+    // Allocate framebuffer
     buf[0] = almalloc(64, FBUF_X_SIZE * FBUF_Y_SIZE);
     buf[1] = almalloc(64, FBUF_X_SIZE * FBUF_Y_SIZE);
@@ -197 +207 @@
     sts[1] = almalloc(64, 64);
 
-    // initialize framebuffer
+    // Initialize framebuffer
     giet_fbf_cma_alloc();
     giet_fbf_cma_init_buf(buf[0], buf[1], sts[0], sts[1]);
     giet_fbf_cma_start(FBUF_X_SIZE * FBUF_Y_SIZE);
 
-    // load textures
-    g_tex[1] = loadTexture("misc/rock_32.raw");
-    g_tex[2] = loadTexture("misc/door_32.raw");
-    g_tex[3] = loadTexture("misc/handle_32.raw");
-    g_tex[4] = loadTexture("misc/wood_32.raw");
+    // Load textures
+    g_tex[1] = dispLoadTexture("misc/rock_32.raw");
+    g_tex[2] = dispLoadTexture("misc/door_32.raw");
+    g_tex[3] = dispLoadTexture("misc/handle_32.raw");
+    g_tex[4] = dispLoadTexture("misc/wood_32.raw");
 
     cur_buf = 0;
+    slice_cnt = 0;
+    slice_x = FBUF_X_SIZE;
+}
+
+int dispRenderSlice(Game *game)
+{
+    unsigned int x;
+    int type;
+    float angle, dist, tx;
+
+    sqt_lock_acquire(&slice_x_lock);
+
+    if (slice_x == FBUF_X_SIZE) {
+        // No more work to do for this frame
+        sqt_lock_release(&slice_x_lock);
+        return 0;
+    }
+    else {
+        // Keep slice coordinate
+        x = slice_x++;
+    }
+
+    sqt_lock_release(&slice_x_lock);
+
+    angle = game->player.dir - FIELD_OF_VIEW / 2.f +
+            x * FIELD_OF_VIEW / FBUF_X_SIZE;
+
+    // Cast a ray to get wall distance
+    dist = dispRaycast(game, &type, &tx, angle);
+
+    // Perspective correction
+    dist *= cos(game->player.dir - angle);
+
+    // Draw ceiling, wall and floor
+    dispDrawSlice(game, x, FBUF_Y_SIZE / dist, type, tx);
+
+    // Signal this slice is done
+    atomic_increment((unsigned int*)&slice_cnt, 1);
+
+    return 1;
 }
 
@@ -214 +264 @@
 {
     int start = giet_proctime();
-    float angle = game->player.dir - FIELD_OF_VIEW / 2.f;
-
-    // Cast a ray for each pixel column and draw a colored wall slice
-    for (int i = 0; i < FBUF_X_SIZE; i++)
-    {
-        float dist;
-        int type;
-        float tx;
-
-        // Cast a ray to get wall distance
-        dist = dispRaycast(game, &type, &tx, angle);
-
-        // Perspective correction
-        dist *= cos(game->player.dir - angle);
-
-        // Draw ceiling, wall and floor
-        dispDrawSlice(game, i, FBUF_Y_SIZE / dist, type, tx);
-
-        angle += FIELD_OF_VIEW / FBUF_X_SIZE;
-    }
-
+
+    // Start rendering
+    slice_cnt = 0;
+    slice_x = 0;
+
+    // Render slices
+    while (dispRenderSlice(game));
+
+    // Wait for completion
+    while (slice_cnt != FBUF_X_SIZE);
+
+    // Flip framebuffer
     giet_fbf_cma_display(cur_buf);
     cur_buf = !cur_buf;
     giet_tty_printf("[RAYCAST] flip (took %d cycles)\n", giet_proctime() - start);
 }
+

soft/giet_vm/applications/raycast/disp.h

@@ -5 +5 @@
 
 void dispInit();
+int dispRenderSlice(Game *game);
 void dispRender(Game *game);
 

soft/giet_vm/applications/raycast/game.c

@@ -81 +81 @@
 static void gameOnBlockHit(int type)
 {
-        g_exit = true;
+    g_exit = true;
 }
 
@@ -197 +197 @@
     }
 }
+
+Game *gameInstance()
+{
+    return &game;
+}

soft/giet_vm/applications/raycast/game.h

@@ -39 +39 @@
 void gameRun();
 void gameTick();
+Game *gameInstance();
 
 #endif // __GAME_H

soft/giet_vm/applications/raycast/main.c

@@ -4 +4 @@
 #include <malloc.h>
 
+static volatile unsigned int    init_sync = 0;
+
 // Exported functions
+
+__attribute__((constructor)) void render()
+{
+    // Wait for main initialization
+    while (!init_sync);
+
+    Game *game = gameInstance();
+
+    // Render slices as soon as it's available
+    while (1) {
+        dispRenderSlice(game);
+    }
+}
 
 __attribute__((constructor)) void main()
 {
-        giet_tty_alloc(0);
-        giet_tty_printf("[RAYCAST] entering main()\n");
+    unsigned int w, h, p;
+    unsigned int i, j;
 
-        heap_init(0, 0);
-        dispInit();
+    giet_tty_alloc(0);
+    giet_tty_printf("[RAYCAST] entering main()\n");
+
+    // Initialize heap for each cluster
+    giet_procs_number(&w, &h, &p);
+    for (i = 0; i < w; i++)
+        for (j = 0; j < h; j++)
+            heap_init(i, j);
+
+    // Initialize game
+    dispInit();
+
+    init_sync = 1;
 
     while (1) {

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