Changeset 669 for soft/giet_vm/applications

Timestamp:

Jul 27, 2015, 8:40:45 PM (9 years ago)

Author:

alain

Message:

Introduce support for the "shared" argument in the giet_tty_alloc() system call,
and replace the giet_shr_printf() system call by giet_tty_printf().

Location:

soft/giet_vm/applications

Files:

• classif/main.c (modified) (4 diffs)
• convol/convol.py (modified) (2 diffs)
• convol/main.c (modified) (24 diffs)
• coproc/main.c (modified) (5 diffs)
• display/main.c (modified) (2 diffs)
• gameoflife/gameoflife.py (modified) (1 diff)
• gameoflife/main.c (modified) (8 diffs)
• shell/main.c (modified) (2 diffs)
• sort/main.c (modified) (10 diffs)
• sort/sort.py (modified) (1 diff)
• transpose/main.c (modified) (18 diffs)
• transpose/transpose.py (modified) (1 diff)

soft/giet_vm/applications/classif/main.c

@@ -11 +11 @@
 // It can run on architectures containing up to 16 * 16 clusters,
 // and up to 8 processors per cluster.
+//
+// It requires N+2 TTY terminals, as each task in cluster[0][0] displays messages.
 //
 // This application is described as a TCG (Task and Communication Graph) 
@@ -142 +144 @@
     if ( (x==0) && (y==0) )
     {
-        giet_tty_alloc();
+        // allocate a private TTY
+        giet_tty_alloc(0);
 
         giet_tty_printf("\n*** Task load on P[%d][%d][%d] starts at cycle %d\n"
@@ -299 +302 @@
     if ( (x==0) && (y==0) )
     {
-        giet_tty_alloc();
+        // allocate a private TTY
+        giet_tty_alloc(0);
 
         giet_tty_printf("\n*** Task store on P[%d][%d][%d] starts at cycle %d\n"
@@ -439 +443 @@
     if ( (x==0) && (y==0) )
     {
-        giet_tty_alloc();
+        // allocate a private TTY
+        giet_tty_alloc(0);
 
         giet_tty_printf("\n*** Task analyse on P[%d][%d][%d] starts at cycle %d\n"

soft/giet_vm/applications/convol/convol.py

@@ -40 +40 @@
     
     data_base  = 0x20000000
-    data_size  = 0x00010000     # 64 Kbytes (non replicated)
+    data_size  = 0x00020000     # 128 Kbytes (non replicated)
 
     heap_base  = 0x40000000     
@@ -49 +49 @@
 
     # create Vspace
-    vspace = mapping.addVspace( name = 'convol', startname = 'conv_data' )
+    vspace = mapping.addVspace( name = 'convol', startname = 'conv_data', active = False )
     
     # data vseg in cluster[0,0] : non local

soft/giet_vm/applications/convol/main.c

@@ -1 +1 @@
 ///////////////////////////////////////////////////////////////////////////////////////
-// File   : main.c   (for convol application)
+// File   : main.c   (convol application)
 // Date   : june 2014
 // author : Alain Greiner
@@ -22 +22 @@
 
 #define USE_SQT_BARRIER            1
-#define VERBOSE                    0
+#define VERBOSE                    1
 #define SUPER_VERBOSE              0
 
@@ -49 +49 @@
 #define max(x,y) ((x) > (y) ? (x) : (y))
 #define min(x,y) ((x) < (y) ? (x) : (y))
+
+// macro to use a shared TTY
+#define printf(...)     lock_acquire( &tty_lock ); \
+                        giet_tty_printf(__VA_ARGS__);  \
+                        lock_release( &tty_lock )
 
 // global instrumentation counters (cluster_id, lpid]
@@ -60 +65 @@
 unsigned int D_END[CLUSTERS_MAX][PROCS_MAX];
 
-// global synchronization barrier
+// global synchronization barriers
 
 #if USE_SQT_BARRIER
@@ -71 +76 @@
 volatile unsigned int load_image_ok      = 0;
 volatile unsigned int instrumentation_ok = 0;
+
+// lock protecting access to shared TTY
+user_lock_t         tty_lock;
 
 // global pointers on distributed buffers in all clusters
@@ -138 +146 @@
     START[cluster_id][lpid] = date;
 
-#if VERBOSE
-giet_shr_printf( "\n[CONVOL] task[%d,%d,%d] starts at cycle %d\n", x,y,lpid, date );
-#endif
-
      // parameters checking 
    
@@ -161 +165 @@
     
     ///////////////////////////////////////////////////////////////////
-    // task[0][0][0] makes barrier initialisation
+    // task[0][0][0] makes various initialisations
     ///////////////////////////////////////////////////////////////////
     
     if ( (x==0) && (y==0) && (lpid==0) )
     {
-        giet_shr_printf("\n[CONVOL] task[0,0,0] starts barrier init at cycle %d\n" 
-                        "- CLUSTERS   = %d\n"
-                        "- PROCS      = %d\n" 
-                        "- TASKS      = %d\n" 
-                        "- LINES/TASK = %d\n",
-                        giet_proctime(), nclusters, nprocs, ntasks, lines_per_task );
+        // get a shared TTY
+        giet_tty_alloc( 1 );
+
+        // initializes TTY lock
+        lock_init( &tty_lock );
+
+        // initializes the distributed heap[x,y]
+        unsigned int cx;
+        unsigned int cy;
+        for ( cx = 0 ; cx < x_size ; cx++ )
+        {
+            for ( cy = 0 ; cy < y_size ; cy++ )
+            {
+                heap_init( cx , cy );
+            }
+        }
+
 #if USE_SQT_BARRIER
         sqt_barrier_init( &barrier, x_size , y_size , nprocs );
@@ -178 +193 @@
 #endif
 
-        giet_shr_printf( "\n[CONVOL] task[0,0,0] completes barrier init at cycle %d\n",
-                         giet_proctime() );
+        printf("\n[CONVOL] task[0,0,0] completes initialisation at cycle %d\n" 
+               "- CLUSTERS   = %d\n"
+               "- PROCS      = %d\n" 
+               "- TASKS      = %d\n" 
+               "- LINES/TASK = %d\n",
+               giet_proctime(), nclusters, nprocs, ntasks, lines_per_task );
 
         barrier_init_ok = 1;
@@ -196 +215 @@
 
 #if VERBOSE
-giet_shr_printf( "\n[CONVOL] task[%d,%d,%d] enters malloc at cycle %d\n", 
+printf( "\n[CONVOL] task[%d,%d,%d] enters malloc at cycle %d\n", 
                  x,y,lpid, date );
 #endif
@@ -207 +226 @@
         
 #if VERBOSE
-giet_shr_printf( "\n[CONVOL]  Shared Buffer Virtual Addresses in cluster(%d,%d)\n"
-                 "### GA = %x\n"
-                 "### GB = %x\n"               
-                 "### GC = %x\n"               
-                 "### GD = %x\n"               
-                 "### GZ = %x\n",
-                 x, y,
-                 GA[cluster_id],
-                 GB[cluster_id],
-                 GC[cluster_id],
-                 GD[cluster_id],
-                 GZ[cluster_id] );
+printf( "\n[CONVOL]  Shared Buffer Virtual Addresses in cluster(%d,%d)\n"
+        "### GA = %x\n"
+        "### GB = %x\n"               
+        "### GC = %x\n"               
+        "### GD = %x\n"               
+        "### GZ = %x\n",
+        x, y,
+        GA[cluster_id],
+        GB[cluster_id],
+        GC[cluster_id],
+        GD[cluster_id],
+        GZ[cluster_id] );
 #endif
     }
@@ -257 +276 @@
     {
         // open file
-        file = giet_fat_open( "misc/philips_image.raw" , 0 );
+        file = giet_fat_open( "/misc/philips_1024.raw" , 0 );
         if ( file < 0 ) giet_exit( "[CONVOL ERROR] task[0,0,0] cannot open"
-                                   " file misc/philips_image.raw" );
+                                   " file /misc/philips_1024.raw" );
  
-        giet_shr_printf( "\n[CONVOL] task[0,0,0] open file misc/philips_image.raw"
-                         " at cycle %d\n", giet_proctime() );
+        printf( "\n[CONVOL] task[0,0,0] open file /misc/philips_1024.raw"
+                " at cycle %d\n", giet_proctime() );
 
         for ( c = 0 ; c < nclusters ; c++ )
         {
-            giet_shr_printf( "\n[CONVOL] task[0,0,0] starts load "
-                             "for cluster %d at cycle %d\n", c, giet_proctime() );
+            printf( "\n[CONVOL] task[0,0,0] starts load "
+                    "for cluster %d at cycle %d\n", c, giet_proctime() );
 
             giet_fat_lseek( file,
@@ -277 +296 @@
                            frame_size/nclusters );
 
-            giet_shr_printf( "\n[CONVOL] task[0,0,0] completes load "
-                             "for cluster %d at cycle %d\n", c, giet_proctime() );
+            printf( "\n[CONVOL] task[0,0,0] completes load "
+                    "for cluster %d at cycle %d\n", c, giet_proctime() );
         }
         load_image_ok = 1;
@@ -296 +315 @@
 
 #if VERBOSE
-giet_shr_printf( "\n[CONVOL] task[%d,%d,%d] starts initial display"
-                 " at cycle %d\n",
-                 x, y, lpid, giet_proctime() );
+printf( "\n[CONVOL] task[%d,%d,%d] starts initial display"
+        " at cycle %d\n",
+        x, y, lpid, giet_proctime() );
 #endif
 
@@ -319 +338 @@
 
 #if VERBOSE 
-giet_shr_printf( "\n[CONVOL] task[%d,%d,%d] completes initial display"
-                 " at cycle %d\n",
-                 x, y, lpid, giet_proctime() );
+printf( "\n[CONVOL] task[%d,%d,%d] completes initial display"
+        " at cycle %d\n",
+        x, y, lpid, giet_proctime() );
 #endif
 
@@ -347 +366 @@
 
 #if VERBOSE 
-giet_shr_printf( "\n[CONVOL] task[%d,%d,%d] starts horizontal filter"
-                 " at cycle %d\n",
-                 x, y, lpid, date );
+printf( "\n[CONVOL] task[%d,%d,%d] starts horizontal filter"
+        " at cycle %d\n",
+        x, y, lpid, date );
 #else
 if ( (x==0) && (y==0) && (lpid==0) ) 
-giet_shr_printf( "\n[CONVOL] task[0,0,0] starts horizontal filter"
-                 " at cycle %d\n", date );
+printf( "\n[CONVOL] task[0,0,0] starts horizontal filter"
+        " at cycle %d\n", date );
 #endif
 
@@ -412 +431 @@
 
 #if SUPER_VERBOSE
-giet_shr_printf(" - line %d computed at cycle %d\n", l, giet_proctime() );
+printf(" - line %d computed at cycle %d\n", l, giet_proctime() );
 #endif    
 
@@ -421 +440 @@
 
 #if VERBOSE 
-giet_shr_printf( "\n[CONVOL] task[%d,%d,%d] completes horizontal filter"
-                 " at cycle %d\n",
-                 x, y, lpid, date );
+printf( "\n[CONVOL] task[%d,%d,%d] completes horizontal filter"
+        " at cycle %d\n",
+        x, y, lpid, date );
 #else
 if ( (x==0) && (y==0) && (lpid==0) ) 
-giet_shr_printf( "\n[CONVOL] task[0,0,0] completes horizontal filter"
-                 " at cycle %d\n", date );
+printf( "\n[CONVOL] task[0,0,0] completes horizontal filter"
+        " at cycle %d\n", date );
 #endif
 
@@ -451 +470 @@
 
 #if VERBOSE 
-giet_shr_printf( "\n[CONVOL] task[%d,%d,%d] starts vertical filter"
-                 " at cycle %d\n",
-                 x, y, lpid, date );
+printf( "\n[CONVOL] task[%d,%d,%d] starts vertical filter"
+        " at cycle %d\n",
+        x, y, lpid, date );
 #else
 if ( (x==0) && (y==0) && (lpid==0) ) 
-giet_shr_printf( "\n[CONVOL] task[0,0,0] starts vertical filter"
-                 " at cycle %d\n", date );
+printf( "\n[CONVOL] task[0,0,0] starts vertical filter"
+        " at cycle %d\n", date );
 #endif
 
@@ -532 +551 @@
 
 #if SUPER_VERBOSE
-giet_shr_printf(" - column %d computed at cycle %d\n", p, giet_proctime());
+printf(" - column %d computed at cycle %d\n", p, giet_proctime());
 #endif 
 
@@ -541 +560 @@
 
 #if VERBOSE 
-giet_shr_printf( "\n[CONVOL] task[%d,%d,%d] completes vertical filter"
-                 " at cycle %d\n",
-                 x, y, lpid, date );
+printf( "\n[CONVOL] task[%d,%d,%d] completes vertical filter"
+        " at cycle %d\n",
+        x, y, lpid, date );
 #else
 if ( (x==0) && (y==0) && (lpid==0) ) 
-giet_shr_printf( "\n[CONVOL] task[0,0,0] completes vertical filter"
-                 " at cycle %d\n", date );
+printf( "\n[CONVOL] task[0,0,0] completes vertical filter"
+        " at cycle %d\n", date );
 #endif
 
@@ -568 +587 @@
 
 #if VERBOSE
-giet_shr_printf( "\n[CONVOL] task[%d,%d,%d] starts final display"
-                 " at cycle %d\n",
-                 x, y, lpid, date);
+printf( "\n[CONVOL] task[%d,%d,%d] starts final display"
+        " at cycle %d\n",
+        x, y, lpid, date);
 #else
 if ( (x==0) && (y==0) && (lpid==0) ) 
-giet_shr_printf( "\n[CONVOL] task[0,0,0] starts final display"
-                 " at cycle %d\n", date );
+printf( "\n[CONVOL] task[0,0,0] starts final display"
+        " at cycle %d\n", date );
 #endif
 
@@ -600 +619 @@
 
 #if VERBOSE
-giet_shr_printf( "\n[CONVOL] task[%d,%d,%d] completes final display"
-                 " at cycle %d\n",
-                 x, y, lpid, date);
+printf( "\n[CONVOL] task[%d,%d,%d] completes final display"
+        " at cycle %d\n",
+        x, y, lpid, date);
 #else
 if ( (x==0) && (y==0) && (lpid==0) ) 
-giet_shr_printf( "\n[CONVOL] task[0,0,0] completes final display"
-                 " at cycle %d\n", date );
+printf( "\n[CONVOL] task[0,0,0] completes final display"
+        " at cycle %d\n", date );
 #endif
      
@@ -625 +644 @@
     {
         date  = giet_proctime();
-        giet_shr_printf("\n[CONVOL] task[0,0,0] starts instrumentation"
-                        " at cycle %d\n\n", date );
+        printf("\n[CONVOL] task[0,0,0] starts instrumentation"
+               " at cycle %d\n\n", date );
 
         int cc, pp;
@@ -678 +697 @@
         }
 
-        giet_shr_printf(" - START : min = %d / max = %d / med = %d / delta = %d\n",
+        printf(" - START : min = %d / max = %d / med = %d / delta = %d\n",
                min_start, max_start, (min_start+max_start)/2, max_start-min_start);
 
-        giet_shr_printf(" - H_BEG : min = %d / max = %d / med = %d / delta = %d\n",
+        printf(" - H_BEG : min = %d / max = %d / med = %d / delta = %d\n",
                min_h_beg, max_h_beg, (min_h_beg+max_h_beg)/2, max_h_beg-min_h_beg);
 
-        giet_shr_printf(" - H_END : min = %d / max = %d / med = %d / delta = %d\n",
+        printf(" - H_END : min = %d / max = %d / med = %d / delta = %d\n",
                min_h_end, max_h_end, (min_h_end+max_h_end)/2, max_h_end-min_h_end);
 
-        giet_shr_printf(" - V_BEG : min = %d / max = %d / med = %d / delta = %d\n",
+        printf(" - V_BEG : min = %d / max = %d / med = %d / delta = %d\n",
                min_v_beg, max_v_beg, (min_v_beg+max_v_beg)/2, max_v_beg-min_v_beg);
 
-        giet_shr_printf(" - V_END : min = %d / max = %d / med = %d / delta = %d\n",
+        printf(" - V_END : min = %d / max = %d / med = %d / delta = %d\n",
                min_v_end, max_v_end, (min_v_end+max_v_end)/2, max_v_end-min_v_end);
 
-        giet_shr_printf(" - D_BEG : min = %d / max = %d / med = %d / delta = %d\n",
+        printf(" - D_BEG : min = %d / max = %d / med = %d / delta = %d\n",
                min_d_beg, max_d_beg, (min_d_beg+max_d_beg)/2, max_d_beg-min_d_beg);
 
-        giet_shr_printf(" - D_END : min = %d / max = %d / med = %d / delta = %d\n",
+        printf(" - D_END : min = %d / max = %d / med = %d / delta = %d\n",
                min_d_end, max_d_end, (min_d_end+max_d_end)/2, max_d_end-min_d_end);
 
-        giet_shr_printf( "\n General Scenario (Kcycles for each step)\n" );
-        giet_shr_printf( " - BOOT OS           = %d\n", (min_start            )/1000 );
-        giet_shr_printf( " - LOAD IMAGE        = %d\n", (min_h_beg - min_start)/1000 );
-        giet_shr_printf( " - H_FILTER          = %d\n", (max_h_end - min_h_beg)/1000 );
-        giet_shr_printf( " - BARRIER HORI/VERT = %d\n", (min_v_beg - max_h_end)/1000 );
-        giet_shr_printf( " - V_FILTER          = %d\n", (max_v_end - min_v_beg)/1000 );
-        giet_shr_printf( " - BARRIER VERT/DISP = %d\n", (min_d_beg - max_v_end)/1000 );
-        giet_shr_printf( " - DISPLAY           = %d\n", (max_d_end - min_d_beg)/1000 );
+        printf( "\n General Scenario (Kcycles for each step)\n" );
+        printf( " - BOOT OS           = %d\n", (min_start            )/1000 );
+        printf( " - LOAD IMAGE        = %d\n", (min_h_beg - min_start)/1000 );
+        printf( " - H_FILTER          = %d\n", (max_h_end - min_h_beg)/1000 );
+        printf( " - BARRIER HORI/VERT = %d\n", (min_v_beg - max_h_end)/1000 );
+        printf( " - V_FILTER          = %d\n", (max_v_end - min_v_beg)/1000 );
+        printf( " - BARRIER VERT/DISP = %d\n", (min_d_beg - max_v_end)/1000 );
+        printf( " - DISPLAY           = %d\n", (max_d_end - min_d_beg)/1000 );
 
         instrumentation_ok = 1;

soft/giet_vm/applications/coproc/main.c

@@ -34 +34 @@
     giet_proc_xyp( &x, &y, &lpid );
 
-    giet_shr_printf("\n*** Starting coproc application on processor"
+    // get a private TTY terminal
+    giet_tty_alloc( 0 );
+
+    giet_tty_printf("\n*** Starting coproc application on processor"
                     "[%d,%d,%d] at cycle %d\n", 
                     x, y, lpid, giet_proctime() );
@@ -63 +66 @@
 
 if ( VERBOSE )
-giet_shr_printf("\n*** get GCD coprocessor at cycle %d\n", giet_proctime() );
+giet_tty_printf("\n*** get GCD coprocessor at cycle %d\n", giet_proctime() );
 
     //////////////////////// initializes channel for OPA
@@ -87 +90 @@
     
 if ( VERBOSE )
-giet_shr_printf("\n*** channels initialized at cycle %d\n", giet_proctime() );
+giet_tty_printf("\n*** channels initialized at cycle %d\n", giet_proctime() );
 
     /////////////////////// starts communication channels
@@ -93 +96 @@
 
 if ( VERBOSE )
-giet_shr_printf("\n*** start GCD coprocessor at cycle %d\n", giet_proctime() );
+giet_tty_printf("\n*** start GCD coprocessor at cycle %d\n", giet_proctime() );
 
     /////////////////////// wait coprocessor completion
@@ -102 +105 @@
 
 if ( VERBOSE )
-giet_shr_printf("\n*** GCD computation completed at cycle %d\n", giet_proctime() );
+giet_tty_printf("\n*** GCD computation completed at cycle %d\n", giet_proctime() );
 
     // display result
     for ( word = 0 ; word < VECTOR_SIZE ; word++ )
     {
-        giet_shr_printf("pgcd( %d , %d ) = %d\n",
+        giet_tty_printf("pgcd( %d , %d ) = %d\n",
         opa[word] , opb[word] , res[word] );
     }

soft/giet_vm/applications/display/main.c

@@ -17 +17 @@
 #define NIMAGES     10                  
 
-#define INTERACTIVE 1
+#define INTERACTIVE 0
 
 unsigned char buf0[NPIXELS*NLINES] __attribute__((aligned(64)));
@@ -47 +47 @@
 
     // get a private TTY 
-    giet_tty_alloc();
+    giet_tty_alloc(0);
 
     giet_tty_printf("\n[DISPLAY] P[%d,%d,%d] starts at cycle %d\n"

soft/giet_vm/applications/gameoflife/gameoflife.py

@@ -49 +49 @@
 
     # create vspace
-    vspace = mapping.addVspace( name = 'gol', startname = 'gol_data' )
+    vspace = mapping.addVspace( name = 'gameoflife', startname = 'gol_data', active = False )
     
     # data vseg : shared (only in cluster[0,0])

soft/giet_vm/applications/gameoflife/main.c

@@ -5 +5 @@
 //            Alain Greiner <alain.greiner@lip6.fr> february 2015
 //
-// This application is an emulation of the Game of Life automaton.
+// This multi-threaded application is an emulation of the Game of Life automaton.
 // The world size is defined by the HEIGHT and WIDTH parameters.
 // There is one task per processor.
 // Each task compute HEIGHT/nbprocs lines.
-// Task running on processor P(0,0,0) initialises the barrier, and
-// the chained buffer DMA controler.
+// Task running on processor P(0,0,0) initialises the barrier, the TTY terminal,
+// and the chained buffer DMA controler.
 //
 // The number of processors must be a power of 2 not larger than HEIGHT.
@@ -19 +19 @@
 #include "user_barrier.h"
 #include "mapping_info.h"
+#include "hard_config.h"
 
 #define WIDTH           128
@@ -24 +25 @@
 #define NB_ITERATION    1000000000
 
-#define PRINTF(...) ({ if ( proc_id==0) { giet_shr_printf(__VA_ARGS__); } })
+#define PRINTF(...) ({ if ( proc_id==0) { giet_tty_printf(__VA_ARGS__); } })
 
 typedef unsigned char uint8_t;
@@ -31 +32 @@
 
 uint8_t DISPLAY[2][HEIGHT][WIDTH] __attribute__((aligned(64)));
+
+unsigned int status0[16];
+unsigned int status1[16];
 
 giet_sqt_barrier_t barrier;
@@ -121 +125 @@
 ////////////////////////////////////////
 __attribute__((constructor)) void main()
+////////////////////////////////////////
 {
    // get processor identifier
@@ -131 +136 @@
    unsigned int x_size;
    unsigned int y_size;
-   unsigned int n_local_procs;
-   giet_procs_number( &x_size, &y_size, &n_local_procs );
+   unsigned int nprocs;
+   giet_procs_number( &x_size, &y_size, &nprocs );
 
    // compute continuous processor index & number of procs
-   unsigned int proc_id = (((x * y_size) + y) * n_local_procs) + p;  
-   unsigned int n_global_procs = x_size * y_size * n_local_procs; 
+   unsigned int proc_id = (((x * y_size) + y) * nprocs) + p;  
+   unsigned int n_global_procs = x_size * y_size * nprocs; 
 
    unsigned int i;
-
-   if ( n_global_procs > HEIGHT )
-   {
-       PRINTF("[GAMEOFLIFE ERROR] Number or processors too large :"
-              " nb_procs = %d / image heigth = %d\n", n_global_procs, HEIGHT );
-       giet_exit("error");
-   }
 
    unsigned int nb_line       = HEIGHT / n_global_procs;
    unsigned int base_line     = nb_line * proc_id; 
    
-   PRINTF("\n*** Starting barrier and CMA initialisation at cycle %d ***\n"
-          " nprocs = %d / nlines = %d\n", 
-          giet_proctime() , n_global_procs, HEIGHT );
-
-   //////////// barrier & CMA initialization ( P(0,0,0) )
-
+   // parameters checking
+   giet_assert( (n_global_procs <= HEIGHT),
+                " Number or processors larger than world height" );
+
+   giet_assert( ((WIDTH == FBUF_X_SIZE) && (HEIGHT == FBUF_Y_SIZE)),
+                "Frame Buffer size does not fit the world size" );
+   
+   giet_assert( ((x_size == 1) || (x_size == 2) || (x_size == 4) ||
+                 (x_size == 8) || (x_size == 16)),
+                "x_size must be a power of 2 no larger than 16" );
+
+   giet_assert( ((y_size == 1) || (y_size == 2) || (y_size == 4) ||
+                 (y_size == 8) || (y_size == 16)),
+                "y_size must be a power of 2 no larger than 16" );
+
+   giet_assert( ((nprocs == 1) || (nprocs == 2) || (nprocs == 4)), 
+                "nprocs must be a power of 2 no larger than 4" );
+
+   // P[0,0,0] makes initialisation
    if ( proc_id == 0 )
    {
-      // initialises CMA component
+      // get a private TTY for P[0,0,0]
+      giet_tty_alloc( 0 );
+
+      // get a Chained Buffer DMA channel
       giet_fbf_cma_alloc();
-      giet_fbf_cma_start( &DISPLAY[0][0][0] , 
-                          &DISPLAY[1][0][0] , 
-                          HEIGHT * WIDTH );
+
+      // initializes the source and destination buffers
+      giet_fbf_cma_init_buf( &DISPLAY[0][0][0] , 
+                             &DISPLAY[1][0][0] , 
+                             status0 ,
+                             status1 );
+
+      // activates CMA channel
+      giet_fbf_cma_start( HEIGHT * WIDTH );
+
+      // initializes distributed heap
+      unsigned int cx;
+      unsigned int cy;
+      for ( cx = 0 ; cx < x_size ; cx++ )
+      {
+         for ( cx = 0 ; cx < x_size ; cx++ )
+         {
+            heap_init( cx , cy );
+         }
+      }
 
       // initialises barrier
-      sqt_barrier_init( &barrier , x_size , y_size , n_local_procs );
+      sqt_barrier_init( &barrier , x_size , y_size , nprocs );
+
+      PRINTF("\n[GAMEOFLIFE] P[0,0,0] completes initialisation at cycle %d\n"
+             " nprocs = %d / nlines = %d\n", 
+             giet_proctime() , n_global_procs, HEIGHT );
 
       // activates all other processors
@@ -175 +210 @@
    }
 
-   PRINTF("\n*** Starting world initialisation at cycle %d ***\n",
-          giet_proctime() );
-
    ///////////// world  initialization ( All processors )
 
-   // initialises WORLD[0]
+   // All processors initialize WORLD[0]
    init_world( 0 , base_line , nb_line );
 
@@ -192 +224 @@
    if ( proc_id == 0 ) giet_fbf_cma_display ( 0 );
 
-   PRINTF("\n*** Starting evolution at cycle %d ***\n", giet_proctime() );
+   PRINTF("\n[GAMEOFLIFE] starts evolution at cycle %d\n", giet_proctime() );
    
    //////////// evolution : 2 steps per iteration 

soft/giet_vm/applications/shell/main.c

@@ -163 +163 @@
 }
 
+/////////////////////////////////////////
 static void cmd_rm(int argc, char **argv)
 {
@@ -326 +327 @@
     int count = 0;
 
-    giet_shr_printf("\n[SHELL] Enter at cycle %d\n", giet_proctime());
-    giet_tty_alloc();
+    // get a private TTY
+    giet_tty_alloc( 0 );
+
+    // display first prompt
     prompt();
 

soft/giet_vm/applications/sort/main.c

@@ -3 +3 @@
 // Date   :  November 2013
 // Author :  Cesar Fuguet Tortolero <cesar.fuguet-tortolero@lip6.fr>
+///////////////////////////////////////////////////////////////////////////////
+// This multi-threaded application implement a multi-stage sort application.
+// The various stages are separated by synchronisation barriers.
+// There is one thread per physical processors. Computation is organised as
+// a binary tree: All threads contribute to the first stage of parallel sort
+// but, the number of participating threads is divided by 2 at each next stage.
+//       Number_of_stages = number of barriers = log2(Number_of_threads)
 //
-// Description :
-//
-//      Sort application using the GIET-VM OS. This application uses the
-//      barrier routines to apply a sort algorithm in several stages.
-//
-//      Constraints :
-//
-//      - It supports up to 1024 processors and the number of processors
-//        must be a power of 2.
-//
-//      _ The array of values to be sorted (ARRAY_LENGTH) must be power of 2 
-//        larger than the number of processors.
-//
-//      - This application must be executed on a cache coherent architecture. 
-//
+// Constraints :
+// - It supports up to 1024 processors and the number of processors
+//   must be a power of 2.
+// _ The array of values to be sorted (ARRAY_LENGTH) must be power of 2 
+//   larger than the number of processors.
+// - This application uses a private TTY terminal, shared by all threads,
+//   that is protectted by an user-level SQT lock.
 ///////////////////////////////////////////////////////////////////////////////
 
 #include "stdio.h"
 #include "mapping_info.h"
-#include "hard_config.h"
 #include "user_barrier.h"
+#include "user_lock.h"
 
 #define ARRAY_LENGTH    0x1000
 #define IPT             (ARRAY_LENGTH / threads) // ITEMS PER THREAD
 
-////////////////////////////////////////////////////////////////////////////////
-// Processors other than 0 display algorithm state if VERBOSE non zero
-
-#define VERBOSE         1
-
-////////////////////////////////////////////////////////////////////////////////
-// Define printf according to verbosity option and number of available TTY
-
-#if (VERBOSE == 1)
-#   define printf(...)     giet_shr_printf(__VA_ARGS__)
-#else      
-#   define printf(...)
-#endif
-
-#define task0_printf(...) if(thread_id == 0) giet_shr_printf(__VA_ARGS__)
-
-int array0[ARRAY_LENGTH];
-int array1[ARRAY_LENGTH];
-
-volatile int init_ok = 0;
+// macro to use a shared TTY
+#define printf(...)     lock_acquire( &tty_lock ); \
+                        giet_tty_printf(__VA_ARGS__);  \
+                        lock_release( &tty_lock )
+
+int              array0[ARRAY_LENGTH];
+int              array1[ARRAY_LENGTH];
+
+volatile int     init_ok = 0;
+giet_barrier_t   barrier[10];
+user_lock_t      tty_lock;   
 
 void bubbleSort(
@@ -63 +53 @@
         int init_pos_result);
 
-///////////////////////////////////////////////////////
-// This application supports at most 1024 processors
-// Number of barriers = log2(threads)
-
-giet_barrier_t barrier[10];
-
 //////////////////////////////////////////
-__attribute__ ((constructor)) void sort()
+__attribute__ ((constructor)) void main()
+//////////////////////////////////////////
 {
-    int thread_id = giet_thread_id();
     int * src_array = NULL;
     int * dst_array = NULL;
     int i;
-    
-    unsigned int time_start = giet_proctime();
-    unsigned int time_end;   
-
-    // compute number of threads (one thread per proc)
     unsigned int x_size;
     unsigned int y_size;
@@ -86 +65 @@
     unsigned int threads;
 
+    // each thread gets its thread_id
+    int thread_id = giet_thread_id();
+    
+    unsigned int time_start = giet_proctime();
+    unsigned int time_end;   
+
+    // each thread compute number of threads (one thread per proc)
     giet_procs_number( &x_size , &y_size , &nprocs );
     threads = x_size * y_size * nprocs;
 
+    // thread 0 makes TTY and barrier initialisations
+    // other threads wait initialisation completion.
+    if ( thread_id == 0 )
+    {
+        // request a shared TTY used by all threads
+        giet_tty_alloc(1);
+        
+        // TTY lock initialisation
+        lock_init( &tty_lock );
+
+        printf("\n[ SORT T0 ] Starting sort application with %d threads "
+                 "at cycle %d\n", threads, time_start);
+
+        // Barriers Initialization
+        for (i = 0; i < __builtin_ctz( threads ); i++)
+        {
+            barrier_init( &barrier[i], threads >> i );
+        }
+
+        init_ok = 1;
+    }
+    else
+    {
+        while( !init_ok );
+    }
+
+    // each thread checks number of tasks
     if ( (threads != 1)   && (threads != 2)   && (threads != 4)   && 
          (threads != 8)   && (threads != 16 ) && (threads != 32)  && 
@@ -94 +107 @@
          (threads != 512) && (threads != 1024) )
     {
-        task0_printf("[SORT ERROR] Number of processors must be power of 2\n"
-                     "  x_size = %d / y_size = %d / nprocs = %d\n",
-                     x_size , y_size , nprocs );
-        giet_exit("error");
-    }
-
-    task0_printf("\n[ Thread 0 ] Starting sort application with %d threads "
-                 "at cycle %d\n", threads, time_start);
-
-    ///////////////////////////
-    // Barriers Initialization
-
-    if (thread_id == 0)
-    {
-        for (i = 0; i < __builtin_ctz( threads ); i++)
-        {
-            barrier_init(&barrier[i], threads >> i);
-        }
-
-        init_ok = 1;
-    }
-    else
-    {
-        while(!init_ok);
-    }
-
-    ////////////////////////
-    // Array Initialization
-
+        giet_exit("error : number of processors must be power of 2");
+    }
+
+
+    // Each thread contribute to Array Initialization
     for (i = IPT * thread_id; i < IPT * (thread_id + 1); i++)
     {
@@ -128 +117 @@
     }
 
-    ///////////////////////////////////
-    // Parallel sort of array elements
-
-    printf("[ Thread %d ] Stage 0: Sorting...\n\r", thread_id);
+    // all threads contribute to the first stage of parallel sort
+    printf("[ SORT T%d ] Stage 0: Sorting...\n\r", thread_id);
 
     bubbleSort(array0, IPT, IPT * thread_id);
 
-    printf("[ Thread %d ] Finishing Stage 0\n\r", thread_id);
-
+    printf("[ SORT T%d ] Finishing Stage 0\n\r", thread_id);
+
+    // the number of threads is divided by 2 at each next stage
     for (i = 0; i < __builtin_ctz( threads ); i++)
     {
-        barrier_wait(&barrier[i]);
+        barrier_wait( &barrier[i] );
 
         if((thread_id % (2 << i)) != 0)
         {
-            printf("[ Thread %d ] Quit\n\r", thread_id );
+            printf("[ SORT T%d ] Quit\n\r", thread_id );
             giet_exit("Completed");
         }
 
-        printf("[ Thread %d ] Stage %d: Sorting...\n\r", thread_id, i+1);
+        printf("[ SORT T%d ] Stage %d: Sorting...\n\r", thread_id, i+1);
 
         if((i % 2) == 0)
@@ -167 +155 @@
                 );
 
-        printf("[ Thread %d ] Finishing Stage %d\n\r", thread_id, i + 1);
+        printf("[ SORT T%d ] Finishing Stage %d\n\r", thread_id, i + 1);
     }
 
@@ -173 +161 @@
     int failure_index;
 
-    //////////////////////////////
     // Verify the resulting array
-    
     if(thread_id != 0)
     {
@@ -186 +172 @@
         if(dst_array[i] > dst_array[i+1])
         {
-
             success = 0;
             failure_index = i;
@@ -195 +180 @@
     time_end = giet_proctime();
 
-    printf("[ Thread 0 ] Finishing sort application at cycle %d\n"
-           "[ Thread 0 ] Time elapsed = %d\n",
+    printf("[ SORT T0 ] Finishing sort application at cycle %d\n"
+           "[ SORT T0 ] Time elapsed = %d\n",
             time_end, (time_end - time_start) );
 
@@ -205 +190 @@
     else
     {
-        printf("[ Thread 0 ] Failure!! Incorrect element: %d\n\r", 
+        printf("[ SORT T0 ] Failure!! Incorrect element: %d\n\r", 
                failure_index);
         for(i=0; i<ARRAY_LENGTH; i++)

soft/giet_vm/applications/sort/sort.py

@@ -45 +45 @@
 
     # create Vspace
-    vspace = mapping.addVspace( name = 'sort', startname = 'sort_data' )
+    vspace = mapping.addVspace( name = 'sort', startname = 'sort_data', active = False )
 
     # data vseg : non local (only in cluster[0,0])

soft/giet_vm/applications/transpose/main.c

@@ -33 +33 @@
 #define CLUSTER_MAX           (X_MAX * Y_MAX)             // max number of clusters
 #define NN                    256                         // image size : nlines = npixels
-#define INITIAL_FILE_PATH     "misc/lena.raw"             // pathname on virtual disk
+#define INITIAL_FILE_PATH     "/misc/lena_256.raw"        // pathname on virtual disk
 #define TRANSPOSED_FILE_PATH  "/home/lena_transposed.raw" // pathname on virtual disk
 #define RESTORED_FILE_PATH    "/home/lena_restored.raw"   // pathname on virtual disk
 #define INSTRUMENTATION_OK    1                           // display statistics on TTY 
+
+// macro to use a shared TTY
+#define printf(...)     lock_acquire( &tty_lock ); \
+                        giet_tty_printf(__VA_ARGS__);  \
+                        lock_release( &tty_lock )
 
 ///////////////////////////////////////////////////////
@@ -61 +66 @@
 unsigned check_line_after[NN];
 
-// global synchronisation barrier
+// lock protecting shared TTY
+user_lock_t  tty_lock;
+
+// global & local synchronisation variables
 giet_sqt_barrier_t barrier;
 
@@ -98 +106 @@
     unsigned int task_id       = (cluster_id * nprocs) + lpid;  // "continuous" task index
 
+    // checking parameters
+    giet_assert( ((nprocs == 1) || (nprocs == 2) || (nprocs == 4)),
+                 "[TRANSPOSE ERROR] number of procs per cluster must be 1, 2 or 4");
+
+    giet_assert( ((x_size == 1) || (x_size == 2) || (x_size == 4) || 
+                  (x_size == 8) || (x_size == 16)),
+                 "[TRANSPOSE ERROR] x_size must be 1,2,4,8,16");
+
+    giet_assert( ((y_size == 1) || (y_size == 2) || (y_size == 4) || 
+                  (y_size == 8) || (y_size == 16)),
+                 "[TRANSPOSE ERROR] y_size must be 1,2,4,8,16");
+
+    giet_assert( (ntasks <= NN ),
+                 "[TRANSPOSE ERROR] number of tasks larger than number of lines");
 
     ///////////////////////////////////////////////////////////////////////
@@ -107 +129 @@
     if ( (x==0) && (y==0) && (lpid==0) )
     {
-        if ((nprocs != 1) && (nprocs != 2) && (nprocs != 4))
-        { 
-            giet_exit("[TRANSPOSE ERROR] number of procs per cluster must be 1, 2 or 4");
-        }
-        if ((nclusters != 1) && (nclusters != 2) && (nclusters != 4) && 
-            (nclusters != 8) && (nclusters != 16) && (nclusters != 32) && (nclusters != 64) )
-        {
-            giet_exit("[TRANSPOSE ERROR] number of clusters must be 1,2,4,8,16,32,64");
-        }
-        if ( ntasks > NN )
-        {
-            giet_exit("[TRANSPOSE ERROR] number of tasks larger than number of lines");
-        }
-
+        // shared TTY allocation
+        giet_tty_alloc( 1 );
+
+        // TTY lock initialisation
+        lock_init( &tty_lock);
+      
         // distributed heap initialisation
         unsigned int cx , cy;
@@ -134 +148 @@
         sqt_barrier_init( &barrier, x_size , y_size , nprocs );
 
-        giet_shr_printf("\n[TRANSPOSE] Proc [0,0,0] completes heap & barrier init at cycle %d\n",
-                        giet_proctime() );
+        printf("\n[TRANSPOSE] Proc [0,0,0] completes initialisation at cycle %d\n",
+               giet_proctime() );
 
         global_init_ok = 1;
@@ -157 +171 @@
 
         if ( (x==0) && (y==0) )
-        giet_shr_printf("\n[TRANSPOSE] Proc [%d,%d,%d] completes buffer allocation"
-                        " for cluster[%d,%d] at cycle %d\n"
-                        " - buf_in  = %x\n"
-                        " - buf_out = %x\n",
-                        x, y, lpid, x, y, giet_proctime(), 
-                        (unsigned int)buf_in[cluster_id], (unsigned int)buf_out[cluster_id] );
+        printf("\n[TRANSPOSE] Proc [%d,%d,%d] completes buffer allocation"
+               " for cluster[%d,%d] at cycle %d\n"
+               " - buf_in  = %x\n"
+               " - buf_out = %x\n",
+               x, y, lpid, x, y, giet_proctime(), 
+               (unsigned int)buf_in[cluster_id], (unsigned int)buf_out[cluster_id] );
 
         ///////////////////////////////////////////////////////////////////////
@@ -173 +187 @@
         if ( fd_initial < 0 ) 
         { 
-            giet_shr_printf("\n[TRANSPOSE ERROR] Proc [%d,%d,%d] cannot open file %s\n",
-                            x , y , lpid , INITIAL_FILE_PATH );
+            printf("\n[TRANSPOSE ERROR] Proc [%d,%d,%d] cannot open file %s\n",
+                   x , y , lpid , INITIAL_FILE_PATH );
             giet_exit(" open() failure");
         }
         else if ( (x==0) && (y==0) && (lpid==0) )
         {
-            giet_shr_printf("\n[TRANSPOSE] Proc [0,0,0] open file %s / fd = %d\n",
-                            INITIAL_FILE_PATH , fd_initial );
+            printf("\n[TRANSPOSE] Proc [0,0,0] open file %s / fd = %d\n",
+                   INITIAL_FILE_PATH , fd_initial );
         }
 
@@ -187 +201 @@
         if ( fd_transposed < 0 ) 
         { 
-            giet_shr_printf("\n[TRANSPOSE ERROR] Proc [%d,%d,%d] cannot open file %s\n",
+            printf("\n[TRANSPOSE ERROR] Proc [%d,%d,%d] cannot open file %s\n",
                             x , y , lpid , TRANSPOSED_FILE_PATH );
             giet_exit(" open() failure");
@@ -193 +207 @@
         else if ( (x==0) && (y==0) && (lpid==0) )
         {
-            giet_shr_printf("\n[TRANSPOSE] Proc [0,0,0] open file %s / fd = %d\n",
-                            TRANSPOSED_FILE_PATH , fd_transposed );
+            printf("\n[TRANSPOSE] Proc [0,0,0] open file %s / fd = %d\n",
+                   TRANSPOSED_FILE_PATH , fd_transposed );
         }
 
@@ -201 +215 @@
         if ( fd_restored < 0 ) 
         { 
-            giet_shr_printf("\n[TRANSPOSE ERROR] Proc [%d,%d,%d] cannot open file %s\n",
-                            x , y , lpid , RESTORED_FILE_PATH );
+            printf("\n[TRANSPOSE ERROR] Proc [%d,%d,%d] cannot open file %s\n",
+                   x , y , lpid , RESTORED_FILE_PATH );
             giet_exit(" open() failure");
         }
         else if ( (x==0) && (y==0) && (lpid==0) )
         {
-            giet_shr_printf("\n[TRANSPOSE] Proc [0,0,0] open file %s / fd = %d\n",
-                            RESTORED_FILE_PATH , fd_restored );
+            printf("\n[TRANSPOSE] Proc [0,0,0] open file %s / fd = %d\n",
+                   RESTORED_FILE_PATH , fd_restored );
         }
 
@@ -244 +258 @@
                                  SEEK_SET ) != offset )
             {
-                giet_shr_printf("\n[TRANSPOSE ERROR] Proc [%d,%d,%d] cannot seek fd = %d\n",
-                                x , y , lpid , fd_in );
+                printf("\n[TRANSPOSE ERROR] Proc [%d,%d,%d] cannot seek fd = %d\n",
+                       x , y , lpid , fd_in );
                 giet_exit(" seek() failure");
             }
@@ -254 +268 @@
                                 pixels ) != pixels )
             {
-                giet_shr_printf("\n[TRANSPOSE ERROR] Proc [%d,%d,%d] cannot read fd = %d\n",
-                                x , y , lpid , fd_in );
+                printf("\n[TRANSPOSE ERROR] Proc [%d,%d,%d] cannot read fd = %d\n",
+                       x , y , lpid , fd_in );
                 giet_exit(" read() failure");
             }
 
             if ( (x==0) && (y==0) )
-            giet_shr_printf("\n[TRANSPOSE] Proc [%d,%d,%d] completes load"
-                            "  for iteration %d at cycle %d\n",
-                            x, y, lpid, iteration, giet_proctime() );
+            printf("\n[TRANSPOSE] Proc [%d,%d,%d] completes load"
+                   "  for iteration %d at cycle %d\n",
+                   x, y, lpid, iteration, giet_proctime() );
         }
 
@@ -314 +328 @@
         }
 
-        if ( lpid == 0 )
-        {
-            if ( (x==0) && (y==0) )
-            giet_shr_printf("\n[TRANSPOSE] proc [%d,%d,0] completes transpose"
-                            " for iteration %d at cycle %d\n", 
-                            x, y, iteration, giet_proctime() );
+//        if ( lpid == 0 )
+        {
+//            if ( (x==0) && (y==0) )
+            printf("\n[TRANSPOSE] proc [%d,%d,0] completes transpose"
+                   " for iteration %d at cycle %d\n", 
+                   x, y, iteration, giet_proctime() );
 
         }
@@ -340 +354 @@
                              npt );
 
-        if ( (x==0) && (y==0) && (lpid==0) )
-        giet_shr_printf("\n[TRANSPOSE] Proc [%d,%d,%d] completes display"
-                        " for iteration %d at cycle %d\n",
-                        x, y, lpid, iteration, giet_proctime() );
+//        if ( (x==0) && (y==0) && (lpid==0) )
+        printf("\n[TRANSPOSE] Proc [%d,%d,%d] completes display"
+               " for iteration %d at cycle %d\n",
+               x, y, lpid, iteration, giet_proctime() );
 
         DISP_END[x][y][lpid] = giet_proctime();
@@ -364 +378 @@
                                  SEEK_SET ) != offset )
             {
-                giet_shr_printf("\n[TRANSPOSE ERROR] Proc [%d,%d,%d] cannot seek fr = %d\n",
-                                x , y , lpid , fd_out );
+                printf("\n[TRANSPOSE ERROR] Proc [%d,%d,%d] cannot seek fr = %d\n",
+                       x , y , lpid , fd_out );
                 giet_exit(" seek() failure");
             }
@@ -374 +388 @@
                                  pixels ) != pixels )
             {
-                giet_shr_printf("\n[TRANSPOSE ERROR] Proc [%d,%d,%d] cannot write fd = %d\n",
-                                x , y , lpid , fd_out );
+                printf("\n[TRANSPOSE ERROR] Proc [%d,%d,%d] cannot write fd = %d\n",
+                       x , y , lpid , fd_out );
                 giet_exit(" write() failure");
             }
 
             if ( (x==0) && (y==0) )
-            giet_shr_printf("\n[TRANSPOSE] Proc [%d,%d,%d] completes store"
-                            "  for iteration %d at cycle %d\n",
-                            x, y, lpid, iteration, giet_proctime() );
+            printf("\n[TRANSPOSE] Proc [%d,%d,%d] completes store"
+                   "  for iteration %d at cycle %d\n",
+                   x, y, lpid, iteration, giet_proctime() );
         }
 
@@ -437 +451 @@
             }
 
-            giet_shr_printf("\n   ---------------- Instrumentation Results ---------------------\n");
-
-            giet_shr_printf(" - LOAD_START : min = %d / max = %d / med = %d / delta = %d\n",
-                            min_load_start, max_load_start, (min_load_start+max_load_start)/2, 
-                            max_load_start-min_load_start); 
-
-            giet_shr_printf(" - LOAD_END   : min = %d / max = %d / med = %d / delta = %d\n",
-                            min_load_ended, max_load_ended, (min_load_ended+max_load_ended)/2, 
-                            max_load_ended-min_load_ended); 
-
-            giet_shr_printf(" - TRSP_START : min = %d / max = %d / med = %d / delta = %d\n",
-                            min_trsp_start, max_trsp_start, (min_trsp_start+max_trsp_start)/2, 
-                            max_trsp_start-min_trsp_start); 
-
-            giet_shr_printf(" - TRSP_END   : min = %d / max = %d / med = %d / delta = %d\n",
-                            min_trsp_ended, max_trsp_ended, (min_trsp_ended+max_trsp_ended)/2, 
-                            max_trsp_ended-min_trsp_ended); 
-
-            giet_shr_printf(" - DISP_START : min = %d / max = %d / med = %d / delta = %d\n",
-                            min_disp_start, max_disp_start, (min_disp_start+max_disp_start)/2, 
-                            max_disp_start-min_disp_start); 
-
-            giet_shr_printf(" - DISP_END   : min = %d / max = %d / med = %d / delta = %d\n",
-                            min_disp_ended, max_disp_ended, (min_disp_ended+max_disp_ended)/2, 
-                            max_disp_ended-min_disp_ended); 
-
-            giet_shr_printf(" - STOR_START : min = %d / max = %d / med = %d / delta = %d\n",
-                            min_stor_start, max_stor_start, (min_stor_start+max_stor_start)/2, 
-                            max_stor_start-min_stor_start); 
-
-            giet_shr_printf(" - STOR_END   : min = %d / max = %d / med = %d / delta = %d\n",
-                            min_stor_ended, max_stor_ended, (min_stor_ended+max_stor_ended)/2, 
-                            max_stor_ended-min_stor_ended); 
+            printf("\n   ---------------- Instrumentation Results ---------------------\n");
+
+            printf(" - LOAD_START : min = %d / max = %d / med = %d / delta = %d\n",
+                   min_load_start, max_load_start, (min_load_start+max_load_start)/2, 
+                   max_load_start-min_load_start); 
+
+            printf(" - LOAD_END   : min = %d / max = %d / med = %d / delta = %d\n",
+                   min_load_ended, max_load_ended, (min_load_ended+max_load_ended)/2, 
+                   max_load_ended-min_load_ended); 
+
+            printf(" - TRSP_START : min = %d / max = %d / med = %d / delta = %d\n",
+                   min_trsp_start, max_trsp_start, (min_trsp_start+max_trsp_start)/2, 
+                   max_trsp_start-min_trsp_start); 
+
+            printf(" - TRSP_END   : min = %d / max = %d / med = %d / delta = %d\n",
+                   min_trsp_ended, max_trsp_ended, (min_trsp_ended+max_trsp_ended)/2, 
+                   max_trsp_ended-min_trsp_ended); 
+
+            printf(" - DISP_START : min = %d / max = %d / med = %d / delta = %d\n",
+                   min_disp_start, max_disp_start, (min_disp_start+max_disp_start)/2, 
+                   max_disp_start-min_disp_start); 
+
+            printf(" - DISP_END   : min = %d / max = %d / med = %d / delta = %d\n",
+                   min_disp_ended, max_disp_ended, (min_disp_ended+max_disp_ended)/2, 
+                   max_disp_ended-min_disp_ended); 
+
+            printf(" - STOR_START : min = %d / max = %d / med = %d / delta = %d\n",
+                   min_stor_start, max_stor_start, (min_stor_start+max_stor_start)/2, 
+                   max_stor_start-min_stor_start); 
+
+            printf(" - STOR_END   : min = %d / max = %d / med = %d / delta = %d\n",
+                   min_stor_ended, max_stor_ended, (min_stor_ended+max_stor_ended)/2, 
+                   max_stor_ended-min_stor_ended); 
         }
 
@@ -497 +511 @@
     }
 
-    // clean up
-    if ( (x==0) && (y == 0) && (lpid == 0) )
-    { 
-        giet_fat_remove( "/home/lena_transposed" , 0 );
-        giet_fat_remove( "/home/lena_restored" , 0 );
-
-        giet_fat_remove( "/home" , 1 );
-    }
-    
     giet_exit("Completed");
 

soft/giet_vm/applications/transpose/transpose.py

@@ -49 +49 @@
 
     # create vspace
-    vspace = mapping.addVspace( name = 'transpose', startname = 'trsp_data' )
+    vspace = mapping.addVspace( name = 'transpose', startname = 'trsp_data', active = False )
     
     # data vseg : shared (only in cluster[0,0])