Changeset 165

Timestamp:

Jul 4, 2012, 2:51:18 PM (12 years ago)

Author:

alain

Message:

Introducing various modifications in kernel initialisation

Location:

soft/giet_vm

Files:

• Makefile (modified) (5 diffs)
• apps/fifo (deleted)
• apps/hello/main.c (modified) (1 diff)
• apps/numsplit (deleted)
• apps/pgcd/main.c (modified) (2 diffs)
• apps/router/Makefile (modified) (1 diff)
• apps/router/main.c (modified) (7 diffs)
• boot/boot_handler.c (modified) (34 diffs)
• boot/mips32_registers.h (deleted)
• boot/reset.S (modified) (4 diffs)
• giet_config.h (modified) (3 diffs)
• libs/barrier.c (modified) (1 diff)
• libs/barrier.h (modified) (1 diff)
• libs/mwmr.c (deleted)
• libs/mwmr.h (deleted)
• libs/mwmr_channel.c (modified) (6 diffs)
• libs/spin_lock.c (modified) (2 diffs)
• libs/spin_lock.h (modified) (1 diff)
• libs/stdio.c (modified) (48 diffs)
• libs/stdio.h (modified) (1 diff)
• map.xml (modified) (31 diffs)
• memo/Makefile (modified) (1 diff)
• memo/include/mapping_info.h (deleted)
• memo/src/memo.cpp (modified) (15 diffs)
• sys/common.c (modified) (4 diffs)
• sys/common.h (modified) (1 diff)
• sys/ctx_handler.c (modified) (5 diffs)
• sys/ctx_handler.h (modified) (1 diff)
• sys/drivers.c (modified) (19 diffs)
• sys/drivers.h (modified) (2 diffs)
• sys/giet.s (modified) (1 diff)
• sys/init.c (deleted)
• sys/irq_handler.c (modified) (4 diffs)
• sys/irq_handler.h (modified) (1 diff)
• sys/kernel_init.c (added)
• sys/mips32_registers.h (modified) (2 diffs)
• sys/sys.ld (modified) (3 diffs)
• sys/sys_handler.c (modified) (6 diffs)
• sys/task_init.S (deleted)
• xml/mapping_info.h (modified) (7 diffs)
• xml/xml_driver.c (modified) (6 diffs)
• xml/xml_parser.c (modified) (45 diffs)

soft/giet_vm/Makefile

@@ -4 +4 @@
 LD=mipsel-unknown-elf-ld
 DU=mipsel-unknown-elf-objdump
-
 
 #current directory absolute path
@@ -25 +24 @@
 SYS_OBJS_LIST = \
                 sys_handler.o \
-                init.o          \
                 giet.o \
                 switch.o \
@@ -33 +31 @@
                 exc_handler.o \
                 irq_handler.o \
-                task_init.o 
+                kernel_init.o
 
 BOOT_OBJS_LIST = reset.o \
@@ -39 +37 @@
 
 #LIB_SRCS = $(wildcard $(LIB_NAME)/*.c)
-LIB_OBJS_LIST = stdio.o\
-                                mwmr.o\
+LIB_OBJS_LIST = stdio.o \
+                                mwmr_channel.o \
+                                barrier.o \
+                                spin_lock.o \
                                 common.o
 
@@ -73 +73 @@
         @mkdir $(ELF_PATH) 2>$(TRASH)
 
-## compile the parser
 ## mapping compilation
 map.bin: map.xml

soft/giet_vm/apps/hello/main.c

@@ -5 +5 @@
         unsigned int    i;
         char                byte;
-    unsigned int        proc = procid();
+    unsigned int        proc = giet_procid();
 
         for( i=0 ; i<1000 ; i++ )
         {
-                if( tty_printf(" hello from processor %d\n", proc) )
+                if( giet_tty_printf(" hello from processor %d\n", proc) )
                 {
-                        tty_puts("echec tty_printf\n");
-                        exit();
+                        giet_tty_puts("echec tty_printf\n");
+                        giet_exit();
                 }
-        if( tty_getc_irq((void*)&byte) )
+        if( giet_tty_getc((void*)&byte) )
         {
-                        tty_puts("echec tty_getc_irq\n");
-                        exit();
+                        giet_tty_puts("echec tty_getc_irq\n");
+                        giet_exit();
                 } 
-                if(byte == 'q') exit();
+        if ( byte == 'q' ) giet_exit();
         }
-        exit();
+    giet_exit();
 
 } // end main

soft/giet_vm/apps/pgcd/main.c

@@ -7 +7 @@
     unsigned int opy;
 
-    tty_printf(" Interactive PGCD \n");
+    giet_tty_printf(" Interactive PGCD \n");
 
     while (1) 
     {
-        tty_printf("\n*******************\n");
-        tty_printf("operand X = ");
-        tty_getw_irq(&opx);
-        tty_printf("\n");
-        tty_printf("operand Y = ");
-        tty_getw_irq(&opy);
-        tty_printf("\n");
+        giet_tty_printf("\n*******************\n");
+        giet_tty_printf("operand X = ");
+        giet_tty_getw( &opx );
+        giet_tty_printf("\n");
+        giet_tty_printf("operand Y = ");
+        giet_tty_getw( &opy );
+        giet_tty_printf("\n");
         if( (opx == 0) || (opy == 0) ) 
         {
-            tty_printf("operands must be larger than 0\n");
+            giet_tty_printf("operands must be larger than 0\n");
         } 
         else 
@@ -29 +29 @@
                 else            opy = opy - opx;
             }
-            tty_printf("pgcd      = %d\n", opx);
+            giet_tty_printf("pgcd      = %d\n", opx);
         }
     }

soft/giet_vm/apps/router/Makefile

@@ -2 +2 @@
 
 USE+= stdio.o
-USE+= mwmr.o
+USE+= mwmr_channel.o
 
 USES=$(patsubst %,$(BUILD_PATH)/$(LIB_NAME)/%,$(USE))

soft/giet_vm/apps/router/main.c

@@ -1 +1 @@
 #include "stdio.h"
-#include "srl.h"
+#include "mwmr_channel.h"
 
 #define NMAX 200
@@ -10 +10 @@
     unsigned int        n;
     unsigned int        buf;
-    srl_mwmr_t      mwmr;
+    mwmr_channel_t*     mwmr;
 
-    srl_log_printf( TRACE, "*** Starting task producer on processor %d", procid() );
-    srl_log_printf( TRACE, " at cycle %d ***\n\n", proctime() );
+    giet_tty_printf( "*** Starting task producer on processor %d", giet_procid() );
+    giet_tty_printf( " at cycle %d ***\n\n", giet_proctime() );
 
-    if( vobj_get_vbase( "router" , "mwmr_in", MWMR, (unsigned int*)&mwmr ) )
+    if( giet_vobj_get_vbase( "router" , 
+                             "mwmr_in", 
+                             VOBJ_TYPE_MWMR, 
+                             (void*)&mwmr ) )
     {
-        srl_log_printf( NONE, "\n[ERROR] in producer task :\n");
-        srl_log_printf( NONE, "          undefined <mwmr_in> channel: %d\n", mwmr);
-        srl_log_printf( TRACE, "*** &mwmr_in = %x\n\n", (unsigned int)mwmr );
-        exit();
-    }
-    else
-    {
-        srl_log_printf( TRACE, "*** &mwmr_in = %x\n\n", (unsigned int)mwmr );
+        giet_tty_printf( "\n[ERROR] in producer task :\n");
+        giet_tty_printf( "          undefined <mwmr_in> channel: %d\n", mwmr);
+        giet_tty_printf( "*** &mwmr_in = %x\n\n", (unsigned int)mwmr );
+        giet_exit();
     }
 
@@ -31 +30 @@
     { 
         buf = n;
-        srl_mwmr_write( mwmr, &buf , 1 );
-        srl_log_printf( TRACE, "transmitted value : %d\n", buf);
+        mwmr_write( mwmr, &buf , 1 );
+        giet_tty_printf( "transmitted value : %d\n", buf);
     }
 
-    srl_log_printf( TRACE, "\n*** Completing producer task at cycle %d ***\n", proctime());
-    exit();
+    giet_tty_printf( "\n*** Completing producer task at cycle %d ***\n", giet_proctime());
+    giet_exit();
 
 } // end producer()
@@ -45 +44 @@
     unsigned int        n;
     unsigned int        buf[5];
-    srl_mwmr_t  mwmr;
+    mwmr_channel_t*     mwmr;
 
-    srl_log_printf( TRACE, "*** Starting task consumer on processor %d", procid() );
-    srl_log_printf( TRACE, " at cycle %d ***\n\n", proctime() );
+    giet_tty_printf( "*** Starting task consumer on processor %d", giet_procid() );
+    giet_tty_printf( " at cycle %d ***\n\n", giet_proctime() );
 
-    if ( vobj_get_vbase( "router" , "mwmr_out", MWMR, (unsigned int*)&mwmr ) )
+    if ( giet_vobj_get_vbase( "router" , 
+                              "mwmr_out", 
+                              VOBJ_TYPE_MWMR, 
+                              (void*)&mwmr ) )
     {
-        srl_log_printf( NONE, "\n[ERROR] in consumer task :\n");
-        srl_log_printf( NONE, "          undefined <mwmr_out> channel\n");
-        exit();
-    }
-    else
-    {
-        srl_log_printf( TRACE, "*** &mwmr_out = %x\n\n", (unsigned int)mwmr );
+        giet_tty_printf( "\n[ERROR] in consumer task :\n");
+        giet_tty_printf( "          undefined <mwmr_out> channel\n");
+        giet_exit();
     }
 
@@ -64 +62 @@
     for(n = 0 ; n < NMAX ; n = n+5 ) 
     { 
-        srl_mwmr_read( mwmr, buf , 5 );
-        srl_log_printf( TRACE, "received token %d / value = %d\n", n  , buf[0]);
-        srl_log_printf( TRACE, "received token %d / value = %d\n", n+1, buf[1]);
-        srl_log_printf( TRACE, "received token %d / value = %d\n", n+2, buf[2]);
-        srl_log_printf( TRACE, "received token %d / value = %d\n", n+3, buf[3]);
-        srl_log_printf( TRACE, "received token %d / value = %d\n", n+4, buf[4]);
+        mwmr_read( mwmr, buf , 5 );
+        giet_tty_printf( "received token %d / value = %d\n", n  , buf[0]);
+        giet_tty_printf( "received token %d / value = %d\n", n+1, buf[1]);
+        giet_tty_printf( "received token %d / value = %d\n", n+2, buf[2]);
+        giet_tty_printf( "received token %d / value = %d\n", n+3, buf[3]);
+        giet_tty_printf( "received token %d / value = %d\n", n+4, buf[4]);
     }
 
-    srl_log_printf( TRACE, "\n*** Completing consumer task at cycle %d ***\n", proctime());
-    exit();
+    giet_tty_printf( "\n*** Completing consumer task at cycle %d ***\n", giet_proctime());
+    giet_exit();
 
 } // end consumer()
@@ -83 +81 @@
     unsigned int        x;
     unsigned int        tempo;
-    srl_mwmr_t          mwmr_in ;
-    srl_mwmr_t      mwmr_out ;
+    mwmr_channel_t*     mwmr_in ;
+    mwmr_channel_t* mwmr_out ;
 
     
-    srl_log_printf( TRACE, "*** Starting task router on processor %d at cycle %d ***\n\n", 
-                procid(), proctime() );
+    giet_tty_printf( "*** Starting task router on processor %d", giet_procid() ); 
+    giet_tty_printf( " at cycle %d ***\n\n", giet_proctime() );
 
-    if ( vobj_get_vbase( "router" , "mwmr_out", MWMR, (unsigned int*)&mwmr_out ) )
+    if ( giet_vobj_get_vbase( "router" , 
+                              "mwmr_out", 
+                              VOBJ_TYPE_MWMR, 
+                              (void*)&mwmr_out ) )
     {
-        srl_log( NONE, "\n[ERROR] in router task :\n");
-        srl_log( NONE, "          undefined <mwmr_in> channel\n");
-        exit();
-    }
-    else
-    {
-        srl_log_printf( TRACE, "*** &mwmr_out = %x\n\n", (unsigned int)mwmr_out );
+        giet_tty_printf( "\n[ERROR] in router task :\n");
+        giet_tty_printf( "          undefined <mwmr_in> channel\n");
+        giet_exit();
     }
 
-    if (  vobj_get_vbase( "router" , "mwmr_in", MWMR, (unsigned int*)&mwmr_in ) )
+    if (  giet_vobj_get_vbase( "router" , 
+                               "mwmr_in", 
+                               VOBJ_TYPE_MWMR, 
+                               (void*)&mwmr_in ) )
     {
-        srl_log( NONE, "\n[ERROR] in router task :\n");
-        srl_log( NONE, "          undefined <mwmr_out> channel\n");
-        exit();
-    }
-    else
-    {
-        srl_log_printf( TRACE, "*** &mwmr_in = %x\n\n", (unsigned int)mwmr_out );
+        giet_tty_printf( "\n[ERROR] in router task :\n");
+        giet_tty_printf( "          undefined <mwmr_out> channel\n");
+        giet_exit();
     }
 
@@ -115 +111 @@
     while(1)
     {
-        srl_mwmr_read( mwmr_in , buf , 2 );
-        tempo = rand() >> 6;
+        mwmr_read( mwmr_in , buf , 2 );
+        tempo = giet_rand() >> 6;
         for ( x = 0 ; x < tempo ; x++ ) asm volatile ("");
-        srl_log_printf( TRACE, "token value : %d / temporisation = %d\n", buf[0], tempo);
-        srl_log_printf( TRACE, "token value : %d / temporisation = %d\n", buf[1], tempo);
-        srl_mwmr_write( mwmr_out, buf , 2 );
+        giet_tty_printf( "token value : %d / temporisation = %d\n", buf[0], tempo);
+        giet_tty_printf( "token value : %d / temporisation = %d\n", buf[1], tempo);
+        mwmr_write( mwmr_out, buf , 2 );
     }
 }

soft/giet_vm/boot/boot_handler.c

@@ -6 +6 @@
 ///////////////////////////////////////////////////////////////////////////////////
 // The boot_handler.h and boot_handler.c files are part of the GIET nano-kernel.
-// This code can be used in the boot phase to build all the pages tables then jumps
-// in to the seg_kernel_init segment with an activated MMU. 
+// This code is executed in the boot phase by proc0 to build  all the pages tables,
+// then jump in the seg_kernel_init segment with an activated MMU. 
 //
-// It uses the SoCLib generic MMU (paged virtual memory) to provide two services:
-//
+// The SoCLib generic MMU (paged virtual memory) provides two services:
 // 1) classical memory protection, when several independant applications compiled
 //    in different virtual spaces are executing on the same hardware platform.
@@ -16 +15 @@
 //    of the software objects (virtual segments) on the physical memory banks.
 //
-// It uses the MAPPING_INFO binary data structures, that must be pre-loaded in the 
-// boot ROM in the seg_boot_mapping segment (at address seg_mapping_base).
+// The boot code uses the MAPPING_INFO binary data structures, that must be pre-loaded 
+// in the the seg_boot_mapping segment (at address seg_mapping_base).
 // This MAPPING_INFO data structure defines both the hardware architecture,
 // and the mapping:
@@ -32 +31 @@
 // As most applications use only a limited number of segments, the number of PT2s 
 // actually used by a given virtual space is generally smaller than 2048, and is
-// defined in the MAPPING_INFO_BINARY data structure(using the length field). 
-// The value is calculated and put in _max_pte2 indexed by the vspace_id.
+// defined in the MAPPING_INFO_BINARY data structure (using the length field). 
+// The value is calculated and put in _max_pt2 indexed by the vspace_id.
 // The physical alignment constraints, is ensured by the align flag in the MAPPING_INFO 
 // structure.
@@ -41 +40 @@
 // - a first 8K aligned PT1[2148] array, indexed by the (ix1) field of VPN. 
 //   The PT1 contains 2048 PTD of 4 bytes => 8K bytes.
-// - an aray of array PT2[1024][_max_pte2[vspace_id]], indexed by
+// - an aray of array PT2[1024][_max_pt2[vspace_id]], indexed by
 //   the (ix2) field of the VPN, and by the PT2 index (pt2_id).
-//   Each PT2 contains 512 PTE2 of 8bytes => 4Kbytes * _max_pte2[vspace_id]
-// The size of each page table is 8K + (_max_pte2[vspace_id])*4K bytes.
+//   Each PT2 contains 512 PTE2 of 8bytes => 4Kbytes * _max_pt2[vspace_id]
+// The size of each page table is 8K + (_max_pt2[vspace_id])*4K bytes.
 // All page tables must be stored in the seg_kernel_pt segment (at address
 // seg_kernel_pt_base) 
 ////////////////////////////////////////////////////////////////////////////////////
 
-#include <mips32_registers.h>
+#include "../sys/mips32_registers.h"
 #include <boot_handler.h>
 #include <mapping_info.h>
-#include <mwmr.h>
+#include <mwmr_channel.h>
 
 #include <stdarg.h>
@@ -62 +61 @@
 
 ////////////////////////////////////////////////////////////////////////////
-//  Global variables
+//  Page Tables global variables
 ////////////////////////////////////////////////////////////////////////////
 
-// Page Tables 
-// Next free PT2 index 
+// Next free PT2 index array
 unsigned int  _next_free_pt2[GIET_NB_VSPACE_MAX] =
                          { [0 ... GIET_NB_VSPACE_MAX-1] = 0 };
 
-// Max PT2 index 
-unsigned int  _max_pte2[GIET_NB_VSPACE_MAX] =
+// Max number of PT2 array
+unsigned int  _max_pt2[GIET_NB_VSPACE_MAX] =
                          { [0 ... GIET_NB_VSPACE_MAX-1] = 0 };
 
-// Page table pointers
+// Page table pointers array
 page_table_t* _ptabs[GIET_NB_VSPACE_MAX];
 
@@ -107 +105 @@
 
 ////////////////////////////////////////////////////////////////////////////
-// boot_tty_puts()
+// boot_puts()
 // (it uses TTY0)
 ////////////////////////////////////////////////////////////////////////////
-void boot_tty_puts(const char *buffer) 
+void boot_puts(const char *buffer) 
 {
     unsigned int* tty_address = (unsigned int*)&seg_tty_base;
@@ -124 +122 @@
 
 ////////////////////////////////////////////////////////////////////////////
-// boot_tty_putw() 
+// boot_putw() 
 // (it uses TTY0)
 ////////////////////////////////////////////////////////////////////////////
-void boot_tty_putw(unsigned int val)
+void boot_putw(unsigned int val)
 {
     static const char   HexaTab[] = "0123456789ABCDEF";
@@ -142 +140 @@
         val = val >> 4;
     }
-    boot_tty_puts(buf);
+    boot_puts(buf);
 }
 
@@ -219 +217 @@
     mapping_vseg_t*         vseg    = boot_get_vseg_base ( header );
     mapping_task_t*         task    = boot_get_task_base ( header );;
-    mapping_vobj_t*    vobj   = boot_get_vobj_base( header );
+    mapping_vobj_t*     vobj    = boot_get_vobj_base( header );
 
     // header
-    boot_tty_puts("mapping_info");
-
-    boot_tty_puts("\n - signature = ");
-    boot_tty_putw(header->signature);
-    boot_tty_puts("\n - name      = ");
-    boot_tty_puts(header->name);
-    boot_tty_puts("\n - clusters  = ");
-    boot_tty_putw(header->clusters);
-    boot_tty_puts("\n - psegs     = ");
-    boot_tty_putw(header->psegs);
-    boot_tty_puts("\n - ttys      = ");
-    boot_tty_putw(header->ttys);
-    boot_tty_puts("\n - vspaces   = ");
-    boot_tty_putw(header->vspaces);
-    boot_tty_puts("\n - globals   = ");
-    boot_tty_putw(header->globals);
-    boot_tty_puts("\n - vsegs     = ");
-    boot_tty_putw(header->vsegs);
-    boot_tty_puts("\n - tasks     = ");
-    boot_tty_putw(header->tasks);
-    boot_tty_puts("\n\n");
+    boot_puts("mapping_info");
+
+    boot_puts("\n - signature = ");
+    boot_putw(header->signature);
+    boot_puts("\n - name      = ");
+    boot_puts(header->name);
+    boot_puts("\n - clusters  = ");
+    boot_putw(header->clusters);
+    boot_puts("\n - psegs     = ");
+    boot_putw(header->psegs);
+    boot_puts("\n - ttys      = ");
+    boot_putw(header->ttys);
+    boot_puts("\n - fbs       = ");
+    boot_putw(header->fbs);
+    boot_puts("\n - vspaces   = ");
+    boot_putw(header->vspaces);
+    boot_puts("\n - globals   = ");
+    boot_putw(header->globals);
+    boot_puts("\n - vsegs     = ");
+    boot_putw(header->vsegs);
+    boot_puts("\n - vobjs     = ");
+    boot_putw(header->vobjs);
+    boot_puts("\n - tasks     = ");
+    boot_putw(header->tasks);
+    boot_puts("\n\n");
 
     // clusters
     for ( cluster_id = 0 ; cluster_id < header->clusters ; cluster_id++ )
     {
-        boot_tty_puts("cluster ");
-        boot_tty_putw(cluster_id);
-
-        boot_tty_puts("\n - procs  = ");
-        boot_tty_putw(cluster[cluster_id].procs);
-        boot_tty_puts("\n - timers = ");
-        boot_tty_putw(cluster[cluster_id].timers);
-        boot_tty_puts("\n - dmas   = ");
-        boot_tty_putw(cluster[cluster_id].dmas);
-        boot_tty_puts("\n\n");
+        boot_puts("cluster ");
+        boot_putw(cluster_id);
+
+        boot_puts("\n - procs  = ");
+        boot_putw(cluster[cluster_id].procs);
+        boot_puts("\n\n");
     }
 
@@ -262 +260 @@
     for ( pseg_id = 0 ; pseg_id < header->psegs ; pseg_id++ )
     {
-        boot_tty_puts("pseg ");
-        boot_tty_putw(pseg_id);
-
-        boot_tty_puts("\n - name   = ");
-        boot_tty_puts( pseg[pseg_id].name );
-        boot_tty_puts("\n - base   = ");
-        boot_tty_putw( pseg[pseg_id].base );
-        boot_tty_puts("\n - length = ");
-        boot_tty_putw( pseg[pseg_id].length );
-        boot_tty_puts("\n\n");
+        boot_puts("pseg ");
+        boot_putw(pseg_id);
+
+        boot_puts("\n - name   = ");
+        boot_puts( pseg[pseg_id].name );
+        boot_puts("\n - base   = ");
+        boot_putw( pseg[pseg_id].base );
+        boot_puts("\n - length = ");
+        boot_putw( pseg[pseg_id].length );
+        boot_puts("\n\n");
     }
 
@@ -277 +275 @@
     for ( vseg_id = 0 ; vseg_id < header->globals ; vseg_id++ )
     {
-        boot_tty_puts("global vseg ");
-        boot_tty_putw(vseg_id);
-
-        boot_tty_puts("\n - name   = ");
-        boot_tty_puts( vseg[vseg_id].name );
-        boot_tty_puts("\n - vbase  = ");
-        boot_tty_putw( vseg[vseg_id].vbase );
-        boot_tty_puts("\n - length = ");
-        boot_tty_putw( vseg[vseg_id].length );
-        boot_tty_puts("\n - mode   = ");
-        boot_tty_putw( vseg[vseg_id].mode );
-        boot_tty_puts("\n - ident = ");
-        boot_tty_putw( vseg[vseg_id].ident );
-        boot_tty_puts("\n - psegname = ");
-        boot_tty_puts( pseg[vseg[vseg_id].psegid].name );
-        boot_tty_puts("\n");
-        for ( vobj_id = vseg[vseg_id].vobj_offset ; vobj_id < vseg[vseg_id].vobj_offset + vseg[vseg_id].vobjs ; vobj_id++ )
-        {
-                        boot_tty_puts("vobjs: \n");
-            boot_tty_putw( vobj[vobj_id].name);
-            boot_tty_puts("\n");
-            boot_tty_puts("\t name     = ");
-                        boot_tty_putw(  vobj[vobj_id].name);
-                        boot_tty_puts("\n");
-            boot_tty_puts("\t type     = ");
-                        boot_tty_putw( vobj[vobj_id].type);
-                        boot_tty_puts("\n");
-            boot_tty_puts("\t length   = ");
-                        boot_tty_putw(   vobj[vobj_id].length);
-                        boot_tty_puts("\n");
-            boot_tty_puts("\t align    = ");
-                        boot_tty_putw(   vobj[vobj_id].align);
-                        boot_tty_puts("\n");
-            boot_tty_puts("\t binpath  = ");
-                        boot_tty_putw(   vobj[vobj_id].binpath);
-                        boot_tty_puts("\n\n");
+        boot_puts("global vseg ");
+        boot_putw(vseg_id);
+
+        boot_puts("\n - name        = ");
+        boot_puts( vseg[vseg_id].name );
+        boot_puts("\n - vbase       = ");
+        boot_putw( vseg[vseg_id].vbase );
+        boot_puts("\n - length      = ");
+        boot_putw( vseg[vseg_id].length );
+        boot_puts("\n - mode        = ");
+        boot_putw( vseg[vseg_id].mode );
+        boot_puts("\n - ident       = ");
+        boot_putw( vseg[vseg_id].ident );
+        boot_puts("\n - psegname    = ");
+        boot_puts( pseg[vseg[vseg_id].psegid].name );
+        boot_puts("\n - vobjs       = ");
+        boot_putw( vseg[vseg_id].vobjs );
+        boot_puts("\n - vobj_offset = ");
+        boot_putw( vseg[vseg_id].vobj_offset );
+        boot_puts("\n");
+        for ( vobj_id = vseg[vseg_id].vobj_offset ; 
+              vobj_id < vseg[vseg_id].vobj_offset + vseg[vseg_id].vobjs ; 
+              vobj_id++ )
+        {
+                        boot_puts("\n\t vobj ");
+            boot_puts( vobj[vobj_id].name);
+            boot_puts("\n\t type     = ");
+                        boot_putw( vobj[vobj_id].type);
+            boot_puts("\n\t length   = ");
+                        boot_putw(   vobj[vobj_id].length);
+            boot_puts("\n\t align    = ");
+                        boot_putw(   vobj[vobj_id].align);
+            boot_puts("\n\t binpath  = ");
+                        boot_puts(   vobj[vobj_id].binpath);
+                        boot_puts("\n\n");
         }
     }
@@ -319 +316 @@
     for ( vspace_id = 0 ; vspace_id < header->vspaces ; vspace_id++ )
     {
-        unsigned int func_id = vspace[vspace_id].vobj_offset + vspace[vspace_id].funcs_offset; 
-        boot_tty_puts("vspace ");
-        boot_tty_putw(vspace_id);
-
-        boot_tty_puts("\n - name    = ");
-        boot_tty_puts( vspace[vspace_id].name ); 
-        boot_tty_puts("\n - funcs    = ");
-        boot_tty_puts( vobj[func_id].name ); 
-        boot_tty_puts( vspace[vspace_id].name ); 
-        boot_tty_puts("\n - ttys    = ");
-        boot_tty_putw( vspace[vspace_id].ttys );
-        boot_tty_puts("\n\n");
+        unsigned int start_id = vspace[vspace_id].vobj_offset + 
+                                vspace[vspace_id].start_offset; 
+
+        boot_puts("vspace ");
+        boot_putw(vspace_id);
+
+        boot_puts("\n - name        = ");
+        boot_puts( vspace[vspace_id].name ); 
+        boot_puts("\n - start_vobj  = ");
+        boot_puts( vobj[start_id].name ); 
+        boot_puts("\n - vsegs       = ");
+        boot_putw( vspace[vspace_id].vsegs ); 
+        boot_puts("\n - vobjs       = ");
+        boot_putw( vspace[vspace_id].vobjs ); 
+        boot_puts("\n - tasks       = ");
+        boot_putw( vspace[vspace_id].tasks ); 
+        boot_puts("\n - vseg_offset = ");
+        boot_putw( vspace[vspace_id].vseg_offset ); 
+        boot_puts("\n - vobj_offset = ");
+        boot_putw( vspace[vspace_id].vobj_offset ); 
+        boot_puts("\n - task_offset = ");
+        boot_putw( vspace[vspace_id].task_offset ); 
+        boot_puts("\n\n");
 
         for ( vseg_id = vspace[vspace_id].vseg_offset ; 
@@ -336 +344 @@
               vseg_id++ )
         {
-            boot_tty_puts("    private vseg ");
-            boot_tty_putw( vseg_id );
-
-            boot_tty_puts("\n    - name   = ");
-            boot_tty_puts( vseg[vseg_id].name );
-            boot_tty_puts("\n    - vbase  = ");
-            boot_tty_putw( vseg[vseg_id].vbase );
-            boot_tty_puts("\n    - length = ");
-            boot_tty_putw( vseg[vseg_id].length );
-            boot_tty_puts("\n    - mode   = ");
-            boot_tty_putw( vseg[vseg_id].mode );
-            boot_tty_puts("\n    - ident = ");
-            boot_tty_putw( vseg[vseg_id].ident );
-            boot_tty_puts("\n    - psegname = ");
-            boot_tty_puts( pseg[vseg[vseg_id].psegid].name );
-            boot_tty_puts("\n");
-            for ( vobj_id = vseg[vseg_id].vobj_offset ; vobj_id < vseg[vseg_id].vobj_offset + vseg[vseg_id].vobjs ; vobj_id++ )
+            boot_puts("    private vseg ");
+            boot_putw( vseg_id );
+
+            boot_puts("\n    - name        = ");
+            boot_puts( vseg[vseg_id].name );
+            boot_puts("\n    - vbase       = ");
+            boot_putw( vseg[vseg_id].vbase );
+            boot_puts("\n    - length      = ");
+            boot_putw( vseg[vseg_id].length );
+            boot_puts("\n    - mode        = ");
+            boot_putw( vseg[vseg_id].mode );
+            boot_puts("\n    - ident       = ");
+            boot_putw( vseg[vseg_id].ident );
+            boot_puts("\n    - psegname    = ");
+            boot_puts( pseg[vseg[vseg_id].psegid].name );
+            boot_puts("\n    - vobjs       = ");
+            boot_putw( vseg[vseg_id].vobjs );
+            boot_puts("\n    - vobj_offset = ");
+            boot_putw( vseg[vseg_id].vobj_offset );
+            boot_puts("\n");
+
+            for ( vobj_id = vseg[vseg_id].vobj_offset ; 
+                  vobj_id < vseg[vseg_id].vobj_offset + vseg[vseg_id].vobjs ; 
+                  vobj_id++ )
             {
-                boot_tty_puts("\t\t vobjs     = ");
-                                boot_tty_putw(     vobj[vobj_id].name);
-                                boot_tty_puts("\n");
-                boot_tty_puts("\t\t name     = ");
-                                boot_tty_putw(     vobj[vobj_id].name);
-                                boot_tty_puts("\n");
-                boot_tty_puts("\t\t type     = ");
-                                boot_tty_putw( vobj[vobj_id].type);
-                                boot_tty_puts("\n");
-                boot_tty_puts("\t\t length   = ");
-                                boot_tty_putw(   vobj[vobj_id].length);
-                                boot_tty_puts("\n");
-                boot_tty_puts("\t\t align    = ");
-                                boot_tty_putw(   vobj[vobj_id].align);
-                                boot_tty_puts("\n");
-                boot_tty_puts("\t\t binpath  = ");
-                                boot_tty_putw(   vobj[vobj_id].binpath);
-                                boot_tty_puts("\n");
+                boot_puts("\n\t\t vobj ");
+                boot_puts( vobj[vobj_id].name);
+                boot_puts("\n\t\t type     = ");
+                boot_putw( vobj[vobj_id].type);
+                boot_puts("\n\t\t length   = ");
+                            boot_putw(   vobj[vobj_id].length);
+                boot_puts("\n\t\t align    = ");
+                            boot_putw(   vobj[vobj_id].align);
+                boot_puts("\n\t\t binpath  = ");
+                        boot_puts(   vobj[vobj_id].binpath);
+                        boot_puts("\n\n");
             }
         }
@@ -379 +387 @@
               task_id++ )
         {
-            boot_tty_puts("     task");
-            boot_tty_putw( task_id );
-
-            boot_tty_puts("\n     - name = ");
-            boot_tty_puts( task[task_id].name );
-            boot_tty_puts("\n     - clusterid = ");
-            boot_tty_putw( task[task_id].clusterid );
-            boot_tty_puts("\n     - proclocid = ");
-            boot_tty_putw( task[task_id].proclocid );
-            boot_tty_puts("\n     - vobjlocid = ");
-            boot_tty_putw( task[task_id].vobjlocid );
-            boot_tty_puts("\n     - startid   = ");
-            boot_tty_putw( task[task_id].startid );
-            boot_tty_puts("\n     - ttylocid  = ");
-            boot_tty_putw( task[task_id].ttylocid );
-            boot_tty_puts("\n\n");
+            boot_puts("     task");
+            boot_putw( task_id );
+
+            boot_puts("\n     - name = ");
+            boot_puts( task[task_id].name );
+            boot_puts("\n     - clusterid = ");
+            boot_putw( task[task_id].clusterid );
+            boot_puts("\n     - proclocid = ");
+            boot_putw( task[task_id].proclocid );
+            boot_puts("\n     - vobjlocid = ");
+            boot_putw( task[task_id].vobjlocid );
+            boot_puts("\n     - startid   = ");
+            boot_putw( task[task_id].startid );
+            boot_puts("\n     - use_tty   = ");
+            boot_putw( task[task_id].use_tty );
+            boot_puts("\n     - use_fb   = ");
+            boot_putw( task[task_id].use_fb );
+            boot_puts("\n\n");
         }
     }
@@ -403 +413 @@
 // boot_pseg_get() 
 // This function returns the pointer on a physical segment
-// identified  by the segment index.
+// identified  by the pseg index.
 //////////////////////////////////////////////////////////////////////////////
 mapping_pseg_t* boot_pseg_get( unsigned int seg_id)
@@ -413 +423 @@
     if ( seg_id >= header->psegs )
     {
-        boot_tty_puts("\n[BOOT ERROR] : seg_id argument too large\n");
-        boot_tty_puts("               in function boot_pseg_get()\n");
+        boot_puts("\n[BOOT ERROR] : seg_id argument too large\n");
+        boot_puts("               in function boot_pseg_get()\n");
         boot_exit();
     }
@@ -420 +430 @@
     return &pseg[seg_id];                                    
 } // end boot_pseg_get()
-
 
 //////////////////////////////////////////////////////////////////////////////
@@ -450 +459 @@
 
         
-    unsigned int max_pte2   = _max_pte2[vspace_id];
-    if(max_pte2 == 0)
-    {
-        boot_tty_puts("Unfound page table for vspace ");
-        boot_tty_putw(vspace_id);
-        boot_tty_puts("\n");
+    unsigned int max_pt2   = _max_pt2[vspace_id];
+    if(max_pt2 == 0)
+    {
+        boot_puts("Unfound page table for vspace ");
+        boot_putw(vspace_id);
+        boot_puts("\n");
         boot_exit();
     }
@@ -463 +472 @@
     {
         pt2_id = _next_free_pt2[vspace_id];
-        if ( pt2_id == max_pte2 )
-        {
-            boot_tty_puts("\n[BOOT ERROR] in boot_add_pte() function\n");
-            boot_tty_puts("the length of the ptab vobj is too small\n"); 
+        if ( pt2_id == max_pt2 )
+        {
+            boot_puts("\n[BOOT ERROR] in boot_add_pte() function\n");
+            boot_puts("the length of the ptab vobj is too small\n"); 
             boot_exit();
         }
@@ -487 +496 @@
     if ( ( *pt_flags & PTE_V) != 0 )    // page already mapped
     {
-        if(global)
-        {
-            boot_tty_puts("\n[BOOT ERROR] in boot_add_pte() function\n");
-            boot_tty_puts("page already mapped\n");
-            boot_exit();
-        }else
-        {
-            /**
-             * The case where a global vseg is already mapped as private vseg of a
-             * vspace_id. Typically used when a vseg is being replicated.
-             */  
-            boot_tty_puts("\n[BOOT] global PTE for vspace ");
-            boot_tty_putw(vspace_id);
-            boot_tty_puts(" already mapped, vpn = ");
-            boot_tty_putw(vpn);
-            boot_tty_puts("\n");
-            return;
-        }
+        boot_puts("\n[BOOT ERROR] in boot_add_pte() function\n");
+        boot_puts("page already mapped\n");
+        boot_exit();
     }
 
@@ -549 +543 @@
 
 #if BOOT_DEBUG_PT
-boot_tty_puts("- vseg ");
-boot_tty_puts( vseg[vseg_id].name );
-boot_tty_puts(" / flags = ");
-boot_tty_putw( flags );
-boot_tty_puts("\n");
+boot_puts("- vseg ");
+boot_puts( vseg[vseg_id].name );
+boot_puts(" / flags = ");
+boot_putw( flags );
+boot_puts(" / npages = ");
+boot_putw( npages );
+boot_puts("\n");
 #endif        
         // loop on 4K pages
@@ -583 +579 @@
 
 #if BOOT_DEBUG_PT
-boot_tty_puts("- vseg ");
-boot_tty_puts( vseg[vseg_id].name );
-boot_tty_puts(" / flags = ");
-boot_tty_putw( flags );
-boot_tty_puts(" / npages = ");
-boot_tty_putw( npages );
-boot_tty_puts("\n");
+boot_puts("- vseg ");
+boot_puts( vseg[vseg_id].name );
+boot_puts(" / flags = ");
+boot_putw( flags );
+boot_puts(" / npages = ");
+boot_putw( npages );
+boot_puts("\n");
 #endif        
         // loop on 4K pages
@@ -606 +602 @@
 } // end boot_vspace_pt_build()
 
-
 ///////////////////////////////////////////////////////////////////////////
 // Align the value "toAlign" to the required alignement indicated by
 // alignPow2 ( the logarithme of 2 the alignement).
 ///////////////////////////////////////////////////////////////////////////
-unsigned int align_to( unsigned toAlign, unsigned alignPow2)
-{
-    unsigned mask = (1 << alignPow2) - 1;
-    return ((toAlign + mask ) & ~mask );//page aligned 
-}
-
-///////////////////////////////////////////////////////////////////////////
-// Initialise vobjs
-// For now only one type is initialised the: PTAB
-//
-// param:
-//  vobj: the vobj to initialise
-//  region_id: the vspace in wich the vobj is located or the global space(-1).
-///////////////////////////////////////////////////////////////////////////
-void initailise_vobj(mapping_vobj_t* vobj, unsigned int region_id)
-{
-    if(vobj->type == PTAB)
-    {
-        if(region_id == ((unsigned int) -1))
-        {
-            boot_tty_puts( "No PTAB vobjs are allowed in the global region" );
-            boot_exit();
-        }
-        if(vobj->length < (PT1_SIZE + PT2_SIZE) ) //at least one pt2 => ( max_pt2 >= 1)
-        {
-            boot_tty_puts("PTAB too small, minumum size is ");
-            boot_tty_putw( PT1_SIZE + PT2_SIZE);
-            boot_exit();
-        }
-
-        _ptabs[region_id]        = (page_table_t*) vobj->paddr;
-        _max_pte2[region_id]    = (vobj->length - PT1_SIZE) / PT2_SIZE;
-
-#if BOOT_DEBUG_VIEW
-        boot_tty_puts("ptabs for vspace ");
-        boot_tty_putw(region_id);
-        boot_tty_puts(" address: ");
-        boot_tty_putw((unsigned)_ptabs[region_id]);
-        boot_tty_puts("\n");
-#endif
-    } 
+unsigned int align_to( unsigned int toAlign, 
+                       unsigned int alignPow2)
+{
+    unsigned int    mask = (1 << alignPow2) - 1;
+    return ((toAlign + mask ) & ~mask ); 
 }
 
@@ -660 +619 @@
 // It updates the page allocator (nextfreepage field of the pseg),
 // and checks a possible pseg overflow.
-// region_id: the vspace in wich the vseg is located or the global space(-1).
+// It is a global vseg if vspace_id = (-1) 
 ///////////////////////////////////////////////////////////////////////////
-void boot_vseg_map( mapping_vseg_t* vseg, unsigned int region_id ) 
-{
-    unsigned pages;
-    unsigned vobj_id;
-    unsigned cur_vaddr;
-    unsigned cur_paddr;
+void boot_vseg_map( mapping_vseg_t*     vseg, 
+                    unsigned int        vspace_id ) 
+{
+    unsigned int        pages;
+    unsigned int        vobj_id;
+    unsigned int        cur_vaddr;
+    unsigned int        cur_paddr;
     mapping_header_t*   header = (mapping_header_t*)&seg_mapping_base;  
     mapping_vobj_t*     vobj   = boot_get_vobj_base( header );
@@ -677 +637 @@
     if ( vseg->ident != 0 )            // identity mapping required
     {
-        // check physical segment overflow  
-        if ( (vseg->vbase < pseg->base) || 
-             ((vseg->vbase + vseg->length) > (pseg->base + pseg->length)) )
-        {
-            boot_tty_puts("\n[BOOT ERROR] in boot_vseg_map() function\n");
-            boot_tty_puts("impossible identity mapping for virtual segment: ");
-            boot_tty_puts( vseg->name ); 
-            boot_tty_puts("\n"); 
-            boot_exit();
-        }
-        vseg->pbase = vseg->vbase;
+         vseg->pbase = vseg->vbase;
     }
     else                                // unconstrained mapping
     {
-        // check physical segment overflow
-        if ( (vseg->vbase + vseg->length) > (pseg->base + pseg->length) )
-        {
-            boot_tty_puts("\n[BOOT ERROR] in boot_vseg_map() function\n");
-            boot_tty_puts("physical segment ");
-            boot_tty_puts( pseg->name ); 
-            boot_tty_puts(" is too small to map virtual segment");
-            boot_tty_puts( vseg->name ); 
-            boot_tty_puts("\n");
-            boot_exit();
-        }
         vseg->pbase = pseg->base + (pseg->next_free_page<<12);
     }
     
-
-    //loop on vobj:
-    // + to computes the length of the current vseg
-    // + Align vobjs
-    // + Initialise the vobj
+    // loop on vobjs to computes the length of the vseg,
+    // initialise the vaddr and paddr fields of all vobjs,
+    // and initialise the page table pointers array 
     cur_vaddr = vseg->vbase;
     cur_paddr = vseg->pbase;
-    for(vobj_id= vseg->vobj_offset; vobj_id < (vseg->vobj_offset + vseg->vobjs); vobj_id++)
-    {
-        if(vobj[vobj_id].align)
+
+    for( vobj_id = vseg->vobj_offset; 
+         vobj_id < (vseg->vobj_offset + vseg->vobjs); 
+         vobj_id++)
+    {
+        if ( vobj[vobj_id].align )
         {
             cur_paddr = align_to(cur_paddr, vobj[vobj_id].align);
         }
 
-        //set vaddr/paddr
+        // set vaddr/paddr
         vobj[vobj_id].vaddr = cur_vaddr;        
         vobj[vobj_id].paddr = cur_paddr;  
       
-        //set next vaddr/paddr
+        // set next vaddr/paddr
         cur_vaddr += vobj[vobj_id].length;
         cur_paddr += vobj[vobj_id].length; 
-        initailise_vobj(&vobj[vobj_id], region_id);
+
+        // initialise _ptabs[] and _max_pt2[]
+        if ( vobj[vobj_id].type == VOBJ_TYPE_PTAB )
+        {
+            if(vobj[vobj_id].length < (PT1_SIZE + PT2_SIZE) ) // max_pt2 >= 1
+            {
+                boot_puts( "\n[BOOT ERROR] in boot_vseg_map() function: " );
+                boot_puts("PTAB vobj is too small in vspace ");
+                boot_putw(vspace_id);
+                boot_puts("\n");
+                boot_exit();
+            }
+            if(vspace_id == ((unsigned int) -1))    // global vseg
+            {
+                boot_puts( "\n[BOOT ERROR] in boot_vseg_map() function: " );
+                boot_puts( "a PTAB vobj cannot be global" );
+                boot_exit();
+            }
+            _ptabs[vspace_id]   = (page_table_t*)vobj[vobj_id].paddr;
+            _max_pt2[vspace_id] = (vobj[vobj_id].length - PT1_SIZE) / PT2_SIZE;
+        }
     } 
     
-    //set the length
-    vseg->length = align_to((cur_paddr - vseg->pbase), 12);
+    //set the vseg length
+    unsigned int plength = pseg->length;
+    unsigned int vlength = cur_paddr - vseg->pbase;
+    vseg->length = align_to(vlength, 12);
+
+    // checking pseg overflow
+    if ( (vseg->pbase < pseg->base) || 
+         ((vseg->pbase + vlength) > (pseg->base + plength)) )
+    {
+        boot_puts("\n[BOOT ERROR] in boot_vseg_map() function\n");
+        boot_puts("impossible identity mapping for virtual segment: ");
+        boot_puts( vseg->name ); 
+        boot_puts("\n"); 
+        boot_puts("vseg pbase = ");
+        boot_putw( vseg->pbase ); 
+        boot_puts("\n"); 
+        boot_puts("vseg length = ");
+        boot_putw( vseg->length ); 
+        boot_puts("\n"); 
+        boot_puts("pseg pbase = ");
+        boot_putw( pseg->base ); 
+        boot_puts("\n"); 
+        boot_puts("pseg length = ");
+        boot_putw( pseg->length ); 
+        boot_puts("\n"); 
+        boot_exit();
+    }
 
     // computes number of pages
@@ -743 +728 @@
 
 #if BOOT_DEBUG_PT
-boot_tty_puts("- vseg ");
-boot_tty_puts( vseg->name );
-boot_tty_puts(" : vbase = ");
-boot_tty_putw( vseg->vbase );
-boot_tty_puts(" / pbase = ");
-boot_tty_putw( vseg->pbase );
-boot_tty_puts("\n");
+boot_puts("- vseg ");
+boot_puts( vseg->name );
+boot_puts(" : vbase = ");
+boot_putw( vseg->vbase );
+boot_puts(" / pbase = ");
+boot_putw( vseg->pbase );
+boot_puts("\n");
 #endif  
 
@@ -755 +740 @@
 
 /////////////////////////////////////////////////////////////////////
-// This function cheks the mapping_info data structure 
+// This function checks the mapping_info data structure 
 /////////////////////////////////////////////////////////////////////
 void boot_check_mapping()
@@ -764 +749 @@
     if ( header->signature != IN_MAPPING_SIGNATURE )
     {
-        boot_tty_puts("\n[BOOT ERROR] Illegal mapping signature: ");
-        boot_tty_putw(header->signature);
-        boot_tty_puts("\n");
+        boot_puts("\n[BOOT ERROR] Illegal mapping signature: ");
+        boot_putw(header->signature);
+        boot_puts("\n");
         boot_exit();
     }
@@ -777 +762 @@
     if ( header->clusters != NB_CLUSTERS )
     {
-        boot_tty_puts("\n[BOOT ERROR] Incoherent NB_CLUSTERS");
-        boot_tty_puts("\n             - In giet_config,  value = ");
-        boot_tty_putw ( NB_CLUSTERS );
-        boot_tty_puts("\n             - In mapping_info, value = ");
-        boot_tty_putw ( header->clusters );
-        boot_tty_puts("\n");
+        boot_puts("\n[BOOT ERROR] Incoherent NB_CLUSTERS");
+        boot_puts("\n             - In giet_config,  value = ");
+        boot_putw ( NB_CLUSTERS );
+        boot_puts("\n             - In mapping_info, value = ");
+        boot_putw ( header->clusters );
+        boot_puts("\n");
         boot_exit();
     }
@@ -789 +774 @@
     if ( header->ttys != NB_TTYS )
     {
-        boot_tty_puts("\n[BOOT ERROR] Incoherent NB_TTYS");
-        boot_tty_puts("\n             - In giet_config,  value = ");
-        boot_tty_putw ( NB_TTYS );
-        boot_tty_puts("\n             - In mapping_info, value = ");
-        boot_tty_putw ( header->ttys );
-        boot_tty_puts("\n");
+        boot_puts("\n[BOOT ERROR] Incoherent NB_TTYS");
+        boot_puts("\n             - In giet_config,  value = ");
+        boot_putw ( NB_TTYS );
+        boot_puts("\n             - In mapping_info, value = ");
+        boot_putw ( header->ttys );
+        boot_puts("\n");
         boot_exit();
     }
@@ -801 +786 @@
     if ( header->vspaces > GIET_NB_VSPACE_MAX )
     {
-        boot_tty_puts("\n[BOOT ERROR] : number of vspaces > GIET_NB_VSPACE_MAX\n");
-        boot_tty_puts("\n");
+        boot_puts("\n[BOOT ERROR] : number of vspaces > GIET_NB_VSPACE_MAX\n");
+        boot_puts("\n");
         boot_exit();
     }
@@ -825 +810 @@
     unsigned int        pseg_id;
 
-    // first loop on virtual spaces to map global vsegs
+    // checking mapping_info
+    boot_check_mapping();
+
+    // physical page allocators must be initialised 
+    for ( pseg_id = 0 ; pseg_id < header->psegs ; pseg_id++ )
+    {
+        pseg[pseg_id].next_free_page = 0;
+    }
 
 #if BOOT_DEBUG_PT
-boot_tty_puts("\n******* mapping global vsegs ********");
+boot_puts("\n******* mapping global vsegs ********\n");
 #endif
             
-    // physical page allocators must be initialised ???
-    for ( pseg_id = 0 ; pseg_id < header->psegs ; pseg_id++ )
-    {
-        pseg[pseg_id].next_free_page = 0;
-    }
-
+    // step 1 : first loop on virtual spaces to map global vsegs
     for ( vseg_id = 0 ; vseg_id < header->globals ; vseg_id++ )
     {
@@ -842 +829 @@
     }
 
-    // loop on virtual vspaces to map private vsegs
+    // step 2 : loop on virtual vspaces to map private vsegs
     for ( vspace_id = 0 ; vspace_id < header->vspaces ; vspace_id++ )
     {
 
 #if BOOT_DEBUG_PT
-boot_tty_puts("\n******* mapping private vsegs in vspace ");
-boot_tty_puts(vspace[vspace_id].name);
-boot_tty_puts(" ********\n");
+boot_puts("\n******* mapping private vsegs in vspace ");
+boot_puts(vspace[vspace_id].name);
+boot_puts(" ********\n");
 #endif
             
@@ -860 +847 @@
     } 
 
-    // loop on the vspaces to build the page tables
+    // step 3 : loop on the vspaces to build the page tables
     for ( vspace_id = 0 ; vspace_id < header->vspaces ; vspace_id++ )
     {
 
 #if BOOT_DEBUG_PT
-boot_tty_puts("\n******* building page table for vspace ");
-boot_tty_puts(vspace[vspace_id].name);
-boot_tty_puts(" ********\n");
+boot_puts("\n******* building page table for vspace ");
+boot_puts(vspace[vspace_id].name);
+boot_puts(" ********\n");
 #endif
             
         boot_vspace_pt_build( vspace_id );
+
+#if BOOT_DEBUG_PT
+boot_puts(">>> page table physical address = ");
+boot_putw((unsigned)_ptabs[vspace_id]);
+boot_puts("\n");
+#endif
     } 
+
+    boot_puts("\n[BOOT] Page Tables initialisation completed at cycle ");
+    boot_putw( boot_time() );
+    boot_puts("\n");
+
 } // end boot_pt_init()
-
-
-
-////////////////////////////////////////////////////////////////////////////////////
-// boot_init()
-// This function is executed by one single processor to initialize the page
-// tables, the tasks contexts and the peripherals, for all applications.
-////////////////////////////////////////////////////////////////////////////////////
-void boot_init()
-{
-    // checking mapping_info
-    boot_check_mapping();
-
-    // building page tables
-    boot_pt_init();
-    boot_tty_puts("\n[BOOT] Page Tables completed at cycle ");
-    boot_tty_putw( boot_time() );
-    boot_tty_puts("\n");
-
-} // end boot_init()
 
 // Local Variables:

soft/giet_vm/boot/reset.S

@@ -1 +1 @@
 /********************************************************************************/
-/*      File : reset.S                                                              */
-/*      Author : Alain Greiner  & Mohamed karaoui               */
-/*      Date : 03/06/2012                                                           */
+/*      File : reset.S                                                              */
+/*      Author : Alain Greiner  & Mohamed karaoui                                   */
+/*      Date : 03/06/2012                                                                                       */
 /********************************************************************************/
 /* This boot code is for a multi-cluster, multi-processor architecture,             */
-/* running one or several multi-tasks software application(s) defined in the    */
+/* running one or several multi-tasks software application(s) defined in        */
 /* the mapping_info data-structure.                                                                     */
-/* It uses the mapping_info data structure to build the page tables.            */
-/* Processor 0 is in charge of building all pages tables.                       */
+/* Procesor 0 uses the mapping_info data structure to build all page tables     */
+/* before jumping to the kernel_init code.                                                                              */
 /* Other processors are waiting until the mapping_info signature has been       */
 /* modified by processor 0 (done while executing kernel_init code).             */
+/* Implementation note:                                                                                                                 */
 /* The entry point is 0xbfc00000, but the actual boot code starts at address    */
 /* 0xbfc00500, and a minimal boot exception handler is implemented at address   */
@@ -17 +18 @@
                 
 #include <giet_config.h>
-#include <mips32_registers.h>
+#include "../sys/mips32_registers.h"
 
 #define EXCEP_ORG               0x380
@@ -44 +45 @@
 boot_excep:
     la  a0,     boot_error_string
-    jal boot_tty_puts
+    jal boot_puts
     nop
     mfc0        a0,     CP0_TIME
-        jal     boot_tty_putw
+        jal     boot_putw
         nop
     la  a0,     boot_lf_string
-    jal boot_tty_puts
+    jal boot_puts
+    nop
+
+        la      a0,     boot_pid_string
+    jal boot_puts
+    nop
+    mfc0        k0,     CP0_PROCID
+    andi        a0,     k0,     0xFFF
+        jal     boot_putw
+    nop
+    la  a0,     boot_lf_string
+    jal boot_puts
     nop
 
         la      a0,     boot_epc_string
-    jal boot_tty_puts
+    jal boot_puts
     nop
     mfc0        a0,     CP0_EPC
-
-        jal     boot_tty_putw
+        jal     boot_putw
     nop
     la  a0,     boot_lf_string
-    jal boot_tty_puts
+    jal boot_puts
     nop
 
         la      a0,     boot_cr_string
-    jal boot_tty_puts
+    jal boot_puts
     nop
     mfc0        a0,     CP0_CR
-        jal     boot_tty_putw
+        jal     boot_putw
     nop
     la  a0,     boot_lf_string
-    jal boot_tty_puts
+    jal boot_puts
     nop
 
         la      a0,     boot_sr_string
-    jal boot_tty_puts
+    jal boot_puts
     nop
     mfc0        a0,     CP0_SR
-        jal     boot_tty_putw
+        jal     boot_putw
     nop
     la  a0,     boot_lf_string
-    jal boot_tty_puts
+    jal boot_puts
     nop
 
         la      a0,     boot_bar_string
-    jal boot_tty_puts
+    jal boot_puts
     nop
     mfc0        a0,     CP0_BAR
-        jal     boot_tty_putw
+        jal     boot_putw
     nop
     la  a0,     boot_lf_string
-    jal boot_tty_puts
+    jal boot_puts
     nop
 
@@ -101 +112 @@
 /*******************************************/
     .align      2
-        .org    START_ORG
+    .org        START_ORG
 
 boot_start:
     /* get the procid */
     mfc0        k0,     CP0_PROCID
-        andi    k0,     k0,     0x3FF   /* no more than 1024 processors... */
+    andi        k0,     k0,     0xFFF   /* no more than 4096 processors... */
 
-        /* Only processor 0 does init */
-        bne     k0,     zero,   boot_wait_signature
+    /* Only processor 0 does init */
+    bne k0,     zero,   boot_wait_signature
     nop
 
-        /* temporary stack for procesor 0 : 16K */
-        la          sp, seg_boot_stack_base
-        addiu   sp,     sp,     0x4000  
+    /* Processor 0 get a temporary stack */
+    la      sp, seg_boot_stack_base
+    addiu       sp,     sp,     0x3000                          /* SP <= seg_boot_stack + 12K */
 
-    /* plat-form initialisation */
-        jal     boot_init
+    /* Processor 0 initialises all Page Tables */
+    jal boot_pt_init
     nop
-    j to_kinit
+ 
+    /* jump to kernel_init */
+    j           boot_to_kernel_init
     nop
 
 boot_wait_signature:
+
+    /* all other processors are waiting signature change */
     la  k0, seg_mapping_base
-    cache   0x11,   0(k0)           /* invalidate local cache copy */
-    lw  k0, 0(k0)                   /* k0 <= mapping_info[0] */
+    cache   0x11,   0(k0)                               /* invalidate local cache copy */
+    lw  k0, 0(k0)                                               /* k0 <= mapping_info[0]       */
     li  k1,     OUT_MAPPING_SIGNATURE
     bne k1, k0, boot_wait_signature
     nop
         
-to_kinit:
-    /* All processors initialize PTPR / MODE */
-    /* and jump to kernel_init code.                                     */
+    /* all other processors get a temporary stack of 256 bytes */
+    la      sp, seg_boot_stack_base
+    addiu   sp, sp, 0x3100                              
+    mfc0        k0, CP0_PROCID
+    andi    k0, k0, 0xFFF
+    sll     k0, k0, 8                                   
+    addu    sp, sp, k0          /* SP <= seg_boot_stack_base + 12K + (pid+1)*256 */
 
-    /* get the procid */
-    mfc0        s0,     CP0_PROCID
-        andi    s0,     s0,     0x3FF           /* no more than 1024 processors... TOFIX*/
+boot_to_kernel_init:
 
-    /* load a PTPR */
-        la          k1, _ptabs
+    /* all processors initialize PTPR with PTAB[0] */
+    la      k1, _ptabs
     lw      k1, 0(k1)   
     srl     k1, k1, 13
-    mtc2        k1,     CP2_PTPR                /* ptpr <= _ptabs[0]  */
+    mtc2        k1,     CP2_PTPR                /* PTPR <= _ptabs[0]  */
 
-        /* activates MMU */
-        li          k1, 0xF
-        mtc2    k1,     CP2_MODE                /* load MODE register */
+        /* all processors activate MMU */
+    li      k1, 0xF
+    mtc2    k1, CP2_MODE        /* MODE register */
 
     /* jump to kernel_init */
-        la          k0, seg_kernel_init_base
+    la      k0, seg_kernel_init_base
     j       k0
     nop
 
-
-boot_error_string:      .asciiz "\n[BOOT] Fatal Error at cycle"
+boot_error_string:      .asciiz "\n[BOOT] Fatal Error in reset.S at cycle "
+boot_pid_string:        .asciiz "    PID  = "
 boot_sr_string:         .asciiz "    SR   = "
 boot_cr_string:         .asciiz "    CR   = "

soft/giet_vm/giet_config.h

@@ -1 +1 @@
 /********************************************************************************/
-/*      File : giet_config.h                                                    */
-/*      Author : Alain Greiner                                                  */
-/*      Date : 26/03/2012                                                       */
+/*      File : giet_config.h                                                        */
+/*      Author : Alain Greiner                                                      */
+/*      Date : 26/03/2012                                                           */
 /********************************************************************************/
-/*      Define various configuration parameters for the GIET                    */
+/*      Define various configuration parameters for the GIET                                */
 /********************************************************************************/
 
@@ -12 +12 @@
 /* Debug parameters */
 
-#define BOOT_DEBUG_VIEW         0       /* display the mapping_info on system TTY */
-#define BOOT_DEBUG_PT           0       /* display the page tables after mapping */
-#define BOOT_DEBUG_CTX          0       /* display the task contexts after mapping */
-#define INIT_DEBUG_CTX          1       /* display the task contexts after mapping */
-
-#define GIET_DEBUG_SWITCH       0       /* Trace context switchs */
+#define BOOT_DEBUG_VIEW         0           /* display the mapping_info on system TTY */
+#define BOOT_DEBUG_PT           0           /* display the page tables after mapping */
+#define INIT_DEBUG                      0           /* display the task contexts after mapping */
+#define GIET_DEBUG_SWITCH       0           /* Trace context switchs */
 
 
@@ -24 +22 @@
 /* hardware parameters */
 
-#define NB_CLUSTERS             1       /* number of clusters */
-#define CLUSTER_SPAN            0       /* address increment between clusters */
-#define NB_PROCS                    4   /* number of processors per cluster */
-#define NB_TIMERS                   4   /* number of timers per cluster */
-#define NB_DMAS                     4   /* number of DMA channels per cluster */
-#define NB_TTYS                     9   /* total number of TTY terminals */
+#define NB_CLUSTERS             1           /* number of clusters */
+#define CLUSTER_SPAN            0           /* address increment between clusters */
+#define NB_PROCS                    4       /* max number of processors per cluster */
+#define NB_TIMERS                   4       /* number of timers per cluster */
+#define NB_DMAS                     1       /* total number of DMA channels */
+#define NB_TTYS                     7       /* total number of TTY terminals */
 
 /* software parameters */
 
-#define GIET_NB_TASKS_MAX       6       /* max number of tasks per processor */
-#define GIET_NB_VSPACE_MAX      4       /* max number of virtual spaces */
-#define GIET_NB_PT2_MAX         16      /* max number of level 2 page tables per vspace */
-#define GIET_TICK_VALUE         20000   /* context switch period (number of cycles) */
+#define GIET_NB_TASKS_MAX       4           /* max number of tasks per processor */
+#define GIET_NB_VSPACE_MAX      3           /* max number of virtual spaces */
+#define GIET_NB_PT2_MAX         16          /* max number of level 2 page tables per vspace */
+#define GIET_TICK_VALUE     65536   /* context switch period (number of cycles) */
 
 #endif

soft/giet_vm/libs/barrier.c

@@ -11 +11 @@
 // The barrier itself must have been allocated in a shared data segment.
 ///////////////////////////////////////////////////////////////////////////////////
+
+#include "barrier.h"
 
 ///////////////////////////////////////////////////////////////////////////////////

soft/giet_vm/libs/barrier.h

@@ -15 +15 @@
 typedef struct giet_barrier_s {
     char                name[32];       // barrier name
-    unsigned int        init;           // total number of participants
-    unsigned int        count;          // number of not yet arrived tasks
-} giet_barrier_t
+    unsigned int        init;   // total number of participants
+    unsigned int        count;  // number of not yet arrived tasks
+} giet_barrier_t;
 
 //////////////////////////////////////////////////////////////////////////////
-//  MWMR access functions
+//  access functions
 //////////////////////////////////////////////////////////////////////////////
 

soft/giet_vm/libs/mwmr_channel.c

@@ -12 +12 @@
 // The mwmr_read() and mwmr_write() functions do not require a system call.
 // The channel itself must have been allocated in a non cacheable segment,
-// if the platform does not provide hardwate cache coherence.
+// if the platform does not provide hardware cache coherence.
 //
 // ALL MWMR channels must be defined in the mapping_info data structure, 
@@ -37 +37 @@
 //  mwmr_lock_aquire()
 // This blocking function returns only when the lock has been taken.
-// If the lock is already taken a random delay is introduced before retry.
-//////////////////////////////////////////////////////////////////////////////
-void mwmr_lock_acquire(unsigned int* plock)
+// If the lock is already taken a fixed delay is introduced before retry.
+//////////////////////////////////////////////////////////////////////////////
+void mwmr_lock_acquire(unsigned int* lock_address)
 {
+    register unsigned int*      plock = lock_address;
+    register unsigned int       delay = 100;
     asm volatile (
             "mwmr_lock_try:                                     \n"
             "ll   $2,    0(%0)                          \n" /* $2 <= lock current value */
-            "bnez $2,    mwmr_lock_delay        \n" /* retry if lock already taken */
+            "bnez $2,    mwmr_lock_delay        \n" /* retry after delay if lock busy */
             "li   $3,    1                                      \n" /* $3 <= argument for sc */
             "sc   $3,    0(%0)                          \n" /* try to get lock */
             "bnez $3,    mwmr_lock_ok           \n" /* exit if atomic */
-
             "mwmr_lock_delay:                           \n"
-            "jal  rand                                  \n" /* rand() system call */
-            "nop                                                        \n"
-            "andi $4,   $2,     0xFF                    \n"     /* $4 <= random delay < 256 cycles */
-
-            "mwmr_lock_loop:                            \n"
+            "move $4,    %1                 \n" /* $4 <= delay */
+            "mwmr_lock_loop:                \n"
+            "beqz $4,    mwmr_lock_loop         \n" /* test end delay */
             "addi $4,    $4,  -1                        \n" /* $4 <= $4 - 1 */
-            "beqz $4,    mwmr_lock_loop         \n" /* test end delay */
-            "nop                                                        \n"
-            "j           mwmr_lock_try          \n" /* retry */
+            "j           mwmr_lock_try          \n" /* retry ll */
             "nop                                                        \n"
             "mwmr_lock_ok:                                      \n"
             :
-            :"r"(plock)
+            :"r"(plock), "r"(delay)
             :"$2", "$3", "$4");
 } 
@@ -117 +114 @@
         {
             mwmr->lock = 0;
-            for ( x = rand()>>8 ; x > 0 ; x-- ) asm volatile ( "nop" );
+            for ( x = giet_rand()>>8 ; x > 0 ; x-- ) asm volatile ( "nop" );
         }
         else    // write as many items as possible, release lock and retry after delay
@@ -135 +132 @@
         }
         // random delay before retry
-        for ( x = rand()>>6 ; x > 0 ; x-- ) asm volatile ( "nop" );
+        for ( x = giet_rand()>>6 ; x > 0 ; x-- ) asm volatile ( "nop" );
     }
 } 
@@ -188 +185 @@
         {
             mwmr->lock = 0;
-            for ( x = rand()>>8 ; x > 0 ; x-- ) asm volatile ( "nop" );
+            for ( x = giet_rand()>>8 ; x > 0 ; x-- ) asm volatile ( "nop" );
         }
         else    // read as many items as possible, release lock and retry after delay
@@ -206 +203 @@
         }
         // random delay before retry
-        for ( x = rand()>>6 ; x > 0 ; x-- ) asm volatile ( "nop" );
+        for ( x = giet_rand()>>6 ; x > 0 ; x-- ) asm volatile ( "nop" );
     }
 } 

soft/giet_vm/libs/spin_lock.c

@@ -28 +28 @@
 // If the lock is already taken a random delay is introduced before retry.
 ///////////////////////////////////////////////////////////////////////////////////
-void lock_acquire( giet_lock_t* lock)
+void lock_acquire( giet_lock_t* lock )
 {
-    unsigned in*t       plock = &lock->value;
+    unsigned int*       plock = &lock->value;
  
     asm volatile (
@@ -41 +41 @@
 
             "giet_lock_delay:                           \n"
-            "jal  rand                                  \n" /* rand() system call */
+            "jal  giet_rand                                 \n" /* giet_rand() system call */
             "nop                                                        \n"
-            "andi $4,   $2,     0xFF                    \n"     /* $4 <= random delay < 256 cycles */
+            "andi $4,   $2,     0xFF                    \n"     /* $4 <= delay < 256 cycles */
 
             "giet_lock_loop:                            \n"

soft/giet_vm/libs/spin_lock.h

@@ -23 +23 @@
 //////////////////////////////////////////////////////////////////////////////
 
-unsigned int lock_acquire( giet_lock_t* lock );
+void lock_acquire( giet_lock_t* lock );
 
 void lock_release( giet_lock_t* lock );

soft/giet_vm/libs/stdio.c

@@ -17 +17 @@
 #define SYSCALL_TTY_WRITE       0x02
 #define SYSCALL_TTY_READ        0x03
-#define SYSCALL_TIMER_WRITE     0x04
-#define SYSCALL_TIMER_READ      0x05
 #define SYSCALL_GCD_WRITE       0x06
 #define SYSCALL_GCD_READ        0x07
@@ -37 +35 @@
 
 //////////////////////////////////////////////////////////////////////////////////
-//      sys_call()
+// sys_call()
 // This generic C function is used to implement all system calls.
+// It writes the system call arguments in the proper registers,
+// and tells GCC what has been modified by system call execution.
 //////////////////////////////////////////////////////////////////////////////////
 static inline unsigned int sys_call( unsigned int call_no,
@@ -83 +83 @@
 
 ////////////////////////////////////////////////////////////////////////////////////
-//      procid()
+// giet_procid()
+////////////////////////////////////////////////////////////////////////////////////
 // This function returns the processor identifier.
 ////////////////////////////////////////////////////////////////////////////////////
-unsigned int procid()
+unsigned int giet_procid()
 {
     return sys_call(SYSCALL_PROCID, 
@@ -92 +93 @@
 }
 ////////////////////////////////////////////////////////////////////////////////////
-//      proctime()
+// giet_proctime()
+////////////////////////////////////////////////////////////////////////////////////
 // This function returns the local processor time (clock cycles since boot)
 ////////////////////////////////////////////////////////////////////////////////////
-unsigned int proctime()
+unsigned int giet_proctime()
 {
     return sys_call(SYSCALL_PROCTIME, 
@@ -104 +106 @@
 
 ////////////////////////////////////////////////////////////////////////////////////
-//      tty_putc()
+// giet_tty_putc()
+////////////////////////////////////////////////////////////////////////////////////
 // This function displays a single ascii character on a terminal.
 // The terminal index must be defined in the task context in the boot phase.
@@ -110 +113 @@
 // - Returns 1 if the character has been written, 0 otherwise.
 ////////////////////////////////////////////////////////////////////////////////////
-unsigned int tty_putc(char byte)
+unsigned int giet_tty_putc(char byte)
 {
     return sys_call(SYSCALL_TTY_WRITE,
@@ -118 +121 @@
 }
 ////////////////////////////////////////////////////////////////////////////////////
-//       tty_puts()
+// giet_tty_puts()
+////////////////////////////////////////////////////////////////////////////////////
 // This function displays a string on a terminal.
 // The terminal index must be defined in the task context in the boot phase.
@@ -125 +129 @@
 // - Returns the number of written characters.
 ////////////////////////////////////////////////////////////////////////////////////
-unsigned int tty_puts(char *buf)
+unsigned int giet_tty_puts(char *buf)
 {
     unsigned int length = 0;
@@ -138 +142 @@
 }
 ////////////////////////////////////////////////////////////////////////////////////
-//      tty_putw()
+// giet_tty_putw()
+////////////////////////////////////////////////////////////////////////////////////
 // This function displays the value of a 32-bit word with decimal characters.
 // The terminal index must be defined in the task context in the boot phase.
@@ -144 +149 @@
 // Returns the number of written characters (should be equal to ten).
 ////////////////////////////////////////////////////////////////////////////////////
-unsigned int tty_putw(unsigned int val)
+unsigned int giet_tty_putw(unsigned int val)
 {
     char buf[10];
@@ -160 +165 @@
 
 ////////////////////////////////////////////////////////////////////////////////////
-// tty_getc()
+// giet_tty_getc_no_irq()
+////////////////////////////////////////////////////////////////////////////////////
 // This blocking function fetches a single ascii character from a terminal.
 // The terminal index must be defined in the task context in the boot phase.
@@ -166 +172 @@
 // - Returns necessarily 0 when completed.
 ////////////////////////////////////////////////////////////////////////////////////
-unsigned int tty_getc(char *byte)
+unsigned int giet_tty_getc_no_irq(char *byte)
 {
     unsigned int ret = 0;
@@ -179 +185 @@
 }
 ////////////////////////////////////////////////////////////////////////////////////
-//       tty_getc_irq()
+// giet_tty_getc()
+////////////////////////////////////////////////////////////////////////////////////
 // This blocking function fetches a single ascii character from a terminal.
 // The terminal index must be defined in the task context in the boot phase.
@@ -185 +192 @@
 // - Returns 0 when completed.
 ////////////////////////////////////////////////////////////////////////////////////
-unsigned int tty_getc_irq(char *byte)
+unsigned int giet_tty_getc(char *byte)
 {
     unsigned int ret = 0;
@@ -198 +205 @@
 }
 ////////////////////////////////////////////////////////////////////////////////////
-//      tty_gets_irq()
+// giet_tty_gets()
+////////////////////////////////////////////////////////////////////////////////////
 // This blocking function fetches a string from a terminal to a fixed length buffer.
 // The terminal index must be defined in the task context in the boot phase.
@@ -211 +219 @@
 //   removed from the target buffer.
 ////////////////////////////////////////////////////////////////////////////////////
-unsigned int tty_gets_irq(char *buf, unsigned int bufsize)
+unsigned int giet_tty_gets( char*                       buf, 
+                            unsigned int        bufsize )
 {
     unsigned int ret;
@@ -240 +249 @@
 }
 ////////////////////////////////////////////////////////////////////////////////////
-//      tty_getw_irq()
+// giet_tty_getw()
+////////////////////////////////////////////////////////////////////////////////////
 // This blocking function fetches a string of decimal characters (most
 // significant digit first) to build a 32-bit unsigned integer.
@@ -256 +266 @@
 //   bits range, the zero value is returned.
 ////////////////////////////////////////////////////////////////////////////////////
-unsigned int tty_getw_irq(unsigned int *val)
+unsigned int giet_tty_getw(unsigned int *val)
 {
     unsigned char buf[32];
@@ -281 +291 @@
             buf[max] = byte;
             max++;
-            tty_putc(byte);
+            giet_tty_putc(byte);
         }
         else if ((byte == 0x0A) || (byte == 0x0D)) /* LF or CR character */
@@ -292 +302 @@
             {
                 max--; /* cancel the character */
-                tty_putc(0x08);
-                tty_putc(0x20);
-                tty_putc(0x08);
+                giet_tty_putc(0x08);
+                giet_tty_putc(0x20);
+                giet_tty_putc(0x08);
             }
         }
@@ -301 +311 @@
             for (i = 0; i < max; i++) /* cancel the string */
             {
-                tty_putc(0x08);
-                tty_putc(0x20);
-                tty_putc(0x08);
+                giet_tty_putc(0x08);
+                giet_tty_putc(0x20);
+                giet_tty_putc(0x08);
             }
-            tty_putc(0x30);
+            giet_tty_putc(0x30);
             *val = 0; /* return 0 value */
             return 0;
@@ -329 +339 @@
         for (i = 0; i < max; i++) /* cancel the string */
         {
-            tty_putc(0x08);
-            tty_putc(0x20);
-            tty_putc(0x08);
-        }
-        tty_putc(0x30);
+            giet_tty_putc(0x08);
+            giet_tty_putc(0x20);
+            giet_tty_putc(0x08);
+        }
+        giet_tty_putc(0x30);
         *val = 0; /* return 0 value */
     }
@@ -339 +349 @@
 }
 ////////////////////////////////////////////////////////////////////////////////////
-// tty_printf()
+// giet_tty_printf()
+////////////////////////////////////////////////////////////////////////////////////
 // This function is a simplified version of the mutek_printf() function.
 // The terminal index must be defined in the calling task context.
@@ -351 +362 @@
 // - Returns 0 if success, > 0 if error.
 ////////////////////////////////////////////////////////////////////////////////////
-unsigned int tty_printf(char *format, ...)
+unsigned int giet_tty_printf(char *format, ...)
 {
     va_list ap;
@@ -450 +461 @@
 }
 
-/////  Timer device related system calls /////
-
-#define TIMER_VALUE     0
-#define TIMER_MODE      1
-#define TIMER_PERIOD    2
-#define TIMER_RESETIRQ  3
-
-/*
- * timer_set_mode()
- *
- * This function defines the operation mode of a timer. The possible values for
- * this mode are:
- * - 0x0 : Timer not activated
- * - 0x1 : Timer activated, but no interrupt is generated
- * - 0x3 : Timer activarted and periodic interrupts generated
- *
- * - Returns 0 if success, > 0 if error.
- */
-unsigned int timer_set_mode(unsigned int val)
-{
-    return sys_call(SYSCALL_TIMER_WRITE,
-            TIMER_MODE,
-            val,
-            0, 0);
-}
-
-/*
- * timer_set_period()
- *
- * This function defines the period value of a timer to enable a periodic
- * interrupt.
- * - Returns 0 if success, > 0 if error.
- */
-unsigned int timer_set_period(unsigned int val)
-{
-    return sys_call(SYSCALL_TIMER_WRITE,
-            TIMER_PERIOD,
-            val,
-            0, 0);
-}
-
-/*
- * timer_reset_irq()
- *
- * This function resets the interrupt signal issued by a timer.
- * - Returns 0 if success, > 0 if error.
- */
-unsigned int timer_reset_irq()
-{
-    return sys_call(SYSCALL_TIMER_WRITE,
-            TIMER_RESETIRQ,
-            0, 0, 0);
-}
-
-/*
- * timer_get_time()
- *
- * This function returns the current timing value of a timer.
- * - Returns 0 if success, > 0 if error.
- */
-unsigned int timer_get_time(unsigned int *time)
-{
-    return sys_call(SYSCALL_TIMER_READ,
-            TIMER_VALUE,
-            (unsigned int)time,
-            0, 0);
-}
-
-/////  GCD (Greatest Common Divider) device related system calls
+/////  GCD (Greatest Common Divider) related system calls
 
 #define GCD_OPA     0
@@ -526 +469 @@
 
 //////////////////////////////////////////////////////////////////////////////////
-//      gcd_set_opa()
+// giet_gcd_set_opa()
+//////////////////////////////////////////////////////////////////////////////////
 // This function sets the operand A in the GCD coprocessor.
 // - Returns 0 if success, > 0 if error.
 //////////////////////////////////////////////////////////////////////////////////
-unsigned int gcd_set_opa(unsigned int val)
+unsigned int giet_gcd_set_opa(unsigned int val)
 {
     return sys_call(SYSCALL_GCD_WRITE,
@@ -538 +482 @@
 }
 //////////////////////////////////////////////////////////////////////////////////
-//      gcd_set_opb()
+//      giet_gcd_set_opb()
+//////////////////////////////////////////////////////////////////////////////////
 // This function sets operand B in the GCD coprocessor.
 // - Returns 0 if success, > 0 if error.
 //////////////////////////////////////////////////////////////////////////////////
-unsigned int gcd_set_opb(unsigned int val)
+unsigned int giet_gcd_set_opb(unsigned int val)
 {
     return sys_call(SYSCALL_GCD_WRITE,
@@ -550 +495 @@
 }
 //////////////////////////////////////////////////////////////////////////////////
-//      gcd_start()
+//      giet_gcd_start()
+//////////////////////////////////////////////////////////////////////////////////
 // This function starts the computation in the GCD coprocessor.
 // - Returns 0 if success, > 0 if error.
 //////////////////////////////////////////////////////////////////////////////////
-unsigned int gcd_start()
+unsigned int giet_gcd_start()
 {
     return sys_call(SYSCALL_GCD_WRITE,
@@ -561 +507 @@
 }
 //////////////////////////////////////////////////////////////////////////////////
-//      gcd_get_status()
+//      giet_gcd_get_status()
+//////////////////////////////////////////////////////////////////////////////////
 // This function gets the status fromn the GCD coprocessor.
 // - The value is 0 when the coprocessor is idle (computation completed).
 //////////////////////////////////////////////////////////////////////////////////
-unsigned int gcd_get_status(unsigned int *val)
+unsigned int giet_gcd_get_status(unsigned int *val)
 {
     return sys_call(SYSCALL_GCD_READ,
@@ -573 +520 @@
 }
 //////////////////////////////////////////////////////////////////////////////////
-//      gcd_get_result()
+//      giet_gcd_get_result()
+//////////////////////////////////////////////////////////////////////////////////
 // This function gets the result of the computation from the GCD coprocessor.
 //////////////////////////////////////////////////////////////////////////////////
-unsigned int gcd_get_result(unsigned int *val)
+unsigned int giet_gcd_get_result(unsigned int *val)
 {
     return sys_call(SYSCALL_GCD_READ,
@@ -587 +535 @@
 
 //////////////////////////////////////////////////////////////////////////////////
-//      ioc_write()
+//      giet_ioc_write()
+//////////////////////////////////////////////////////////////////////////////////
 // Transfer data from a memory buffer to a file on the block_device.
 //     lba    : Logical Block Address (first block index)
@@ -594 +543 @@
 // - Returns 0 if success, > 0 if error (e.g. memory buffer not in user space).
 //////////////////////////////////////////////////////////////////////////////////
-unsigned int ioc_write(unsigned int lba, void *buffer, unsigned int count)
+unsigned int giet_ioc_write( unsigned int       lba, 
+                             void*                      buffer, 
+                             unsigned int       count)
 {
     return sys_call(SYSCALL_IOC_WRITE,
@@ -603 +554 @@
 }
 //////////////////////////////////////////////////////////////////////////////////
-//      ioc_read()
+// giet_ioc_read()
+//////////////////////////////////////////////////////////////////////////////////
 // Transfer data from a file on the block_device to a memory buffer.
 //     lba    : Logical Block Address (first block index)
@@ -610 +562 @@
 // - Returns 0 if success, > 0 if error (e.g. memory buffer not in user space).
 //////////////////////////////////////////////////////////////////////////////////
-unsigned int ioc_read(unsigned int lba, void *buffer, unsigned int count)
+unsigned int giet_ioc_read( unsigned int                lba, 
+                            void*                               buffer, 
+                            unsigned int                count )
 {
     return sys_call(SYSCALL_IOC_READ,
@@ -619 +573 @@
 }
 //////////////////////////////////////////////////////////////////////////////////
-//      ioc_completed()
+// giet_ioc_completed()
+//////////////////////////////////////////////////////////////////////////////////
 // This blocking function returns 0 when the I/O transfer is
 // successfully completed, and returns 1 if an address error has been detected.
 //////////////////////////////////////////////////////////////////////////////////
-unsigned int ioc_completed()
+unsigned int giet_ioc_completed()
 {
     return sys_call(SYSCALL_IOC_COMPLETED,
@@ -632 +587 @@
 
 //////////////////////////////////////////////////////////////////////////////////
-//      fb_sync_write()
+// giet_fb_sync_write()
+//////////////////////////////////////////////////////////////////////////////////
 // This blocking function use a memory copy strategy to transfer data from a
 // user buffer to the frame buffer device in kernel space.
@@ -640 +596 @@
 // - Returns 0 if success, > 0 if error (e.g. memory buffer not in user space).
 //////////////////////////////////////////////////////////////////////////////////
-unsigned int fb_sync_write(unsigned int offset, void *buffer, unsigned int length)
+unsigned int giet_fb_sync_write( unsigned int   offset, 
+                                 void*                  buffer, 
+                                 unsigned int   length )
 {
     return sys_call(SYSCALL_FB_SYNC_WRITE,
@@ -649 +607 @@
 }
 //////////////////////////////////////////////////////////////////////////////////
-//      fb_sync_read()
+// giet_fb_sync_read()
+//////////////////////////////////////////////////////////////////////////////////
 // This blocking function use a memory copy strategy to transfer data from the
 // frame buffer device in kernel space to an user buffer.
@@ -657 +616 @@
 // - Returns 0 if success, > 0 if error (e.g. memory buffer not in user space).
 //////////////////////////////////////////////////////////////////////////////////
-unsigned int fb_sync_read(unsigned int offset, void *buffer, unsigned int length)
+unsigned int giet_fb_sync_read( unsigned int    offset, 
+                                void*                   buffer, 
+                                unsigned int    length )
 {
     return sys_call(SYSCALL_FB_SYNC_READ,
@@ -666 +627 @@
 }
 //////////////////////////////////////////////////////////////////////////////////
-//      fb_write()
+// giet_fb_write()
+//////////////////////////////////////////////////////////////////////////////////
 // This non-blocking function use the DMA coprocessor to transfer data from a
 // user buffer to the frame buffer device in kernel space.
@@ -676 +638 @@
 // - Returns 0 if success, > 0 if error (e.g. memory buffer not in user space).
 //////////////////////////////////////////////////////////////////////////////////
-unsigned int fb_write(unsigned int offset, void *buffer, unsigned int length)
+unsigned int giet_fb_write( unsigned int        offset, 
+                            void*                       buffer, 
+                            unsigned int        length )
 {
     return sys_call(SYSCALL_FB_WRITE,
@@ -685 +649 @@
 }
 //////////////////////////////////////////////////////////////////////////////////
-//       fb_read()
+// giet_fb_read()
+//////////////////////////////////////////////////////////////////////////////////
 // This non-blocking function use the DMA coprocessor to transfer data from the
 // frame buffer device in kernel space to an user buffer.
@@ -695 +660 @@
 // - Returns 0 if success, > 0 if error (e.g. memory buffer not in user space).
 //////////////////////////////////////////////////////////////////////////////////
-unsigned int fb_read( unsigned int offset, 
-                      void *buffer, 
-                      unsigned int length )
+unsigned int giet_fb_read( unsigned int         offset, 
+                           void*                        buffer, 
+                           unsigned int         length )
 {
     return sys_call(SYSCALL_FB_READ,
@@ -706 +671 @@
 }
 //////////////////////////////////////////////////////////////////////////////////
-//      fb_completed()
+// giet_fb_completed()
+//////////////////////////////////////////////////////////////////////////////////
 // This blocking function returns when the transfer is completed.
 // - Returns 0 if success, > 0 if error.
 //////////////////////////////////////////////////////////////////////////////////
-unsigned int fb_completed()
+unsigned int giet_fb_completed()
 {
     return sys_call(SYSCALL_FB_COMPLETED,
@@ -716 +682 @@
 }
 
-///// Platform or mapping related system calls /////
-
-//////////////////////////////////////////////////////////////////////////////////
-//      mwmr_base()
-//      TODO!
-// This function returns in argument buffer the virtual base address 
-// of a MWMR communication channel, identified by the two arguments
-// vspace_name and channel_name.
-// As the GIET does not support dynamic allocation, the MWMR channel
-// must be declared in the mapping_info data structure to be initialised
-// in the boot phase.
-// - Returns the address if success,  0 if error ( channel not defined )
-//////////////////////////////////////////////////////////////////////////////////
-unsigned int vobj_get_vbase( char* vspace_name, char* vobj_name,
-                        unsigned int vobj_type, unsigned int* vobj_buffer)
+///// Miscellaneous related system calls /////
+
+//////////////////////////////////////////////////////////////////////////////////
+// giet_vobj_get_vbase()
+//////////////////////////////////////////////////////////////////////////////////
+// This function writes in argument (vobj_vaddr) the virtual base address 
+// of a vobj (defined in the mapping_info data structure), identified by 
+// the two arguments (vspace_name and vobj_name).
+// The (vobj_type) argument is redundant, and used for coherence checking.
+// - Returns the address if success,  0 if error ( not defined or wrong type )
+//////////////////////////////////////////////////////////////////////////////////
+unsigned int giet_vobj_get_vbase( char*                 vspace_name, 
+                                  char*                 vobj_name,
+                                  unsigned int  vobj_type, 
+                                  unsigned int* vobj_vaddr )
 {
     return sys_call(SYSCALL_VOBJ_GET_VBASE, 
@@ -736 +702 @@
                     (unsigned int)vobj_name,
                     (unsigned int)vobj_type,
-                    (unsigned int)vobj_buffer);
-}
-////////////////////////////////////////////////////////////////////////////////////
-//      proc_number()
+                    (unsigned int)vobj_vaddr);
+}
+
+////////////////////////////////////////////////////////////////////////////////////
+// giet_proc_number()
+////////////////////////////////////////////////////////////////////////////////////
 // This function returns in the buffer argument the number of processors 
 // in the cluster specified by the cluster_id argument.
 // - Returns 0 if success, > 0 if error ( cluster index too large )
 ////////////////////////////////////////////////////////////////////////////////////
-unsigned int proc_number( unsigned int cluster_id,
-                          unsigned int* buffer )
+unsigned int giet_proc_number( unsigned int             cluster_id,
+                               unsigned int*    buffer )
 {
     return sys_call(SYSCALL_PROC_NUMBER, 
@@ -756 +724 @@
 
 //////////////////////////////////////////////////////////////////////////////////
-// exit()
+// giet_task_exit()
+//////////////////////////////////////////////////////////////////////////////////
 // This function stops execution of the calling task with a TTY message, 
 // and enter an infinite loop.
 // The task is blocked, but it still consume processor cycles ...
 //////////////////////////////////////////////////////////////////////////////////
-void exit()
-{
-    unsigned int proc_index = procid();
+void giet_exit()
+{
     sys_call(SYSCALL_EXIT, 
-             proc_index, 
-             0, 0, 0);
+             0, 0, 0, 0);
 }
 ///////////////////////////////////////////////////////////////////////////////////
-//      rand()
+// giet_rand()
 // This function returns a pseudo-random value derived from the processor cycle
 // count. This value is comprised between 0 & 65535.
 ///////////////////////////////////////////////////////////////////////////////////
-unsigned int rand()
+unsigned int giet_rand()
 {
     unsigned int x = sys_call(SYSCALL_PROCTIME, 
@@ -783 +750 @@
 }
 //////////////////////////////////////////////////////////////////////////////////
-//      ctx_switch()
+// giet_ctx_switch()
 // The user task calling this function is descheduled and
 // the processor is allocated to another task.
 //////////////////////////////////////////////////////////////////////////////////
-unsigned int ctx_switch()
+unsigned int giet_ctx_switch()
 {
     return sys_call(SYSCALL_CTX_SWITCH, 

soft/giet_vm/libs/stdio.h

@@ -12 +12 @@
 
 /* MIPS32 related functions */
-unsigned int procid();
-unsigned int proctime();
-unsigned int procnumber();
+unsigned int giet_procid();
+unsigned int giet_proctime();
 
 /* TTY device related functions */
-unsigned int tty_putc(char byte);
-unsigned int tty_puts(char *buf);
-unsigned int tty_putw(unsigned int val);
-unsigned int tty_getc(char *byte);
-unsigned int tty_getc_irq(char *byte);
-unsigned int tty_gets_irq(char *buf, unsigned int bufsize);
-unsigned int tty_getw_irq(unsigned int *val);
-unsigned int tty_printf(char *format,...);
-
-/* Timer device related functions */
-unsigned int timer_set_mode(unsigned int mode);
-unsigned int timer_set_period(unsigned int period);
-unsigned int timer_reset_irq();
-unsigned int timer_get_time(unsigned int *time);
+unsigned int giet_tty_putc(char byte);
+unsigned int giet_tty_puts(char *buf);
+unsigned int giet_tty_putw(unsigned int val);
+unsigned int giet_tty_getc_no_irq(char *byte);
+unsigned int giet_tty_getc(char *byte);
+unsigned int giet_tty_gets(char *buf, unsigned int bufsize);
+unsigned int giet_tty_getw(unsigned int *val);
+unsigned int giet_tty_printf(char *format,...);
 
 /* GCD coprocessor related functions */
-unsigned int gcd_set_opa(unsigned int val);
-unsigned int gcd_set_opb(unsigned int val);
-unsigned int gcd_start();
-unsigned int gcd_get_result(unsigned int *val);
-unsigned int gcd_get_status(unsigned int *val);
+unsigned int giet_gcd_set_opa(unsigned int val);
+unsigned int giet_gcd_set_opb(unsigned int val);
+unsigned int giet_gcd_start();
+unsigned int giet_gcd_get_result(unsigned int *val);
+unsigned int giet_gcd_get_status(unsigned int *val);
 
 /* Block device related functions */
-unsigned int ioc_read(unsigned int lba, void *buffer, unsigned int count);
-unsigned int ioc_write(unsigned int lba, void *buffer, unsigned int count);
-unsigned int ioc_completed();
+unsigned int giet_ioc_read( unsigned int        lba, 
+                            void*                       buffer, 
+                            unsigned int        count);
+unsigned int giet_ioc_write(unsigned int        lba, 
+                            void*                       buffer, 
+                            unsigned int        count);
+unsigned int giet_ioc_completed();
 
 /* Frame buffer device related functions */
-unsigned int fb_sync_read(unsigned int offset, void *buffer, unsigned int length);
-unsigned int fb_sync_write(unsigned int offset, void *buffer, unsigned int length);
-unsigned int fb_read(unsigned int offset, void *buffer, unsigned int length);
-unsigned int fb_write(unsigned int offset, void *buffer, unsigned int length);
-unsigned int fb_completed();
-
-/* Software barrier related functions */
-unsigned int barrier_init(unsigned int index, unsigned int count);
-unsigned int barrier_wait(unsigned int index);
+unsigned int giet_fb_sync_read( unsigned int    offset, 
+                                void*                   buffer, 
+                                unsigned int    length );
+unsigned int giet_fb_sync_write(unsigned int    offset, 
+                                void*                   buffer, 
+                                unsigned int    length );
+unsigned int giet_fb_read(      unsigned int    offset, 
+                                void*                   buffer, 
+                                unsigned int    length );
+unsigned int giet_fb_write(     unsigned int    offset, 
+                                void*                   buffer, 
+                                unsigned int    length );
+unsigned int giet_fb_completed();
 
 /* Misc */
-void exit();
-unsigned int rand();
+unsigned int giet_vobj_get_vbase( char* vspace_name, 
+                                  char* vobj_name,
+                                  unsigned int vobj_type, 
+                                  unsigned int* vobj_vaddr );
+void         giet_exit();
+unsigned int giet_rand();
 unsigned int ctx_switch();
-unsigned int vobj_get_vbase( char* vspace_name, char* vobj_name,
-                        unsigned int vobj_type, unsigned int* vobj_buffer);
+unsigned int giet_procnumber();
 
 /*
  * memcpy function
- *
- * This function is likely not to be called directly but GCC can automatically
- * issue call to it during compilation so we must provide it. 'static inline'
- * so the function's code is directly included when used.
- *
+ * This function is required because it can be gnerated by GCC 
+ * during compilation so we must provide it.
  * Code taken from MutekH.
  */

soft/giet_vm/map.xml

@@ -5 +5 @@
                 clusters = "1"
                 psegs    = "9"
-                ttys     = "9"
-                vspaces  = "4" 
+                ttys     = "7"
+                fbs      = "0"
+                vspaces  = "3" 
                 globals  = "13" >
 
         <clusterset>
-                <cluster procs  = "4"
-                         timers = "4"
-                         dmas   = "4" />
+                <cluster index  = "0"
+                         procs  = "4" />
         </clusterset>
 
@@ -59 +59 @@
                         psegname  = "PSEG_ROM" 
                         ident     = "1" >
-                                        <vobj   name    = "seg_boot"
-                                                        type    = "ELF"
-                                                        length  = "0x00008000" 
-                                                        binpath = "build/boot.elf"
-                                                        />
+                                            <vobj   name        = "seg_boot"
+                                                        type    = "ELF"
+                                                        length  = "0x00008000" 
+                                                        binpath = "build/boot.elf" />
                                 </vseg>
 
@@ -71 +70 @@
                         psegname  = "PSEG_ROM"
                         ident     = "1" >
-                                        <vobj   name    = "boot_stack"
-                                                        type    = "BUFFER"
-                                                        length  = "0x00004000" />
+                                        <vobj   name    = "boot_stack"
+                                                        type    = "BUFFER"
+                                                        length  = "0x00004000" />
                                 </vseg>
 
@@ -81 +80 @@
                         psegname  = "PSEG_ROM"
                         ident     = "1" >
-                                        <vobj   name    = "seg_mapping"
-                                                        type    = "ELF"
-                                                        length  = "0x00004000" 
-                                                        binpath = "map.bin"
-                                                        />
+                                        <vobj   name    = "seg_mapping"
+                                                        type    = "ELF"
+                                                        length  = "0x00004000" 
+                                                        binpath = "map.bin" />
                                 </vseg>
 
@@ -105 +103 @@
                         psegname  = "PSEG_RAK"
                         ident     = "1" >
-                                        <vobj   name    = "seg_kernel_data"
-                                                        type    = "ELF"
-                                                        length  = "0x00010000" 
-                                                        binpath = "build/sys.elf"
-                                                        />
+                                        <vobj   name    = "seg_kernel_data"
+                                                        type    = "ELF"
+                                                        length  = "0x00010000" 
+                                                        binpath = "build/sys.elf" />
                                 </vseg>
 
@@ -117 +114 @@
                         psegname  = "PSEG_RAK"
                         ident     = "1" >
-                                        <vobj   name    = "seg_kernel_uncdata"
-                                                        type    = "ELF"
-                                                        length  = "0x00010000" 
-                                                        binpath = "build/sys.elf"
-                                                        />
+                                            <vobj   name        = "seg_kernel_uncdata"
+                                                        type    = "ELF"
+                                                            length  = "0x00010000" 
+                                                        binpath = "build/sys.elf" />
                                 </vseg>
 
@@ -129 +125 @@
                         psegname  = "PSEG_RAK"
                         ident     = "1" >
-                                        <vobj   name    = "seg_kernel_init"
-                                                        type    = "ELF"
-                                                        length  = "0x00010000" 
-                                                        binpath = "build/sys.elf"
-                                                        />
+                                        <vobj   name    = "seg_kernel_init"
+                                                        type    = "ELF"
+                                                        length  = "0x00010000" 
+                                                        binpath = "build/sys.elf" />
                                 </vseg>
 
@@ -142 +137 @@
                         psegname  = "PSEG_TTY"
                         ident     = "1" >
-                                        <vobj   name    = "tty"
-                                                        type    = "PERI"
-                                                        length  = "0x00000100" />
+                                        <vobj   name    = "tty"
+                                                        type    = "PERI"
+                                                        length  = "0x00000100" />
                                 </vseg>
 
@@ -152 +147 @@
                         psegname  = "PSEG_TIM"
                         ident     = "1" >
-                                        <vobj   name    = "timer"
-                                                        type    = "PERI"
-                                                        length  = "0x00000080" />
+                                        <vobj   name    = "timer"
+                                                        type    = "PERI"
+                                                        length  = "0x00000080" />
                                 </vseg>
 
@@ -162 +157 @@
                         psegname  = "PSEG_IOC"
                         ident     = "1" >
-                                        <vobj   name    = "ioc"
-                                                        type    = "PERI"
-                                                        length  = "0x00000020" />
+                                        <vobj   name    = "ioc"
+                                                        type    = "PERI"
+                                                        length  = "0x00000020" />
                                 </vseg>
 
@@ -172 +167 @@
                         psegname  = "PSEG_DMA"
                         ident     = "1" >
-                                        <vobj   name    = "dma"
-                                                        type    = "PERI"
-                                                        length  = "0x00000100" />
+                                        <vobj   name    = "dma"
+                                                        type    = "PERI"
+                                                        length  = "0x00000100" />
                                 </vseg>
 
@@ -182 +177 @@
                         psegname  = "PSEG_FBF"
                         ident     = "1" >
-                                        <vobj   name    = "fb"
-                                                        type    = "PERI"
-                                                        length  = "0x00004000" />
+                                        <vobj   name    = "fb"
+                                                        type    = "PERI"
+                                                        length  = "0x00004000" />
                                 </vseg>
 
@@ -192 +187 @@
                         psegname  = "PSEG_ICU"
                         ident     = "1" >
-                                        <vobj   name    = "icu"
-                                                        type    = "PERI"
-                                                        length  = "0x00000100" />
+                                        <vobj   name    = "icu"
+                                                        type    = "PERI"
+                                                        length  = "0x00000100" />
                                 </vseg>
           </globalset> 
 
           <vspaceset>
-                <vspace name    = "router"
-                        funcs   = "seg_data_router"
-                        ttys    = "4" >
+                <vspace name      = "router"
+                        startname = "seg_data_router" >
 
                         <vseg   name      = "seg_data_router"
                                 vbase     = "0x00800000" 
                                 mode      = "__WU"
-                                psegname  = "PSEG_RAU"
-                                ident     = "0" >
-                                                        <vobj   name    = "seg_data_router"
-                                                                        type    = "ELF"
-                                                                        length  = "0x00010000" 
-                                    binpath = "build/router.elf"
-                                                                        />
+                                psegname  = "PSEG_RAU" >
+                                                            <vobj   name        = "seg_data_router"
+                                                                        type    = "ELF"
+                                                                        length  = "0x00010000" 
+                                        binpath = "build/router.elf" />
                                                 </vseg>
 
@@ -218 +210 @@
                                 vbase     = "0x00400000" 
                                 mode      = "CX_U"
-                                psegname  = "PSEG_RAU"
-                                ident     = "0" >
-                                                        <vobj   name    = "seg_code_router"
-                                                                        type    = "ELF"
-                                                                        length  = "0x00010000" 
-                                    binpath = "build/router.elf"
-                                                                        />
+                                psegname  = "PSEG_RAU" >
+                                                            <vobj   name        = "seg_code_router"
+                                                                        type    = "ELF"
+                                                                            length  = "0x00010000" 
+                                        binpath = "build/router.elf" />
                                                 </vseg>
 
@@ -230 +220 @@
                                 vbase     = "0x00300000" 
                                 mode      = "C___"
-                                psegname  = "PSEG_RAU"
-                                ident     = "0" >
-                            <vobj   name        = "ptab"
-                                    type        = "PTAB"
-                                    length  = "0x00010000" 
-                                    align   = "13"
-                                    />
+                                psegname  = "PSEG_RAU" >
+                                <vobj   name    = "ptab_router"
+                                        type    = "PTAB"
+                                        length  = "0x00010000" 
+                                        align   = "13" />
                         </vseg>
 
@@ -243 +231 @@
                                 mode      = "C_WU"
                                 psegname  = "PSEG_RAU" >
-                                                        <vobj   name    = "stack_producer"
-                                                                        type    = "BUFFER"
-                                                                        length  = "0x00010000" />
+                                                            <vobj   name        = "stack_producer"
+                                                                        type    = "BUFFER"
+                                                                            length  = "0x00010000" />
                                                 </vseg>
 
@@ -252 +240 @@
                                 mode      = "C_WU"
                                 psegname  = "PSEG_RAU" >
-                                                        <vobj   name    = "stack_consumer"
-                                                                        type    = "BUFFER"
-                                                                        length  = "0x00010000" />
+                                                            <vobj   name        = "stack_consumer"
+                                                                        type    = "BUFFER"
+                                                                            length  = "0x00010000" />
                                                 </vseg>
 
@@ -261 +249 @@
                                 mode      = "C_WU"
                                 psegname  = "PSEG_RAU" >
-                                                        <vobj   name    = "stack_router_A"
-                                                                        type    = "BUFFER"
-                                                                        length  = "0x00010000" />
+                                                            <vobj   name        = "stack_router_A"
+                                                                        type    = "BUFFER"
+                                                                            length  = "0x00010000" />
                                                 </vseg>
 
@@ -270 +258 @@
                                 mode      = "C_WU"
                                 psegname  = "PSEG_RAU" >
-                                                        <vobj   name    = "stack_router_B"
-                                                                        type    = "BUFFER"
-                                                                        length  = "0x00010000" />
-                                                </vseg>
-
-                        <vseg   name      = "seg_mwmr_in"
+                                                            <vobj   name        = "stack_router_B"
+                                                                        type    = "BUFFER"
+                                                                            length  = "0x00010000" />
+                                                </vseg>
+
+                        <vseg   name      = "seg_mwmr_channels"
                                 vbase     = "0x00050000"
                                 mode      = "__WU"
                                 psegname  = "PSEG_RAU" >
-                                                        <vobj   name    = "mwmr_in"
-                                                                        type    = "MWMR"
-                                                                        length  = "0x00000020"/>
-                                                </vseg>
-
-                        <vseg   name      = "seg_mwmr_out"
-                                vbase     = "0x00060000"
-                                mode      = "__WU"
-                                psegname  = "PSEG_RAU">
-                                                        <vobj   name    = "mwmr_out"
-                                                                        type    = "MWMR"
-                                                                        length  = "0x00000020"/>
+                                                            <vobj   name        = "mwmr_in"
+                                                                        type    = "MWMR"
+                                                                            length  = "0x00000020" />
+                                                            <vobj   name        = "mwmr_out"
+                                                                        type    = "MWMR"
+                                                                            length  = "0x00000020" />
                                                 </vseg>
 
@@ -298 +280 @@
                                 stackname = "stack_producer"
                                 startid   = "0"
-                                ttylocid  = "0" />
+                                usetty    = "1" />
+
                         <task   name      = "consumer"
                                 clusterid = "0"
@@ -304 +287 @@
                                 stackname = "stack_consumer"
                                 startid   = "1" 
-                                ttylocid  = "1" />
+                                usetty    = "1" />
+
                         <task   name      = "router_A"
                                 clusterid = "0"
@@ -310 +294 @@
                                 stackname = "stack_router_A"
                                 startid   = "2"
-                                ttylocid  = "2" />
+                                usetty    = "1" />
+
                         <task   name      = "router_B"
                                 clusterid = "0"
@@ -316 +301 @@
                                 stackname = "stack_router_B"
                                 startid   = "2"
-                                ttylocid  = "3" />
+                                usetty    = "1" />
                 </vspace>
 
-                <vspace name    = "hello" 
-                        funcs   = "seg_data_hello"
-                        ttys    = "1" >
+                <vspace name      = "hello" 
+                        startname = "seg_data_hello" >
 
                         <vseg   name      = "seg_data_hello"
                                 vbase     = "0x00800000" 
                                 mode      = "C_WU"
-                                psegname  = "PSEG_RAU"
-                                ident     = "0" >
-                                                        <vobj   name    = "seg_data_hello"
-                                                                        type    = "ELF"
-                                                                        length    = "0x00010000" 
-                                    binpath = "build/hello.elf"/>
+                                psegname  = "PSEG_RAU" >
+                                                            <vobj   name        = "seg_data_hello"
+                                                                        type    = "ELF"
+                                                                            length    = "0x00010000" 
+                                        binpath = "build/hello.elf" />
                                                 </vseg>
 
@@ -337 +320 @@
                                 vbase     = "0x00400000" 
                                 mode      = "CX_U"
-                                psegname  = "PSEG_RAU"
-                                ident     = "0" >
-                                                        <vobj   name    = "seg_code_hello"
-                                                                        type    = "ELF"
-                                                                        length    = "0x00010000" 
-                                    binpath = "build/hello.elf"/>
+                                psegname  = "PSEG_RAU" >
+                                                            <vobj   name        = "seg_code_hello"
+                                                                        type    = "ELF"
+                                                                            length    = "0x00010000" 
+                                        binpath = "build/hello.elf" />
                                                 </vseg>
 
@@ -348 +330 @@
                                 vbase     = "0x00300000" 
                                 mode      = "C___"
-                                psegname  = "PSEG_RAU"
-                                ident     = "0" >
-                            <vobj   name        = "ptab"
-                                    type        = "PTAB"
-                                    length  = "0x00010000" 
-                                    align   = "13"
-                                    />
+                                psegname  = "PSEG_RAU" >
+                                <vobj   name    = "ptab"
+                                        type    = "PTAB"
+                                        length  = "0x00010000" 
+                                        align   = "13" />
                         </vseg>
 
@@ -361 +341 @@
                                 mode      = "C_WU"
                                 psegname  = "PSEG_RAU" >
-                                                        <vobj   name    = "stack"
-                                                                        type    = "BUFFER"
-                                                                        length  = "0x00010000" />
+                                                            <vobj   name        = "stack"
+                                                                        type    = "BUFFER"
+                                                                            length  = "0x00010000" />
                                                 </vseg>
 
@@ -372 +352 @@
                                 stackname = "stack"
                                 startid   = "0" 
-                                ttylocid  = "0" />
+                                usetty    = "1" />
                 </vspace>
 
-                <vspace name    = "pgcd" 
-                        funcs   = "seg_data_pgcd"
-                        ttys    = "1" >
+                <vspace name      = "pgcd" 
+                        startname = "seg_data_pgcd" >
 
                         <vseg   name      = "seg_data_pgcd"
                                 vbase     = "0x00800000" 
                                 mode      = "C_WU"
-                                psegname  = "PSEG_RAU"
-                                ident     = "0" >
-                                                        <vobj   name    = "seg_data_pgcd"
-                                                                        type    = "ELF"
-                                                                        length  = "0x00010000" 
-                                    binpath = "build/pgcd.elf" />
+                                psegname  = "PSEG_RAU" >
+                                                            <vobj   name        = "seg_data_pgcd"
+                                                                        type    = "ELF"
+                                                                            length  = "0x00010000" 
+                                        binpath = "build/pgcd.elf" />
                                                 </vseg>
 
@@ -393 +371 @@
                                 vbase     = "0x00300000" 
                                 mode      = "C___"
-                                psegname  = "PSEG_RAU"
-                                ident     = "0" >
-                            <vobj   name        = "ptab"
-                                    type        = "PTAB"
-                                    length  = "0x00010000" 
-                                    align   = "13"
-                                    />
+                                psegname  = "PSEG_RAU" >
+                                <vobj   name    = "ptab"
+                                        type    = "PTAB"
+                                        length  = "0x00010000" 
+                                        align   = "13" />
                         </vseg>
 
@@ -405 +381 @@
                                 vbase     = "0x00400000" 
                                 mode      = "CX_U"
-                                psegname  = "PSEG_RAU"
-                                ident     = "0" >
-                                                        <vobj   name    = "seg_code_pgcd"
-                                                                        type    = "ELF"
-                                                                        length  = "0x00010000" 
-                                    binpath = "build/pgcd.elf" />
+                                psegname  = "PSEG_RAU" >
+                                                            <vobj   name        = "seg_code_pgcd"
+                                                                        type    = "ELF"
+                                                                            length  = "0x00010000" 
+                                        binpath = "build/pgcd.elf" />
                                                 </vseg>
 
@@ -417 +392 @@
                                 mode      = "C_WU"
                                 psegname  = "PSEG_RAU" >
-                                                        <vobj   name    = "stack"
-                                                                        type    = "BUFFER"
-                                                                        length  = "0x00010000" />
-                                                </vseg>
-
+                                                            <vobj   name        = "stack"
+                                                                        type    = "BUFFER"
+                                                                            length  = "0x00010000" />
+                                                </vseg>
 
                         <task   name      = "main_pgcd"
@@ -428 +402 @@
                                 stackname = "stack"
                                 startid   = "0" 
-                                ttylocid  = "0" />
-                </vspace>
-
-                <vspace name    = "numsplit"
-                        funcs   = "seg_data_numsplit"
-                        ttys    = "2" >
-
-                        <vseg   name      = "seg_data_numsplit"
-                                vbase     = "0x00800000" 
-                                mode      = "__WU"
-                                psegname  = "PSEG_RAU"
-                                ident     = "0" >
-                                                        <vobj   name    = "seg_data_numsplit"
-                                                                        type    = "ELF"
-                                                                        length  = "0x00010000" 
-                                    binpath = "build/numsplit.elf"
-                                                                        />
-                                                </vseg>
-
-                        <vseg   name      = "seg_code_numsplit"
-                                vbase     = "0x00400000" 
-                                mode      = "CX_U"
-                                psegname  = "PSEG_RAU"
-                                ident     = "0" >
-                                                        <vobj   name    = "seg_code_numsplit"
-                                                                        type    = "ELF"
-                                                                        length  = "0x00010000" 
-                                    binpath = "build/numsplit.elf"
-                                                                        />
-                                                </vseg>
-
-                        <vseg   name      = "seg_ptab"
-                                vbase     = "0x00300000" 
-                                mode      = "C___"
-                                psegname  = "PSEG_RAU"
-                                ident     = "0" >
-                            <vobj   name        = "ptab"
-                                    type        = "PTAB"
-                                    length  = "0x00010000" 
-                                    align   = "13"
-                                    />
-                        </vseg>
-
-                        <vseg   name      = "seg_stack_producer"
-                                                vbase     = "0x00010000" 
-                                mode      = "C_WU"
-                                psegname  = "PSEG_RAU" >
-                                                        <vobj   name    = "stack_producer"
-                                                                        type    = "BUFFER"
-                                                                        length  = "0x00010000" />
-                                                </vseg>
-
-                        <vseg   name      = "seg_stack_consumer"
-                                                vbase     = "0x00020000" 
-                                mode      = "C_WU"
-                                psegname  = "PSEG_RAU" >
-                                                        <vobj   name    = "stack_consumer"
-                                                                        type    = "BUFFER"
-                                                                        length  = "0x00010000" />
-                                                </vseg>
-
-                        <vseg   name      = "seg_mwmr"
-                                vbase     = "0x00050000"
-                                mode      = "__WU"
-                                psegname  = "PSEG_RAU">
-                                                        <vobj   name    = "mwmr"
-                                                                        type    = "MWMR"
-                                                                        length  = "0x00000080"/>
-                                                </vseg>
-
-                        <task   name      = "producer"
-                                clusterid = "0"
-                                proclocid = "0"
-                                stackname = "stack_producer"
-                                startid   = "0"
-                                ttylocid  = "1" />
-
-                        <task   name      = "consumer"
-                                clusterid = "0"
-                                proclocid = "1"
-                                stackname = "stack_consumer"
-                                startid   = "1" 
-                                ttylocid  = "0" />
+                                usetty    = "1" />
                 </vspace>
           </vspaceset>

soft/giet_vm/memo/Makefile

@@ -7 +7 @@
 HDRS += $(wildcard include/libelfpp/dpp/*)
 
-INCLUDES = -Iinclude/libelfpp -Iinclude/libelfpp/elfpp -Iinclude/
-
+INCLUDES = -Iinclude/libelfpp -Iinclude/libelfpp/elfpp -Iinclude/ -I../xml
 memo.x: $(SRCS) $(HDRS)
         g++ -Wall -g  $(SRCS) $(INCLUDES) -o memo.x

soft/giet_vm/memo/src/memo.cpp

@@ -39 +39 @@
 #include "memo.h"
 
-
 //#define MOVER_DEBUG
 
@@ -56 +55 @@
 #ifdef MOVER_DEBUG
     std::cout << "Binary file path: " << m_path << std::endl;
-    //print_mapping_info(m_data);
+    print_mapping_info(m_data);
 #endif
 
@@ -141 +140 @@
 }
 
+//////////////////////////////////////////
 void* MeMo::load_bin(std::string filename)
 {
@@ -167 +167 @@
 }
 
-
+/////////////
 MeMo::~MeMo()
 {
@@ -216 +216 @@
                                   MAPPING_CLUSTER_SIZE*header->clusters +
                                   MAPPING_PSEG_SIZE*header->psegs +
-                                  MAPPING_VSPACE_SIZE*header->vsegs +
-                                  MAPPING_VSPACE_SIZE*header->vspaces);
+                                  MAPPING_VSPACE_SIZE*header->vspaces +
+                                  MAPPING_VSEG_SIZE*header->vsegs);
 }
 
@@ -233 +233 @@
 
     // header
-    std::cout << std::hex << "mapping_info" << std::endl
+    std::cout << std::hex << "mapping_info" << std::dec << std::endl
               << " + signature = " << header->signature << std::endl
-              << " + name = " << header->name << std::endl
-              << " + clusters = " << header->clusters << std::endl
-              << " + psegs = " << header->psegs << std::endl
-             << " + ttys = " << header->ttys  << std::endl
-             << " + vspaces = " << header->vspaces  << std::endl
-             << " + globals = " << header->globals  << std::endl
-             << " + vsegs = " << header->vsegs  << std::endl
-             << " + tasks = " << header->tasks  << std::endl;
+              << " + name      = " << header->name      << std::endl
+              << " + clusters  = " << header->clusters  << std::endl
+              << " + psegs     = " << header->psegs     << std::endl
+              << " + ttys      = " << header->ttys      << std::endl
+              << " + fbs       = " << header->fbs       << std::endl
+              << " + vspaces   = " << header->vspaces   << std::endl
+              << " + globals   = " << header->globals   << std::endl
+              << " + vsegs     = " << header->vsegs     << std::endl
+              << " + vobjs     = " << header->vsegs     << std::endl
+              << " + tasks     = " << header->tasks     << std::endl;
 
     // psegs
     for ( size_t pseg_id = 0 ; pseg_id < header->psegs ; pseg_id++ )
     {
-        std::cout << "pseg " << pseg_id << std::endl
-         << " + name = " << pseg[pseg_id].name << std::endl 
-         << " + base = " << pseg[pseg_id].base << std::endl 
-         << " + length = " << pseg[pseg_id].length << std::endl ;
+        std::cout << "pseg " << pseg[pseg_id].name << std::hex << std::endl 
+                  << " + base   = " << pseg[pseg_id].base   << std::endl 
+                  << " + length = " << pseg[pseg_id].length << std::endl ;
     }
 
@@ -256 +257 @@
     for ( size_t vseg_id = 0 ; vseg_id < header->globals ; vseg_id++ )
     {
-        std::cout << "global vseg: " << vseg_id << std::endl
-         << " + name = " << vseg[vseg_id].name << std::endl 
-         << " + vbase = " << vseg[vseg_id].vbase << std::endl 
-         << " + length = " << vseg[vseg_id].length << std::endl 
-         << " + mode = " << (size_t)vseg[vseg_id].mode << std::endl 
-         << " + ident = " << (bool)vseg[vseg_id].ident << std::endl 
-         << " + psegname" << pseg[vseg[vseg_id].psegid].name << std::endl;
-        for(size_t vobj_id = vseg[vseg_id].vobj_offset ; vobj_id < vseg[vseg_id].vobj_offset + vseg[vseg_id].vobjs ; vobj_id++ )
-        {
-            std::cout << "\t vobjs     = "<<     vobj[vobj_id].name << std::endl;
-            std::cout<<"\t name     =" << vobj[vobj_id].name <<std::endl;
-            std::cout<<"\t type     =" << vobj[vobj_id].type <<std::endl;
-            std::cout<<"\t length   =" << vobj[vobj_id].length <<std::endl;
-            std::cout<<"\t align    =" << vobj[vobj_id].align <<std::endl;
-            std::cout<<"\t binpath  =" << vobj[vobj_id].binpath <<std::endl;
-            std::cout<<"\t \n";
-        }
-    }
-
+        std::cout << std::endl;
+        std::cout << "global vseg "   << vseg[vseg_id].name << std::hex << std::endl 
+                  << " + vbase    = " << vseg[vseg_id].vbase << std::endl 
+                  << " + length   = " << vseg[vseg_id].length << std::endl 
+                  << " + mode     = " << (size_t)vseg[vseg_id].mode << std::endl 
+                  << " + ident    = " << (bool)vseg[vseg_id].ident << std::endl 
+                  << " + psegname = " << pseg[vseg[vseg_id].psegid].name << std::endl;
+        for( size_t vobj_id = vseg[vseg_id].vobj_offset ; 
+                    vobj_id < vseg[vseg_id].vobj_offset + vseg[vseg_id].vobjs ; 
+                    vobj_id++ )
+        {
+            std::cout << "\t vobj "        << vobj[vobj_id].name    << std::endl
+                      << "\t + index   = " << std::dec << vobj_id   << std::endl
+                      << "\t + type    = " << vobj[vobj_id].type    << std::endl
+                      << "\t + length  = " << vobj[vobj_id].length  << std::endl
+                      << "\t + align   = " << vobj[vobj_id].align   << std::endl
+                      << "\t + binpath = " << vobj[vobj_id].binpath << std::endl
+                      << "\t + init    = " << vobj[vobj_id].init    << std::endl;
+        }
+    }
 
     // vspaces
     for ( size_t vspace_id = 0 ; vspace_id < header->vspaces ; vspace_id++ )
     {
-        std::cout << "***vspace: " << vspace_id << "***" << std::endl
-         << " + name = " <<  vspace[vspace_id].name  << std::endl 
-         << " + ttys = " <<  vspace[vspace_id].ttys  << std::endl;
+        std::cout << "***vspace "  << vspace[vspace_id].name   << std::endl 
+                  << " + vsegs = " <<  vspace[vspace_id].vsegs << std::endl 
+                  << " + vobjs = " <<  vspace[vspace_id].vobjs << std::endl 
+                  << " + tasks = " <<  vspace[vspace_id].tasks << std::endl;
 
         for ( size_t vseg_id = vspace[vspace_id].vseg_offset ; 
@@ -287 +290 @@
               vseg_id++ )
         {
-            std::cout << "private vseg: ";
-            std::cout <<  vseg_id  << std::endl
-             << " + name = " <<  vseg[vseg_id].name  << std::endl
-             << " + vbase = " <<  vseg[vseg_id].vbase  << std::endl
-             << " + length = " <<  vseg[vseg_id].length  << std::endl
-             << " + mode = " <<  (size_t)vseg[vseg_id].mode  << std::endl
-             << " + ident = " <<  (bool)vseg[vseg_id].ident  << std::endl
-             << " + psegname = " << pseg[vseg[vseg_id].psegid].name  << std::endl << std::endl;
-            for(size_t vobj_id = vseg[vseg_id].vobj_offset ; vobj_id < vseg[vseg_id].vobj_offset + vseg[vseg_id].vobjs ; vobj_id++ )
+            std::cout << "\t vseg " << vseg[vseg_id].name  << std::endl
+                      << "\t + vbase    = " << vseg[vseg_id].vbase             << std::endl
+                      << "\t + length   = " << vseg[vseg_id].length            << std::endl
+                      << "\t + mode     = " << (size_t)vseg[vseg_id].mode      << std::endl
+                      << "\t + ident    = " << (bool)vseg[vseg_id].ident       << std::endl
+                      << "\t + psegname = " << pseg[vseg[vseg_id].psegid].name << std::endl;
+            for(size_t vobj_id = vseg[vseg_id].vobj_offset ; 
+                       vobj_id < vseg[vseg_id].vobj_offset + vseg[vseg_id].vobjs ; 
+                       vobj_id++ )
             {
-                std::cout<<"\t\t vobjs     =" << vobj[vobj_id].name <<std::endl;
-                std::cout<<"\t\t name     =" << vobj[vobj_id].name <<std::endl;
-                std::cout<<"\t\t type     =" << vobj[vobj_id].type <<std::endl;
-                std::cout<<"\t\t length   =" << vobj[vobj_id].length <<std::endl;
-                std::cout<<"\t\t align    =" << vobj[vobj_id].align <<std::endl;
-                std::cout<<"\t\t binpath  =" << vobj[vobj_id].binpath <<std::endl;
+                std::cout << "\t\t vobj "      << vobj[vobj_id].name      << std::endl
+                          << "\t\t + index   = " << std::dec << vobj_id   << std::endl
+                          << "\t\t + type    = " << vobj[vobj_id].type    << std::endl
+                          << "\t\t + length  = " << vobj[vobj_id].length  << std::endl
+                          << "\t\t + align   = " << vobj[vobj_id].align   << std::endl
+                          << "\t\t + binpath = " << vobj[vobj_id].binpath << std::endl
+                          << "\t\t + init    = " << vobj[vobj_id].init    << std::endl;
             }
         }
@@ -309 +313 @@
 } // end print_mapping_info()
 
-///////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////
 void MeMo::pseg_map( mapping_pseg_t* pseg) 
 {
@@ -317 +321 @@
 
 
-///////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////
 void MeMo::vseg_map( mapping_vseg_t* vseg) 
 {
-
     mapping_vobj_t*     vobj   = get_vobj_base( (mapping_header_t*) m_data ); 
     PSeg *ps = &(m_psegh.get(vseg->psegid));// get physical segment pointer(PSegHandler::get)
@@ -354 +357 @@
 #endif
 
-        if(cur_vobj->type == ELF)
+        if(cur_vobj->type == VOBJ_TYPE_ELF)
         {
             if(!first) 
@@ -475 +478 @@
 
 
-/////////////////////////////////////////////////////////////////////
+///////////////////////////////
 void MeMo::buildMap(void* desc)
 {
@@ -485 +488 @@
 
     // get the psegs
+
 #ifdef MOVER_DEBUG
 std::cout << "\n******* Storing Pseg information *********\n" << std::endl;
 #endif
+
     for ( size_t pseg_id = 0 ; pseg_id < header->psegs ; pseg_id++ )
     {
@@ -494 +499 @@
 
     // map global vsegs
+
 #ifdef MOVER_DEBUG
 std::cout << "\n******* mapping global vsegs *********\n" << std::endl;
 #endif
+
     for ( size_t vseg_id = 0 ; vseg_id < header->globals ; vseg_id++ )
     {
@@ -502 +509 @@
     }
 
-    // second loop on virtual spaces to map private vsegs
+    // loop on virtual spaces to map private vsegs
     for (size_t vspace_id = 0 ; vspace_id < header->vspaces ; vspace_id++ )
     {

soft/giet_vm/sys/common.c

@@ -9 +9 @@
 ///////////////////////////////////////////////////////////////////////////////////
 
+#include <sys_handler.h>
 #include <common.h>
 #include <drivers.h>
 #include <stdarg.h>
+
+////////////////////////////////////////////////////////////////////////////
+// _get_lock()
+////////////////////////////////////////////////////////////////////////////
+inline void _get_lock( unsigned int* plock )
+{
+    register unsigned int  delay = (_proctime() & 0xF) << 4;
+
+    asm volatile (
+            "_lock_llsc:             \n"
+            "ll   $2,    0(%0)       \n" /* $2 <= _ioc_lock current value */
+            "bnez $2,    _lock_delay \n" /* delay if _ioc_lock already taken */
+            "li   $3,    1           \n" /* $3 <= argument for sc */
+            "sc   $3,    0(%0)       \n" /* try to set _ioc_lock */
+            "bnez $3,    _lock_ok    \n" /* exit if atomic */
+            "_lock_delay:            \n"
+            "move $4,    %1          \n" /* $4 <= delay */
+            "_lock_loop:             \n"
+            "addi $4,    $4,    -1   \n" /* $4 <= $4 - 1 */
+            "beqz $4,    _lock_loop  \n" /* test end delay */
+            "j           _lock_llsc  \n" /* retry */
+            "_lock_ok:               \n"
+            :
+            :"r"(plock), "r"(delay)
+            :"$2", "$3", "$4");
+}
+
+////////////////////////////////////////////////////////////////////////////
+// _release_lock()
+////////////////////////////////////////////////////////////////////////////
+inline void _release_lock( unsigned int* plock )
+{
+    *plock = 0;
+}
 
 ////////////////////////////////////////////////////////////////////////////
@@ -156 +191 @@
     return ret;
 }
+
 ///////////////////////////////////////////////////////////////////////////////////
 //      _it_mask()
@@ -163 +199 @@
 {
     asm volatile(
-            "mfc0  $2, $12     \n"
-            "ori   $2, $2, 1   \n"
-            "mtc0  $2, $12     \n"
-            ::: "$2"
+            "lui   $27,      0xFFFF   \n"
+            "ori   $27, $27, 0xFFFE   \n"
+            "mfc0  $26, $12           \n"
+            "and   $26, $26, $27      \n"
+            "mtc0  $26, $12           \n"
+            ::: "$26", "$27"
             );
 }
@@ -176 +214 @@
 {
     asm volatile(
-            "mfc0  $2, $12     \n"
-            "addi  $2, $2, -1  \n"
-            "mtc0  $2, $12     \n"
-            ::: "$2"
+            "mfc0  $26, $12      \n"
+            "ori   $26, $26, 1   \n"
+            "mtc0  $26, $12      \n"
+            ::: "$26"
             );
 }
+
 /////////////////////////////////////////////////////////////////////////////
 //      access functions to mapping_info data structure

soft/giet_vm/sys/common.h

@@ -45 +45 @@
 unsigned int _get_cr();
 
+void _get_lock(unsigned int* lock);
+void _release_lock(unsigned int* lock);
+
 mapping_cluster_t*  _get_cluster_base( mapping_header_t* header );
 mapping_pseg_t*     _get_pseg_base( mapping_header_t* header );

soft/giet_vm/sys/ctx_handler.c

@@ -25 +25 @@
 // ctx[3] <- $3   ctx[11]<- $11   ctx[19]<- $19   ctx[27]<- HI    ctx[35]<- PTPR
 // ctx[4] <- $4   ctx[12]<- $12   ctx[20]<- $20   ctx[28]<- $28   ctx[36]<- MODE
-// ctx[5] <- $5   ctx[13]<- $13   ctx[21]<- $21   ctx[29]<- $29   ctx[37]<- reserved
+// ctx[5] <- $5   ctx[13]<- $13   ctx[21]<- $21   ctx[29]<- $29   ctx[37]<- FBDMA
 // ctx[6] <- $6   ctx[14]<- $14   ctx[22]<- $22   ctx[30]<- $30   ctx[38]<- reserved
 // ctx[7] <- $7   ctx[15]<- $15   ctx[23]<- $23   ctx[31]<- $31   ctx[39]<- reserved
@@ -64 +64 @@
     unsigned int *next_context;
 
-    unsigned int tasks;
-    unsigned int proc_id;
-
-    proc_id = _procid();
-    tasks   = _scheduler[proc_id].tasks;
+    unsigned int pid   = _procid();
+    unsigned int time  = _proctime();
+    unsigned int tasks = _scheduler[pid].tasks;
 
     // return if only one task  */
@@ -74 +72 @@
  
     // compute the task context base address for the current task
-    curr_task_id = _scheduler[proc_id].current;
-    curr_context = &(_scheduler[proc_id].context[curr_task_id][0]);
+    curr_task_id = _scheduler[pid].current;
+    curr_context = &(_scheduler[pid].context[curr_task_id][0]);
     
     // select the next task using a round-robin scheduling policy
@@ -81 +79 @@
     
     // compute the task context base address for the next task
-    next_context = &(_scheduler[proc_id].context[next_task_id][0]);
-
-    //  update the scheduler state, and makes the task switch
-    _scheduler[proc_id].current = next_task_id;
-    _task_switch( curr_context, next_context );
+    next_context = &(_scheduler[pid].context[next_task_id][0]);
 
 #if GIET_DEBUG_SWITCH
-unsigned int time = _proctime();
+_get_lock( &_tty_put_lock );
 _puts( "\n[GIET] Context switch for processor ");
-_putw( proc_id );
+_putw( pid );
 _puts( " at cycle ");
 _putw( time );
@@ -103 +97 @@
 _putw( next_task_id );
 _puts("\n");
+_release_lock( &_tty_put_lock );
 #endif
+
+    //  update the scheduler state, and makes the task switch
+    _scheduler[pid].current = next_task_id;
+    _task_switch( curr_context, next_context );
 
 } // end _ctx_switch

soft/giet_vm/sys/ctx_handler.h

@@ -11 +11 @@
 {
     unsigned int        context[GIET_NB_TASKS_MAX][64];   // task contexts
-    unsigned int        tasks;                            // actual number of tasks
-    unsigned int        current;                          // current task index
+    unsigned int        tasks;                                        // actual number of tasks
+    unsigned int        current;                                      // current task index
 } static_scheduler_t;
 

soft/giet_vm/sys/drivers.c

@@ -16 +16 @@
 //
 // The following global parameters must be defined in the giet_config.h file:
-// - NB_PROCS  : number of PROCS per cluster (if not zero)
-// - NB_DMAS   : number of DMA channels per cluster (if not zero)
-// - NB_TIMERS : number of TIMERS per cluster (if not zero)
-// - NB_TTYS   : number of TTY terminals per cluster (if not zero) 
+// - NB_CLUSTERS  : number of clusters 
+// - NB_PROCS     : number of PROCS per cluster 
+// - NB_TIMERS    : number of TIMERS per cluster
+// - NB_DMAS      : number of DMA channels
+// - NB_TTYS      : number of TTY terminals
+// - NB_TIMERS    : number of TIMERS per cluster
+// - CLUSTER_SPAN : address increment between clusters
 //
 // The following base addresses must be defined in the sys.ld file:
@@ -58 +61 @@
 #endif
 
+#if (NB_TTYS < 1)
+# error: NB_TTYS cannot be smaller than 1!
+#endif
+
+#if (NB_TIMERS < NB_PROCS)
+# error: NB_TIMERS must be larger or equal to NB_PROCS!
+#endif
+
+#if (NB_PROCS > 8)
+# error: NB_PROCS cannot be larger than 8!
+#endif
+
+#if (NB_DMAS < 1)
+# error: NB_DMAS cannot be 0!
+#endif
+
+
 /////////////////////////////////////////////////////////////////////////////
 //      Global (uncachable) variables
@@ -71 +91 @@
 in_unckdata volatile unsigned int  _ioc_lock = 0;
 
-in_unckdata volatile unsigned int  _tty_lock[NB_TTYS] = { [0 ... NB_TTYS-1] = 0 };
 in_unckdata volatile unsigned char _tty_get_buf[NB_TTYS];
 in_unckdata volatile unsigned char _tty_get_full[NB_TTYS] = { [0 ... NB_TTYS-1] = 0 };
+in_unckdata unsigned int           _tty_put_lock;
 
 //////////////////////////////////////////////////////////////////////////////
 //      VciMultiTimer driver
 //////////////////////////////////////////////////////////////////////////////
-// The number of independant timers per cluster is defined by the
-// configuration parameter NB_TIMERS.
+// There is one MULTI-TIMER component per cluster.
+// The number of timers per cluster must be larger or equal to the number 
+// processors (NB_TIMERS >= NB_PROCS), because each processor uses a private
+// yimer for context switch.
 // The total number of timers is NB_CLUSTERS * NB_TIMERS
-// The global timer index = cluster_id*NB_TIMER + timer_id
+// The global timer index = cluster_id*NB_TIMERS + timer_id
 //////////////////////////////////////////////////////////////////////////////
 
@@ -87 +109 @@
 // _timer_write()
 //
-// Write a 32-bit word in a memory mapped register of a timer device. 
-// Returns 0 if success, > 0 if error.
-//////////////////////////////////////////////////////////////////////////////
-unsigned int _timer_write( unsigned int global_timer_index,
+// Write a 32-bit word in a memory mapped register of a timer device,
+// identified by the cluster index and the local timer index. 
+// Returns 0 if success, > 0 if error.
+//////////////////////////////////////////////////////////////////////////////
+unsigned int _timer_write( unsigned int cluster_index,
+                           unsigned int timer_index,
                            unsigned int register_index, 
                            unsigned int value )
 {
-    volatile unsigned int *timer_address;
-
-    unsigned int        cluster_id = global_timer_index / NB_TIMERS;
-    unsigned int        timer_id   = global_timer_index % NB_TIMERS;
-
-    /* parameters checking */
-    if ( register_index >= TIMER_SPAN)                  return 1;
-    if ( global_timer_index >= NB_CLUSTERS*NB_TIMERS )  return 1;
+    unsigned int*       timer_address;
+
+    // parameters checking 
+    if ( register_index >= TIMER_SPAN)          return 1;
+    if ( cluster_index >= NB_CLUSTERS)          return 1;
+    if ( timer_index >= NB_TIMERS )         return 1;
 
     timer_address = (unsigned int*)&seg_timer_base + 
-                    ( cluster_id * CLUSTER_SPAN )  +
-                    ( timer_id * TIMER_SPAN );
-
-    timer_address[register_index] = value; /* write word */
+                    ( cluster_index * CLUSTER_SPAN )  +
+                    ( timer_index * TIMER_SPAN );
+
+    timer_address[register_index] = value; // write word
 
     return 0;
@@ -115 +137 @@
 // _timer_read()
 //
-// Read a 32-bit word in a memory mapped register of a timer device. 
-// Returns 0 if success, > 0 if error.
-//////////////////////////////////////////////////////////////////////////////
-unsigned int _timer_read(unsigned int global_timer_index,
+// Read a 32-bit word in a memory mapped register of a timer device,
+// identified by the cluster index and the local timer index. 
+// Returns 0 if success, > 0 if error.
+//////////////////////////////////////////////////////////////////////////////
+unsigned int _timer_read(unsigned int cluster_index,
+                         unsigned int timer_index, 
                          unsigned int register_index, 
                          unsigned int *buffer)
 {
-    volatile unsigned int *timer_address;
-
-    unsigned int        cluster_id = global_timer_index / NB_TIMERS;
-    unsigned int        timer_id   = global_timer_index % NB_TIMERS;
-
-    /* parameters checking */
-    if ( register_index >= TIMER_SPAN)                  return 1;
-    if ( global_timer_index >= NB_CLUSTERS*NB_TIMERS )  return 1;
+    unsigned int *timer_address;
+
+    // parameters checking
+    if ( register_index >= TIMER_SPAN)          return 1;
+    if ( cluster_index >= NB_CLUSTERS)          return 1;
+    if ( timer_index >= NB_TIMERS )         return 1;
 
     timer_address = (unsigned int*)&seg_timer_base + 
-                    ( cluster_id * CLUSTER_SPAN )  +
-                    ( timer_id * TIMER_SPAN );
-
-    *buffer = timer_address[register_index]; /* read word */
+                    ( cluster_index * CLUSTER_SPAN )  +
+                    ( timer_index * TIMER_SPAN );
+
+    *buffer = timer_address[register_index]; // read word 
 
     return 0;
@@ -146 +168 @@
 // The system terminal is TTY[0].
 // The TTYs are allocated to applications by the GIET in the boot phase.
-// The nummber of TTYs allocated to each application, and the TTY used by each
+// The nummber of TTYs allocated to each application, and used by each
 // task can be defined in the mapping_info data structure.
 // For each user task, the tty_id is stored in the context of the task (slot 34),
@@ -152 +174 @@
 // The TTY address is always computed as : seg_tty_base + tty_id*TTY_SPAN
 ///////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////
-// tty_get_lock()
-//
-// This blocking function is intended to be used by the _tty_write() function
-// to provide exclusive access to the TTY. It is not used yet, because it appears
-// that it creates livelock situations...
-///////////////////////////////////////////////////////////////////////////////////
-static inline void _tty_get_lock( unsigned int tty_id )
-{
-    register unsigned int delay = (_proctime() & 0xF) << 4;
-    register unsigned int *plock = (unsigned int*)&_tty_lock[tty_id];
-
-    asm volatile (
-            "_tty_llsc:             \n"
-            "ll   $2,    0(%0)      \n" /* $2 <= _tty_lock current value */
-            "bnez $2,    _tty_delay \n" /* delay if _tty_lock already taken */
-            "li   $3,    1          \n" /* $3 <= argument for sc */
-            "sc   $3,    0(%0)      \n" /* try to set _tty_lock */
-            "bnez $3,    _tty_ok    \n" /* exit if atomic */
-            "_tty_delay:            \n"
-            "move $4,    %1         \n" /* $4 <= delay */
-            "_tty_loop:             \n"
-            "addi $4,    $4,    -1  \n" /* $4 <= $4 - 1 */
-            "beqz $4,    _tty_loop  \n" /* test end delay */
-            "j           _tty_llsc  \n" /* retry */
-            "_tty_ok:               \n"
-            :
-            :"r"(plock), "r"(delay)
-            :"$2", "$3", "$4");
-}
 
 //////////////////////////////////////////////////////////////////////////////
@@ -194 +185 @@
 // The function returns  the number of characters that have been written.
 //////////////////////////////////////////////////////////////////////////////
-unsigned int _tty_write(const char *buffer, unsigned int length)
+unsigned int _tty_write( const char             *buffer, 
+                         unsigned int   length)
 {
     volatile unsigned int *tty_address;
@@ -212 +204 @@
     for (nwritten = 0; nwritten < length; nwritten++)
     {
-        /* check tty's status */
+        // check tty's status 
         if ((tty_address[TTY_STATUS] & 0x2) == 0x2)
             break;
         else
-            /* write character */
+            // write character 
             tty_address[TTY_WRITE] = (unsigned int)buffer[nwritten];
     }
@@ -226 +218 @@
 //
 // This non-blocking function uses the TTY_GET_IRQ[tty_id] interrupt and 
-// the associated // kernel buffer, that has been written by the ISR.
+// the associated kernel buffer, that has been written by the ISR.
 // It fetches one single character from the _tty_get_buf[tty_id] kernel
 // buffer, writes this character to the user buffer, and resets the
@@ -232 +224 @@
 // Returns 0 if the kernel buffer is empty, 1 if the buffer is full.
 //////////////////////////////////////////////////////////////////////////////
-unsigned int _tty_read_irq(char *buffer, unsigned int length)
+unsigned int _tty_read_irq( char                        *buffer, 
+                            unsigned int        length)
 {
     unsigned int proc_id;
@@ -262 +255 @@
 // register of the TTY controler, and writes this character to the user buffer.
 // It doesn't use the TTY_GET_IRQ interrupt and the associated kernel buffer.
-// It doesn't take the lock protecting exclusive access...
 // Returns 0 if the register is empty, 1 if the register is full.
 ////////////////////////////////////////////////////////////////////////////////
-unsigned int _tty_read(char *buffer, unsigned int length)
+unsigned int _tty_read( char                    *buffer, 
+                        unsigned int    length)
 {
     volatile unsigned int *tty_address;
@@ -296 +289 @@
 // _icu_write()
 //
-// Write a 32-bit word in a memory mapped register of the ICU device. The
-// base address is deduced by the proc_id.
-// Returns 0 if success, > 0 if error.
-////////////////////////////////////////////////////////////////////////////////
-unsigned int _icu_write(unsigned int register_index, unsigned int value)
-{
-    volatile unsigned int *icu_address;
-    unsigned int proc_id;
-
-    /* parameters checking */
-    if (register_index >= ICU_END)
-        return 1;
-
-    proc_id = _procid();
-    icu_address = (unsigned int*)&seg_icu_base + (proc_id * ICU_SPAN);
-    icu_address[register_index] = value;   /* write word */
+// Write a 32-bit word in a memory mapped register of the MULTI_ICU device,
+// identified by the cluster index, and a processor local index.
+// Returns 0 if success, > 0 if error.
+////////////////////////////////////////////////////////////////////////////////
+unsigned int _icu_write( unsigned int cluster_index,
+                         unsigned int proc_index,
+                         unsigned int register_index, 
+                         unsigned int value )
+{
+    unsigned int *icu_address;
+
+    // parameters checking 
+    if ( register_index >= ICU_SPAN)            return 1;
+    if ( cluster_index >= NB_CLUSTERS)          return 1;
+    if ( proc_index >= NB_PROCS )           return 1;
+
+    icu_address = (unsigned int*)&seg_icu_base + 
+                  ( cluster_index * CLUSTER_SPAN )  +
+                  ( proc_index * ICU_SPAN );
+
+    icu_address[register_index] = value;   // write word 
     return 0;
 }
@@ -318 +316 @@
 // _icu_read()
 //
-// Read a 32-bit word in a memory mapped register of the ICU device. The
-// ICU base address is deduced by the proc_id.
-// Returns 0 if success, > 0 if error.
-////////////////////////////////////////////////////////////////////////////////
-unsigned int _icu_read(unsigned int register_index, unsigned int *buffer)
-{
-    volatile unsigned int *icu_address;
-    unsigned int proc_id;
-
-    /* parameters checking */
-    if (register_index >= ICU_END)
-        return 1;
-
-    proc_id = _procid();
-    icu_address = (unsigned int*)&seg_icu_base + (proc_id * ICU_SPAN);
-    *buffer = icu_address[register_index]; /* read word */
+// Read a 32-bit word in a memory mapped register of the MULTI_ICU device,
+// identified by the cluster index and a processor local index.
+// Returns 0 if success, > 0 if error.
+////////////////////////////////////////////////////////////////////////////////
+unsigned int _icu_read(  unsigned int cluster_index,
+                         unsigned int proc_index,
+                         unsigned int register_index, 
+                         unsigned int* buffer )
+{
+    unsigned int *icu_address;
+
+    // parameters checking 
+    if ( register_index >= ICU_SPAN)            return 1;
+    if ( cluster_index >= NB_CLUSTERS)          return 1;
+    if ( proc_index >= NB_PROCS )           return 1;
+
+    icu_address = (unsigned int*)&seg_icu_base + 
+                  ( cluster_index * CLUSTER_SPAN )  +
+                  ( proc_index * ICU_SPAN );
+
+    *buffer = icu_address[register_index]; // read word 
     return 0;
 }
@@ -341 +344 @@
 ////////////////////////////////////////////////////////////////////////////////
 // The Greater Dommon Divider is a -very- simple hardware coprocessor
-// performing the computation of a GCD of two 32 bits integers.
+// performing the computation of the GCD of two 32 bits integers.
 // It has no DMA capability.
 ////////////////////////////////////////////////////////////////////////////////
@@ -351 +354 @@
 // Returns 0 if success, > 0 if error.
 ////////////////////////////////////////////////////////////////////////////////
-unsigned int _gcd_write(unsigned int register_index, unsigned int value)
+unsigned int _gcd_write( unsigned int register_index, 
+                         unsigned int value)
 {
     volatile unsigned int *gcd_address;
 
-    /* parameters checking */
+    // parameters checking
     if (register_index >= GCD_END)
         return 1;
 
     gcd_address = (unsigned int*)&seg_gcd_base;
-    gcd_address[register_index] = value; /* write word */
+
+    gcd_address[register_index] = value; // write word
     return 0;
 }
@@ -370 +375 @@
 // Returns 0 if success, > 0 if error.
 ////////////////////////////////////////////////////////////////////////////////
-unsigned int _gcd_read(unsigned int register_index, unsigned int *buffer)
+unsigned int _gcd_read( unsigned int register_index, 
+                        unsigned int *buffer)
 {
     volatile unsigned int *gcd_address;
 
-    /* parameters checking */
+    // parameters checking 
     if (register_index >= GCD_END)
         return 1;
 
     gcd_address = (unsigned int*)&seg_gcd_base;
-    *buffer = gcd_address[register_index]; /* read word */
+
+    *buffer = gcd_address[register_index]; // read word
     return 0;
 }
@@ -386 +393 @@
 // VciBlockDevice driver
 ////////////////////////////////////////////////////////////////////////////////
-// The VciBlockDevice is a simple external storage contrÃŽler.
+// The VciBlockDevice is a single channel external storage contrÃŽler.
 // The three functions below use the three variables _ioc_lock _ioc_done,  and
-// _ioc_status for synchronsation.
+// _ioc_status for synchronisation.
 // As the IOC component can be used by several programs running in parallel,
 // the _ioc_lock variable guaranties exclusive access to the device.  The
@@ -429 +436 @@
             "move $4,    %1         \n" /* $4 <= delay */
             "_ioc_loop:             \n"
+            "beqz $4,    _ioc_loop  \n" /* test end delay */
             "addi $4,    $4,    -1  \n" /* $4 <= $4 - 1 */
-            "beqz $4,    _ioc_loop  \n" /* test end delay */
-            "j           _ioc_llsc  \n" /* retry */
+            "j           _ioc_llsc  \n" /* retry ll */
+            "nop                    \n"
             "_ioc_ok:               \n"
             :

soft/giet_vm/sys/drivers.h

@@ -6 +6 @@
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef _DRIVERS_H_
-#define _DRIVERS_H_
+#ifndef _GIET_SYS_DRIVERS_H_
+#define _GIET_SYS_DRIVERS_H_
 
 ///////////////////////////////////////////////////////////////////////////////////
@@ -22 +22 @@
 extern volatile unsigned char _tty_get_buf[];
 extern volatile unsigned char _tty_get_full[];
+extern unsigned int           _tty_put_lock;
 
 ///////////////////////////////////////////////////////////////////////////////////
-// Prototypes of the drivers functions.
+// Prototypes of the external functions.
 ///////////////////////////////////////////////////////////////////////////////////
 
-unsigned int _timer_write(unsigned int global, unsigned int reg, unsigned int value);
-unsigned int _timer_read(unsigned int global, unsigned int reg, unsigned int *buffer);
+unsigned int _timer_write(  unsigned int        cluster_id,
+                            unsigned int        timer_id, 
+                            unsigned int        register_id, 
+                            unsigned int        value);
 
-unsigned int _tty_write(const char *buffer, unsigned int length);
-unsigned int _tty_read(char *buffer, unsigned int length);
-unsigned int _tty_read_irq(char *buffer, unsigned int length);
+unsigned int _timer_read(   unsigned int        cluster_id,
+                            unsigned int        timer_id, 
+                            unsigned int        register_id, 
+                            unsigned int*       buffer);
 
-unsigned int _ioc_write(unsigned int lba, const void *buffer, unsigned int count);
-unsigned int _ioc_read(unsigned int lba, void *buffer, unsigned int count);
+unsigned int _icu_write(    unsigned int        cluster_id,
+                            unsigned int        proc_id, 
+                            unsigned int        register_id, 
+                            unsigned int        value);
+
+unsigned int _icu_read(     unsigned int        cluster_id,
+                            unsigned int        proc_id, 
+                            unsigned int        register_id, 
+                            unsigned int*       buffer);
+
+unsigned int _tty_write(    const char*         buffer, 
+                            unsigned int        length);
+
+unsigned int _tty_read(     char*                       buffer, 
+                            unsigned int        length);
+
+unsigned int _tty_read_irq( char*                       buffer, 
+                            unsigned int        length);
+
+unsigned int _ioc_write(    unsigned int        lba, 
+                            const void*         buffer, 
+                            unsigned int        count);
+
+unsigned int _ioc_read(     unsigned int        lba, 
+                            void*                       buffer, 
+                            unsigned int        count);
+
 unsigned int _ioc_completed();
 
-unsigned int _icu_write(unsigned int register_index, unsigned int value);
-unsigned int _icu_read(unsigned int register_index, unsigned int *buffer);
+unsigned int _gcd_write(    unsigned int        register_index, 
+                            unsigned int        value);
 
-unsigned int _gcd_write(unsigned int register_index, unsigned int value);
-unsigned int _gcd_read(unsigned int register_index, unsigned int *buffer);
+unsigned int _gcd_read(     unsigned int        register_index, 
+                            unsigned int*       buffer);
 
-unsigned int _fb_sync_write(unsigned int offset, const void *buffer, unsigned int length);
-unsigned int _fb_sync_read(unsigned int offset, const void *buffer, unsigned int length);
-unsigned int _fb_write(unsigned int offset, const void *buffer, unsigned int length);
-unsigned int _fb_read(unsigned int offset, const void *buffer, unsigned int length);
+unsigned int _fb_sync_write(unsigned int        offset, 
+                            const void*         buffer, 
+                            unsigned int        length);
+
+unsigned int _fb_sync_read( unsigned int        offset, 
+                            const void*         buffer, 
+                            unsigned int        length);
+
+unsigned int _fb_write(     unsigned int        offset, 
+                            const void*         buffer, 
+                            unsigned int        length);
+
+unsigned int _fb_read(      unsigned int        offset, 
+                            const void*         buffer, 
+                            unsigned int        length);
+
 unsigned int _fb_completed();
 

soft/giet_vm/sys/giet.s

@@ -26 +26 @@
     mfc0    $27,    $13                 /* $27 <= Cause register */
     la      $26,    _cause_vector       /* $26 <= _cause_vector */
-    andi    $27,    $27,    0x3c        /* $27 <= XCODE*4 */
-    addu    $26,    $26,    $27         /* $26 <= &_cause_vector[XCODE] */
+    andi    $27,    $27,    0x3c            /* $27 <= XCODE*4 */
+    addu    $26,    $26,    $27             /* $26 <= &_cause_vector[XCODE] */
     lw      $26,    ($26)               /* $26 <=  _cause_vector[XCODE] */
     jr      $26                         /* Jump indexed by XCODE */

soft/giet_vm/sys/irq_handler.c

@@ -29 +29 @@
 // This functions uses an external ICU component (Interrupt Controler Unit)
 // that concentrates up to 32 input interrupts lines. This component
-// can support up to NB_PROCS_MAX output IRQ.
+// can support up to NB_PROCS output IRQ.
 //
 // This component returns the highest priority active interrupt index (smaller
@@ -38 +38 @@
 // The interrupt vector (32 ISR addresses array stored at _interrupt_vector
 // address) is initialised with the default ISR address. The actual ISR
-// addresses are supposed to be written in the interrupt vector array by the
-// boot code.
+// addresses are supposed to be written in the interrupt vector array 
+// during system initialisation.
 ///////////////////////////////////////////////////////////////////////////////////
 void _int_demux(void)
 {
-    int interrupt_index;
-    _isr_func_t isr;
-
-    // interrupt vector initialisation
-
-
-    /* retrieves the highest priority active interrupt index */
-    if (!_icu_read(ICU_IT_VECTOR, (unsigned int*)&interrupt_index))
+    int                         interrupt_index;
+    _isr_func_t         isr;
+    unsigned int        pid = _procid();
+
+    // retrieves the highest priority active interrupt index 
+    if (!_icu_read( pid / NB_PROCS,
+                    pid % NB_PROCS,
+                    ICU_IT_VECTOR,
+                    (unsigned int*)&interrupt_index ) )
     {
-        /* no interrupt is active */
-        if (interrupt_index == -1)
+        if (interrupt_index == -1)      // no interrupt is active 
             return;
 
-        /* call the ISR corresponding to this index */
         isr = _interrupt_vector[interrupt_index];
         isr();
     }
+    else
+    {
+        _puts("\n[GIET ERROR] In _demux function : wrong arguments in _icu_read()\n");
+        _exit();
+    }
 }
 ///////////////////////////////////////////////////////////////////////////////////
@@ -70 +74 @@
     _puts("\n\n!!! Default ISR !!!\n");
 }
+
 ///////////////////////////////////////////////////////////////////////////////////
 //      _isr_dma()
-// This ISR acknowledges the interrupt from the dma controller, depending on
-// the proc_id. It reset the global variable _dma_busy[i] for software
-// signaling, after copying the DMA status into the _dma_status[i] variable.
-///////////////////////////////////////////////////////////////////////////////////
-void _isr_dma()
+// This ISR handles up to 8 IRQs generated by 8 independant channels of the
+// multi_dma component. It acknowledges the interrupt and reset the synchronisation
+// variable _dma_busy[i], after copying the status into the _dma_status[i] variable.
+///////////////////////////////////////////////////////////////////////////////////
+void _isr_dma_indexed( unsigned int dma_id )
 {
     volatile unsigned int* dma_address;
-    unsigned int proc_id;
-
-    proc_id = _procid();
-    dma_address = (unsigned int*)&seg_dma_base + (proc_id * DMA_SPAN);
-
-    _dma_status[proc_id] = dma_address[DMA_LEN]; /* save status */
-    _dma_busy[proc_id] = 0;                      /* release DMA */
-    dma_address[DMA_RESET] = 0;                  /* reset IRQ */
-}
+
+    dma_address = (unsigned int*)&seg_dma_base + (dma_id * DMA_SPAN);
+
+    dma_address[DMA_RESET] = 0;                                 /* reset IRQ */
+
+    _dma_status[dma_id] = dma_address[DMA_LEN]; /* save status */
+    _dma_busy[dma_id] = 0;                      /* release DMA */
+}
+
+void _isr_dma_0() { _isr_dma_indexed(0); }
+void _isr_dma_1() { _isr_dma_indexed(1); }
+void _isr_dma_2() { _isr_dma_indexed(2); }
+void _isr_dma_3() { _isr_dma_indexed(3); }
+void _isr_dma_4() { _isr_dma_indexed(4); }
+void _isr_dma_5() { _isr_dma_indexed(5); }
+void _isr_dma_6() { _isr_dma_indexed(6); }
+void _isr_dma_7() { _isr_dma_indexed(7); }
+
 ///////////////////////////////////////////////////////////////////////////////////
 //      _isr_ioc()
@@ -103 +117 @@
     _ioc_done   = 1;                                /* signals completion */
 }
+
 ///////////////////////////////////////////////////////////////////////////////////
 //      _isr_timer_* (* = 0,1,2,3,4,5,6,7)

soft/giet_vm/sys/irq_handler.h

@@ -18 +18 @@
 void _isr_default();
 
-void _isr_dma();
+void _isr_dma_0();
+void _isr_dma_1();
+void _isr_dma_2();
+void _isr_dma_3();
+void _isr_dma_4();
+void _isr_dma_5();
+void _isr_dma_6();
+void _isr_dma_7();
 
 void _isr_ioc();
 
-void _isr_timer0();
-void _isr_timer1();
-void _isr_timer2();
-void _isr_timer3();
+void _isr_timer_0();
+void _isr_timer_1();
+void _isr_timer_2();
+void _isr_timer_3();
+void _isr_timer_4();
+void _isr_timer_5();
+void _isr_timer_6();
+void _isr_timer_7();
 
 void _isr_tty_get();

soft/giet_vm/sys/mips32_registers.h

@@ -73 +73 @@
 #define CP2_PARAMS              $15 
 #define CP2_RELEASE             $16 
-#define CP2_DATA_LO             $17     
-#define CP2_DATA_HI             $18             
+#define CP2_DATA_LO                             $17     
+#define CP2_DATA_HI                             $18             
 #define CP2_ICACHE_INVAL_PA     $19             
 #define CP2_DCACHE_INVAL_PA     $20 
@@ -87 +87 @@
 #define CTX_PTPR_ID             35
 #define CTX_MODE_ID             36
+#define CTX_FBDMA_ID    37
+#define CTX_TASK_ID             63
 
 

soft/giet_vm/sys/sys.ld

@@ -10 +10 @@
 seg_kernel_uncdata_base = 0x80020000;   /* system uncacheable data */
 seg_kernel_init_base    = 0x80030000;   /* system page table */ 
+seg_mapping_base            = 0xBFC0C000;       /* boot mapping_info */
 
 
@@ -22 +23 @@
 seg_fb_base             = 0x96000000;   /* FrameBuffer device */
 seg_icu_base            = 0x9F000000;   /* ICU device */
-
-/*****************************************/
-seg_mapping_base        = 0xBFC0C000;   /* boot mapping_info */
 
 /*
@@ -65 +63 @@
     seg_kernel_init : 
     {
-        *(.kinitentry)
         *(.kinit)
     }

soft/giet_vm/sys/sys_handler.c

@@ -83 +83 @@
     _puts(" on processor ");
     _putw( proc_id );
+    _puts("\n\n");
 
     /* infinite loop */
@@ -96 +97 @@
     unsigned int ret;
     asm volatile("mfc0 %0, $15, 1" : "=r"(ret));
-    return (ret & 0x3FF);
+    return (ret & 0xFFF);
 }
 //////////////////////////////////////////////////////////////////////////////
@@ -132 +133 @@
 /////////////////////////////////////////////////////////////////////////////
 // _vobj_get_vbase()
+// This function writes in vobj_buffer the virtual base address of a vobj 
+// identified by the (vspace_name / vobj_name ) couple.
+// The vobj_type argument is redundant, and for checking purpose.
 // returns 0: success, else: failed.
-// return the virtual base address of a vobj identified by the (vspace_name / channel_name ) couple.
-// The "type" argument is here for checking purpose.
 /////////////////////////////////////////////////////////////////////////////
-unsigned int _vobj_get_vbase( char* vspace_name, char* vobj_name,
-                        unsigned vobj_type, unsigned int* vobj_buffer)
+unsigned int _vobj_get_vbase( char*                     vspace_name, 
+                              char*                     vobj_name,
+                              unsigned int      vobj_type, 
+                              unsigned int* vobj_vaddr )
 {
     mapping_header_t* header = (mapping_header_t*)&seg_mapping_base;
@@ -153 +157 @@
         {
             // scan vobjs
-            for(vobj_id= vspace[vspace_id].vobj_offset; vobj_id < (vspace[vspace_id].vobj_offset + vspace[vspace_id].vobjs); vobj_id++)
+            for( vobj_id = vspace[vspace_id].vobj_offset; 
+                 vobj_id < (vspace[vspace_id].vobj_offset + vspace[vspace_id].vobjs); 
+                 vobj_id++)
             {
 
@@ -159 +165 @@
                 {
                     if(vobj[vobj_id].type != vobj_type)
-                        return -1;//wrong type
+                        return -1;                                                      //wrong type
 
-                    *vobj_buffer = (unsigned int)vobj[vobj_id].vaddr;
+                    *vobj_vaddr = (unsigned int)vobj[vobj_id].vaddr;
                     return 0;
                 }
@@ -167 +173 @@
         }
     } 
-    return -2;//not found 
+    return -2;          //not found 
 }
 

soft/giet_vm/xml/mapping_info.h

@@ -57 +57 @@
 enum 
 {
-    ELF = 0,    //loadable code object
-    PTAB,       //page table 
-    PERI,       //hardware component
-    MWMR,       //MWMR channel
-    LOCK,       //Lock
-    BUFFER,     //Any "no intialiasation needed" objects (stacks...)
-    BARRIER     //Barrier
+    VOBJ_TYPE_ELF     = 0,     // loadable code object
+    VOBJ_TYPE_PTAB    = 1,     // page table 
+    VOBJ_TYPE_PERI    = 2,     // hardware component
+    VOBJ_TYPE_MWMR    = 3,     // MWMR channel
+    VOBJ_TYPE_LOCK    = 4,     // Lock
+    VOBJ_TYPE_BUFFER  = 5,     // Any "no intialiasation needed" objects (stacks...)
+    VOBJ_TYPE_BARRIER = 6,     // Barrier
 };
 
@@ -74 +74 @@
         unsigned int    psegs;          // number of psegs
     unsigned int    ttys;           // number of TTY terminals 
+    unsigned int    fbs;            // number of Frame Buffer DMA channels
         unsigned int    globals;                // number of vsegs mapped in all vspaces
         unsigned int    vspaces;                // number of virtual spaces
         unsigned int    vsegs;                  // total number of virtual segments (for all vspaces)
-        unsigned int    vobjs;                  // total number of virtual memory objects (for all vspaces)
+        unsigned int    vobjs;                  // total number of virtual objects (for all vspaces)
         unsigned int    tasks;                  // total number of tasks (for all vspaces)
     char            name[32];       // mapping name
@@ -86 +87 @@
 {
     unsigned int    procs;          // number of processors in cluster
-    unsigned int    timers;         // number of timers in cluster
-    unsigned int    dmas;           // number of DMA channels in cluster
 } mapping_cluster_t;
 
@@ -103 +102 @@
 {
     char            name[32];       // virtual space name
-    unsigned int    funcs_offset;   // offset of the vobj containing the function entry table (relative to vobj_offset)
-        unsigned int    vsegs;              // number of private virtual segments
-        unsigned int    vobjs;              // number of vobjs channels
-        unsigned int    tasks;              // number of tasks
-        unsigned int    ttys;               // number of required TTY terminals
+    unsigned int    start_offset;   // offset of the vobj containing the start vector
+        unsigned int    vsegs;              // number of vsegs in vspace
+        unsigned int    vobjs;              // number of vobjs in vspace
+        unsigned int    tasks;              // number of tasks in vspace
     unsigned int    vseg_offset;    // index of first vseg in vspace 
     unsigned int    vobj_offset;    // index of first vobjs in vspace
@@ -121 +119 @@
         unsigned int    length;         // size (bytes)
         unsigned int    psegid;         // physical segment index
-        unsigned char   mode;           // C-X-W-U flags
-    unsigned char   ident;          // identity mapping if non zero
-        unsigned int    vobjs;              // number of vobjs channels
-    unsigned int    vobj_offset;    // index of first vobjs in vspace
-    unsigned char   reserved;       // unused
+        unsigned int    mode;           // C-X-W-U flags
+    unsigned int    ident;          // identity mapping if non zero
+        unsigned int    vobjs;              // number of vobjs in vseg
+    unsigned int    vobj_offset;    // index of first vobjs in vseg
 } mapping_vseg_t;
 
@@ -135 +132 @@
         unsigned int    proclocid;      // processor local index (inside cluster)
     unsigned int    vobjlocid;      // stack vobj index in vspace
-    unsigned int    startid;        // index in start_vector (in seg_data)
-    unsigned int    ttylocid;       // tty index (inside the vspace)
+    unsigned int    startid;        // index in start_vector 
+    unsigned int    use_tty;        // TTY terminal required
+    unsigned int    use_fb;         // DMA channel to frame buffer required
 } mapping_task_t;
 
@@ -143 +141 @@
 {
     char            name[32];       // vobj name (unique in a vspace)
-    char            binpath[64];    // path for the binary code ("*.bin")
+    char            binpath[64];    // path for the binary code ("*.elf")
         unsigned int    type;           // type of vobj
         unsigned int    length;         // size (bytes)
         unsigned int    align;          // required alignement (logarithm of 2)
-        unsigned int    vaddr;          // virtual addresse of the vobj location (bytes)
-        unsigned int    paddr;          // physical addresse of the vobj location (bytes)
+        unsigned int    vaddr;          // virtual base addresse of the vobj
+        unsigned int    paddr;          // physical base addresse of the vobj
+        unsigned int    init;           // init value (number of participants for a barrier)
 } mapping_vobj_t;
 

soft/giet_vm/xml/xml_driver.c

@@ -111 +111 @@
     fprintf( fpout, "              psegs     = \"%d\"\n", header->psegs);
     fprintf( fpout, "              ttys      = \"%d\"\n", header->ttys);
+    fprintf( fpout, "              fbs       = \"%d\"\n", header->fbs);
     fprintf( fpout, "              vspaces   = \"%d\"\n", header->vspaces);
-    fprintf( fpout, "              globals   = \"%d\" />\n\n", header->globals);
+    fprintf( fpout, "              globals   = \"%d\" >\n\n", header->globals);
 
     ///////////////////// clusters ///////////////////////////////////////////////
@@ -119 +120 @@
     for ( cluster_id = 0 ; cluster_id < header->clusters ; cluster_id++ )
     {
-        fprintf( fpout, "        <cluster procs  = \"%d\"\n",      cluster[cluster_id].procs);
-        fprintf( fpout, "                 timers = \"%d\"\n",      cluster[cluster_id].timers);
-        fprintf( fpout, "                 dmas   = \"%d\" />\n\n", cluster[cluster_id].dmas);
+        fprintf( fpout, "        <cluster index  = \"%d\"\n",      cluster_id);
+        fprintf( fpout, "                 procs  = \"%d\" />\n\n", cluster[cluster_id].procs);
     }
     fprintf( fpout, "    </clusterset>\n" );
@@ -148 +148 @@
         fprintf( fpout, "                 mode     = \"%s\"\n", mode_str[vseg[vseg_id].mode]);
         fprintf( fpout, "                 psegname = \"%s\"\n",      pseg[pseg_id].name);
-        fprintf( fpout, "                 ident    = \"%d\" >\n", vseg[vseg_id].ident);
-            for ( vobj_id = vseg[vseg_id].vobj_offset ;
-                  vobj_id < (vseg[vseg_id].vobj_offset + vseg[vseg_id].vobjs) ; vobj_id++ )
-            {
-                fprintf( fpout, "                 <vobj name     = \"%s\"\n",     vobj[vobj_id].name);
-                fprintf( fpout, "                       type     = \"%s\" \n", vobj_type[vobj[vobj_id].type]);
-                if(vobj[vobj_id].length)
-                    fprintf( fpout, "                       length   = \"0x%x\" \n",   vobj[vobj_id].length);
-                if(vobj[vobj_id].align)
-                    fprintf( fpout, "                       align    = \"%d\" \n",   vobj[vobj_id].align);
-                if(vobj[vobj_id].binpath[0]!='\0')
-                    fprintf( fpout, "                       binpath  = \"%s\" \n",   vobj[vobj_id].binpath);
-                fprintf( fpout, "                       />\n");
-            }
-            fprintf( fpout, "        </vseg>\n\n");
+        fprintf( fpout, "                 ident    = \"%d\" >\n",    vseg[vseg_id].ident);
+        for ( vobj_id = vseg[vseg_id].vobj_offset;
+              vobj_id < (vseg[vseg_id].vobj_offset + vseg[vseg_id].vobjs); 
+              vobj_id++ )
+        {
+            fprintf( fpout, "                 <vobj name     = \"%s\"\n",    vobj[vobj_id].name);
+            fprintf( fpout, "                       type     = \"%s\"\n",    vobj_type[vobj[vobj_id].type]);
+            fprintf( fpout, "                       length   = \"0x%x\"\n",  vobj[vobj_id].length);
+            fprintf( fpout, "                       align    = \"%d\"\n",    vobj[vobj_id].align);
+            fprintf( fpout, "                       init     = \"%d\" \n",   vobj[vobj_id].init);
+            fprintf( fpout, "                       binpath  = \"%s\" />\n", vobj[vobj_id].binpath);
+        }
+        fprintf( fpout, "        </vseg>\n\n");
     }
     fprintf( fpout, "    </globalset>\n" );
@@ -171 +169 @@
     for ( vspace_id = 0 ; vspace_id < header->vspaces ; vspace_id++ )
     {
-        unsigned int func_id = vspace[vspace_id].vobj_offset + vspace[vspace_id].funcs_offset; 
-        fprintf( fpout, "        <vspace  name    = \"%s\"\n",     vspace[vspace_id].name); 
-        fprintf( fpout, "                 funcs   = \"%s\"\n",     vobj[func_id].name); 
-        fprintf( fpout, "                 ttys    = \"%d\" >\n\n", vspace[vspace_id].ttys);
+        unsigned int func_id = vspace[vspace_id].vobj_offset + vspace[vspace_id].start_offset; 
+        fprintf( fpout, "        <vspace  name      = \"%s\"\n",     vspace[vspace_id].name); 
+        fprintf( fpout, "                 startname = \"%s\" >\n\n", vobj[func_id].name); 
 
         for ( vseg_id = vspace[vspace_id].vseg_offset ;
@@ -185 +182 @@
             fprintf( fpout, "                       mode      = \"%s\"\n", mode_str[vseg[vseg_id].mode]);
             fprintf( fpout, "                       psegname  = \"%s\"\n",      pseg[pseg_id].name);
-            fprintf( fpout, "                       ident     = \"%d\" >\n", vseg[vseg_id].ident);
+            fprintf( fpout, "                       ident     = \"%d\" >\n",    vseg[vseg_id].ident);
 
             for ( vobj_id = vseg[vseg_id].vobj_offset ;
-                  vobj_id < (vseg[vseg_id].vobj_offset + vseg[vseg_id].vobjs) ; vobj_id++ )
+                  vobj_id < (vseg[vseg_id].vobj_offset + vseg[vseg_id].vobjs) ; 
+                  vobj_id++ )
             {
-                fprintf( fpout, "\t                 <vobj name     = \"%s\"\n",     vobj[vobj_id].name);
-                fprintf( fpout, "\t                       type     = \"%s\" \n", vobj_type[vobj[vobj_id].type]);
-                if(vobj[vobj_id].length)
-                    fprintf( fpout, "\t                       length   = \"0x%x\" \n",   vobj[vobj_id].length);
-                if(vobj[vobj_id].align)
-                    fprintf( fpout, "\t                       align    = \"%d\" \n",   vobj[vobj_id].align);
-                if(vobj[vobj_id].binpath[0]!='\0')
-                    fprintf( fpout, "\t                       binpath  = \"%s\" \n",   vobj[vobj_id].binpath);
-                fprintf( fpout, "\t                       />\n");
+                fprintf( fpout, "                       <vobj name     = \"%s\"\n",    vobj[vobj_id].name);
+                fprintf( fpout, "                             type     = \"%s\" \n",   vobj_type[vobj[vobj_id].type]);
+                fprintf( fpout, "                             length   = \"0x%x\" \n", vobj[vobj_id].length);
+                fprintf( fpout, "                             align    = \"%d\" \n",   vobj[vobj_id].align);
+                fprintf( fpout, "                             init     = \"%d\" \n",   vobj[vobj_id].init);
+                fprintf( fpout, "                             binpath  = \"%s\" />\n", vobj[vobj_id].binpath);
             }
-            fprintf( fpout, "\t\t        </vseg>\n\n");
+            fprintf( fpout, "                 </vseg>\n\n");
         }
         for ( task_id = vspace[vspace_id].task_offset ;
-              task_id < (vspace[vspace_id].task_offset + vspace[vspace_id].tasks) ; task_id++ )
+              task_id < (vspace[vspace_id].task_offset + vspace[vspace_id].tasks) ; 
+              task_id++ )
         {
             unsigned int vobj_id = task[task_id].vobjlocid + vspace[vspace_id].vobj_offset; 
@@ -212 +208 @@
             fprintf( fpout, "                       stackname = \"%s\"\n",      vobj[vobj_id].name);
             fprintf( fpout, "                       startid   = \"%d\"\n",      task[task_id].startid);
-            fprintf( fpout, "                       ttylocid  = \"%d\" />\n\n", task[task_id].ttylocid);
+            fprintf( fpout, "                       usetty    = \"%d\"\n",      task[task_id].use_tty);
+            fprintf( fpout, "                       usefb     = \"%d\" />\n\n", task[task_id].use_fb);
         }
-        fprintf( fpout, "        </vspace>\n");
+        fprintf( fpout, "        </vspace>\n\n");
     }
     fprintf( fpout, "    </vspaceset>\n" );

soft/giet_vm/xml/xml_parser.c

@@ -52 +52 @@
 unsigned int            vobj_index     = 0;
 unsigned int            vobj_loc_index = 0;
-unsigned int            vobj_loc_vspace_index = 0;
+unsigned int            vobj_count     = 0;
+
+unsigned int            tty_index      = 1;
+unsigned int            fb_index       = 0;
             
-char one_elf_found = 0;//bool: wether a first vobj of type elf was found
-
 //////////////////////////////////////////////////
 unsigned int getIntValue( xmlTextReaderPtr reader, 
@@ -144 +145 @@
     unsigned int vobj_id;
     unsigned int vobj_min = vspace[vspace_id]->vobj_offset;
-    unsigned int vobj_max = vobj_min + vobj_loc_vspace_index;
+    unsigned int vobj_max = vobj_min + vobj_loc_index;
 
     for ( vobj_id = vobj_min ; vobj_id < vobj_max ; vobj_id++ )
@@ -199 +200 @@
 printf("      clusterid = %x\n", value);
 #endif
+        if ( value >= header->clusters )
+        {
+            printf("[XML ERROR] <clusterid> too large for task (%d,%d)\n",
+                   vspace_index, task_loc_index);
+            exit(1);
+        }
         task[task_index]->clusterid = value;
     }  
@@ -215 +222 @@
 printf("      proclocid = %x\n", value);
 #endif
+        if ( value >= cluster[task[task_index]->clusterid]->procs )
+        {
+            printf("[XML ERROR] <proclocid> too large for task (%d,%d)\n",
+                   vspace_index, task_loc_index);
+            exit(1);
+        }
         task[task_index]->proclocid = value;
     }  
@@ -233 +246 @@
 #if XML_PARSER_DEBUG
 printf("      stackname = %s\n", str);
-printf("      vsegid    = %d\n", index);
+printf("      stackid   = %d\n", index);
 #endif
             task[task_index]->vobjlocid = index;
@@ -239 +252 @@
         else              
         {
-            printf("[XML ERROR] illegal or missing <psegname> for vseg %d\n", 
-                     vseg_loc_index);
+            printf("[XML ERROR] illegal or missing <stackname> for task (%d,%d)\n", 
+                    vspace_index, task_loc_index);
             exit(1);
         }
@@ -246 +259 @@
     else
     {
-        printf("[XML ERROR] illegal or missing <vsegname> for task (%d,%d)\n", 
+        printf("[XML ERROR] illegal or missing <stackname> for task (%d,%d)\n", 
                 vspace_index, task_loc_index);
         exit(1);
@@ -267 +280 @@
     }
 
-    /////////// get ttylocid  attribute
-    value = getIntValue(reader,"ttylocid", &ok);
-    if ( ok )
-    {
-#if XML_PARSER_DEBUG
-printf("      ttylocid = %x\n", value);
-#endif
-        if ( value >= vspace[vspace_index]->ttys )
-        {
-            printf("[XML ERROR] The ttylocid value is too large for task (%d,%d)\n", 
+    /////////// get use_tty  attribute (optionnal : 0 if missing)
+    value = getIntValue(reader,"usetty", &ok);
+    if ( ok )
+    {
+#if XML_PARSER_DEBUG
+printf("      usetty = %x\n", value);
+#endif
+        if ( (value != 0) && (tty_index >= header->ttys) )
+        {
+            printf("[XML ERROR] The tty index is too large for task (%d,%d)\n", 
                 vspace_index, task_loc_index);
             exit(1);
         }
-        task[task_index]->ttylocid = value;
+        task[task_index]->use_tty = value;
+        if (value != 0) tty_index++;
     }  
     else
     {
-        printf("[XML ERROR] illegal or missing <ttylocid> attribute for task (%d,%d)\n", 
+        task[task_index]->use_tty = 0;
+    }
+
+    /////////// get use_fb  attribute (optionnal : 0 if missing)
+    value = getIntValue(reader,"usefb", &ok);
+    if ( ok )
+    {
+#if XML_PARSER_DEBUG
+printf("      usefb = %x\n", value);
+#endif
+        if ( (value != 0) && (fb_index >= header->fbs) )
+        {
+            printf("[XML ERROR] The fb channel index is too large for task (%d,%d)\n", 
                 vspace_index, task_loc_index);
-        exit(1);
+            exit(1);
+        }
+        task[task_index]->use_fb = value;
+        if (value != 0) fb_index++;
+    }  
+    else
+    {
+        task[task_index]->use_fb = 0;
     }
 
@@ -293 +326 @@
 } // end taskNode()
 
+//////////////////////////////////////////
 void  vobjNode ( xmlTextReaderPtr reader )
 {
@@ -307 +341 @@
     }
 
-    if(one_elf_found != 0)
-    {
-        printf("[XML ERROR] a vobj of the type ELF must be defined alone in a vseg (%d,%d)\n", 
-                vspace_index, vobj_loc_vspace_index);
-        exit(1);
-
-    }
-
-#if XML_PARSER_DEBUG
-printf("    vobj %d\n", vobj_loc_index);
+#if XML_PARSER_DEBUG
+printf("      vobj %d\n", vobj_loc_index);
 #endif
 
@@ -326 +352 @@
     {
 #if XML_PARSER_DEBUG
-printf("      name = %s\n", str);
+printf("        name = %s\n", str);
 #endif
         strncpy( vobj[vobj_index]->name, str, 31);
@@ -337 +363 @@
     }
 
-
-    // get type attribute
+    //////// get type attribute
     str = getStringValue(reader, "type", &ok);
 #if XML_PARSER_DEBUG
-printf("      type = %s\n", str);
-#endif
-    if (ok && (strcmp(str, "ELF") == 0)){
-        vobj[vobj_index]->type = ELF;
-        one_elf_found = 1;
-        if(vobj_loc_index != 0) //check that this vobj is the first
-        {
-            printf("[XML ERROR] a vobj of the type ELF must be defined alone in a vobj (%d,%d)\n", 
-                    vspace_index, vobj_loc_vspace_index);
-            exit(1);
-
-        }
-    }
-    else if (ok && (strcmp(str, "PTAB") == 0)) vobj[vobj_index]->type = PTAB;
-    else if (ok && (strcmp(str, "PERI") == 0)) vobj[vobj_index]->type = PERI;
-    else if (ok && (strcmp(str, "MWMR") == 0)) vobj[vobj_index]->type = MWMR;
-    else if (ok && (strcmp(str, "LOCK") == 0)) vobj[vobj_index]->type = LOCK;
-    else if (ok && (strcmp(str, "BUFFER") == 0)) vobj[vobj_index]->type = BUFFER;
-    else if (ok && (strcmp(str, "BARRIER") == 0)) vobj[vobj_index]->type = BARRIER;
+printf("        type = %s\n", str);
+#endif
+    if (ok && (strcmp(str, "ELF") == 0))
+    {
+        vobj[vobj_index]->type = VOBJ_TYPE_ELF;
+
+        //check that this vobj is the first in vseg
+        if(vobj_count != 0) 
+        {
+            printf("[XML ERROR] an ELF vobj must be alone in a vseg (%d,%d)\n", 
+                    vspace_index, vobj_loc_index);
+            exit(1);
+        }
+    }
+    else if (ok && (strcmp(str, "PTAB")    == 0)) vobj[vobj_index]->type = VOBJ_TYPE_PTAB;
+    else if (ok && (strcmp(str, "PERI")    == 0)) vobj[vobj_index]->type = VOBJ_TYPE_PERI;
+    else if (ok && (strcmp(str, "MWMR")    == 0)) vobj[vobj_index]->type = VOBJ_TYPE_MWMR;
+    else if (ok && (strcmp(str, "LOCK")    == 0)) vobj[vobj_index]->type = VOBJ_TYPE_LOCK;
+    else if (ok && (strcmp(str, "BUFFER")  == 0)) vobj[vobj_index]->type = VOBJ_TYPE_BUFFER;
+    else if (ok && (strcmp(str, "BARRIER") == 0)) vobj[vobj_index]->type = VOBJ_TYPE_BARRIER;
     else
     {
         printf("[XML ERROR] illegal or missing <type> attribute for vobj (%d,%d)\n", 
-                vspace_index, vobj_loc_vspace_index);
-        exit(1);
-    }
-
-
-    ////////// get length attribute (0 if missing)
+                vspace_index, vobj_loc_index);
+        exit(1);
+    }
+
+    ////////// get length attribute 
     value = getIntValue(reader,"length", &ok);
     if ( ok )
     {
 #if XML_PARSER_DEBUG
-printf("      length = %d\n", value);
+printf("        length = %d\n", value);
 #endif
         vobj[vobj_index]->length = value;
@@ -379 +404 @@
     else
     {
-        vobj[vobj_index]->length = 0;
-    }
-
-    ////////// get align attribute (0 if missing)
+        printf("[XML ERROR] illegal or missing <length> attribute for vobj (%d,%d)\n", 
+                vspace_index, vobj_loc_index);
+        exit(1);
+    }
+
+    ////////// get align attribute (optional : 0 if missing)
     value = getIntValue(reader,"align", &ok);
     if ( ok )
     {
 #if XML_PARSER_DEBUG
-printf("      align = %d\n", value);
+printf("        align = %d\n", value);
 #endif
         vobj[vobj_index]->align = value;
@@ -396 +423 @@
     }
 
-    ////////// get binpath attribute ('\0' if missing)
+    ////////// get binpath attribute (optional : '\0' if missing)
     str = getStringValue(reader, "binpath", &ok);
     if ( ok )
     {
 #if XML_PARSER_DEBUG
-printf("      binpath = %s\n", str);
+printf("        binpath = %s\n", str);
 #endif
         strncpy(vobj[vobj_index]->binpath, str, 63);
@@ -410 +437 @@
     }
     
+    ////////// get init attribute (optional : 0 if missing)
+    value = getIntValue(reader,"init", &ok);
+    if ( ok )
+    {
+#if XML_PARSER_DEBUG
+printf("        init  = %d\n", value);
+#endif
+        vobj[vobj_index]->init = value;
+    }  
+    else
+    {
+        vobj[vobj_index]->init = 0;
+    }
+
     vobj_index++;
+    vobj_count++;
     vobj_loc_index++;
-    vobj_loc_vspace_index++;
-}
-
-
-///////////////////////////////////////////////////////////////
+} // end vobjNode()
+
+//////////////////////////////////////////
 void  vsegNode ( xmlTextReaderPtr reader )
 {
@@ -422 +462 @@
     unsigned int        value;
     char*               str;
-        vobj_loc_index = 0;
-        one_elf_found = 0;
+
+        vobj_count = 0;
 
     if ( xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT ) return;
@@ -442 +482 @@
     vseg[vseg_index]->vobj_offset = vobj_index;
 #if XML_PARSER_DEBUG
-printf("- vobj_offset = %d\n", vobj_index);
+printf("      vobj_offset = %d\n", vobj_index);
 #endif
 
@@ -477 +517 @@
     }
 
-
-    ////////// get ident attribute (0 if missing)
+    ////////// get ident attribute (optional : 0 if missing)
     value = getIntValue(reader,"ident", &ok);
     if ( ok )
@@ -492 +531 @@
     }
 
-
     ////////// get psegname attribute
     str = getStringValue(reader,"psegname", &ok);
@@ -520 +558 @@
     }
 
-    // get mode attribute
+    //////// get mode attribute
     str = getStringValue(reader,"mode", &ok);
 #if XML_PARSER_DEBUG
@@ -548 +586 @@
     }
     
-    
     ////////// set the length attribute to 0
-    //the final value will be set by the VLoader
     vseg[vseg_index]->length = value;
 
@@ -564 +600 @@
         {
             //  checking source file consistency?
-            vseg[vseg_index]->vobjs = vobj_loc_index;
+            vseg[vseg_index]->vobjs = vobj_count;
             vseg_index++;
             vseg_loc_index++;
@@ -576 +612 @@
         status = xmlTextReaderRead ( reader );
     }
-    
-
 } // end vsegNode()
 
@@ -585 +619 @@
     char*               str;
     unsigned int        ok;
-    unsigned int        value;
-    vobj_loc_vspace_index = 0;
+
+    vobj_loc_index = 0;
         vseg_loc_index = 0;
         task_loc_index = 0;
@@ -601 +635 @@
 
 #if XML_PARSER_DEBUG
-printf("  vspace %d\n", vspace_index);
+printf("\n  vspace %d\n", vspace_index);
 #endif
 
     vspace[vspace_index] = (mapping_vspace_t*)malloc(sizeof(mapping_vspace_t));
 
-    ////////// set vseg_offsetand task_offset attributes
+    ////////// get name attribute
+    str = getStringValue(reader, "name", &ok);
+    if ( ok )
+    {
+#if XML_PARSER_DEBUG
+printf("  name = %s\n", str);
+#endif
+        strncpy(vspace[vspace_index]->name, str, 31);
+    }
+    else
+    {
+        printf("[XML ERROR] illegal or missing <name> attribute for vspace %d\n", 
+                 vspace_index);
+        exit(1);
+    }
+
+    ////////// set vseg_offset and task_offset attributes
     vspace[vspace_index]->vseg_offset = vseg_index;
     vspace[vspace_index]->vobj_offset = vobj_index;
@@ -612 +662 @@
     
 #if XML_PARSER_DEBUG
-printf("- vseg_offset = %d\n", vseg_index);
-printf("- vobj_offset = %d\n", vobj_index);
-printf("- task_offset = %d\n", task_index);
-#endif
-
-    ////////// get name attribute
-    str = getStringValue(reader, "name", &ok);
-    if ( ok )
-    {
-#if XML_PARSER_DEBUG
-printf("    name = %s\n", str);
-#endif
-        strncpy(vspace[vspace_index]->name, str, 31);
-    }
-    else
-    {
-        printf("[XML ERROR] illegal or missing <name> attribute for vspace %d", 
+printf("  vseg_offset = %d\n", vseg_index);
+printf("  vobj_offset = %d\n", vobj_index);
+printf("  task_offset = %d\n", task_index);
+#endif
+
+    ////////// get startname attribute
+    str = getStringValue(reader, "startname", &ok);
+    if ( ok )
+    {
+        //used after parsing the vobjs
+    }
+    else
+    {
+        printf("[XML ERROR] illegal or missing <startname> attribute for vspace %d\n", 
                  vspace_index);
-        exit(1);
-    }
-
-    ////////// get funcs_entry attribute
-    str = getStringValue(reader, "funcs", &ok);
-    if ( ok )
-    {
-#if XML_PARSER_DEBUG
-printf("    name = %s\n", str);
-#endif
-        //used after parsing all the vobjs
-    }
-    else
-    {
-        printf("[XML ERROR] illegal or missing <name> attribute for vspace %d", 
-                 vspace_index);
-        exit(1);
-    }
-
-    // get ttys attribute
-    value = getIntValue(reader,"ttys", &ok);
-#if XML_PARSER_DEBUG
-printf("    ttys = %d\n", value);
-#endif
-    if ( ok )
-    {
-        vspace[vspace_index]->ttys = value;
-    }
-    else
-    {
-        printf("[XML ERROR] illegal or missing <ttys> attribute for vspace %d", 
-                  vspace_index);
         exit(1);
     }
@@ -675 +690 @@
         else if ( strcmp(tag,"vspace") == 0  ) 
         {
-            vspace[vspace_index]->vobjs = vobj_loc_vspace_index;
+            vspace[vspace_index]->vobjs = vobj_loc_index;
             vspace[vspace_index]->tasks = task_loc_index ;
             vspace[vspace_index]->vsegs = vseg_loc_index ;
+
+            // get index of the vobj containing the start vector
             int index =  getVobjLocId( vspace_index, str );
             if(index == -1)
             {
-                printf("Error funcs entry vobj not found %s\n",str);
+                printf("[XML ERROR] vobj containing the start vector not found %s\n",str);
                 exit(-1);
             }
-            vspace[vspace_index]->funcs_offset = index;
+            else
+            {
+                vspace[vspace_index]->start_offset = index;
+#if XML_PARSER_DEBUG
+printf("  startname = %s\n", str);
+printf("  startid   = %d\n", index);
+#endif
+            }
+
+            // checking startid values for all tasks in vspace
+            int task_id;
+            int task_min = vspace[vspace_index]->task_offset;
+            int task_max = task_min + vspace[vspace_index]->tasks; 
+            for ( task_id = task_min ; task_id < task_max ; task_id++ )
+            {
+                if ( task[task_id]->startid >= vspace[vspace_index]->tasks )
+                {
+                    printf("[XML ERROR] <startid> too large for task (%d,%d)\n", 
+                           vspace_index, task_id );
+                    exit(1);
+                }
+            }
 
             vspace_index++;
@@ -722 +760 @@
     str = getStringValue( reader, "name", &ok );
 #if XML_PARSER_DEBUG
-printf("  - name = %s\n", str);
+printf("    name = %s\n", str);
 #endif
     if ( ok ) 
@@ -737 +775 @@
     value = getIntValue( reader, "base", &ok );
 #if XML_PARSER_DEBUG
-printf("  - base = %x\n", value);
+printf("    base = %x\n", value);
 #endif
     if ( ok ) 
@@ -752 +790 @@
     value = getIntValue( reader, "length", &ok );
 #if XML_PARSER_DEBUG
-printf("  - length = %x\n\n", value);
+printf("    length = %x\n\n", value);
 #endif
     if ( ok )
@@ -789 +827 @@
     cluster[cluster_index] = (mapping_cluster_t*)malloc(sizeof(mapping_cluster_t));
 
+    // get index attribute (optional)
+    value = getIntValue(reader,"index",&ok);
+#if XML_PARSER_DEBUG
+printf("    index = %d\n", value);
+#endif
+    if ( ok && (value != cluster_index) )
+    {
+            printf("[XML ERROR] wrong cluster index / expected value is %d", 
+                cluster_index);
+            exit(1);
+    }
+
     // get procs attribute
     value = getIntValue(reader,"procs",&ok);
 #if XML_PARSER_DEBUG
-printf("  - procs = %d\n", value);
+printf("    procs = %d\n", value);
 #endif
     if ( ok )
@@ -805 +855 @@
     }
 
-    // get timers attribute
-    value = getIntValue(reader,"timers",&ok);
-#if XML_PARSER_DEBUG
-printf("  - timers = %d\n", value);
-#endif
-    if ( ok )
-    {
-        cluster[cluster_index]->timers = value;
-    }
-    else
-    {
-        printf("[XML ERROR] illegal or missing <timers> attribute for cluster %d", 
-                cluster_index);
-        exit(1);
-    }
-
-    // get dmas attribute
-    value = getIntValue(reader,"dmas",&ok);
-#if XML_PARSER_DEBUG
-printf("  - dmas = %d\n\n", value);
-#endif
-    if ( ok )
-    {
-        cluster[cluster_index]->dmas = value;
-    }
-    else
-    {
-        printf("[XML ERROR] illegal or missing <dmas> attribute for cluster %d", 
-                cluster_index);
-        exit(1);
-    }
-
     cluster_index++;
 } // end clusterNode()
@@ -846 +864 @@
 
 #if XML_PARSER_DEBUG
-printf("  clusters set\n");
+printf("\n  clusters set\n");
 #endif
 
@@ -922 +940 @@
 
 #if XML_PARSER_DEBUG
-printf("  global vsegs set\n");
+printf("  globals set\n");
 #endif
 
@@ -961 +979 @@
 
 #if XML_PARSER_DEBUG
-printf("  vspaces set\n");
+printf("\n  vspaces set\n");
 #endif
 
@@ -1011 +1029 @@
     header = (mapping_header_t*)malloc(sizeof(mapping_header_t));
 
-    // get name attribute
+    ////////// get name attribute
     name = getStringValue(reader, "name", &ok);
     if ( ok )
     {
 #if XML_PARSER_DEBUG
-printf("- name = %s\n", name);
+printf("  name = %s\n", name);
 #endif
         strncpy( header->name, name, 31);
@@ -1026 +1044 @@
     }
 
-    // get clusters attribute
+    /////////// get clusters attribute
     value = getIntValue(reader, "clusters", &ok);
     if ( ok )
@@ -1036 +1054 @@
         }
 #if XML_PARSER_DEBUG
-printf("- clusters = %d\n", value);
+printf("  clusters = %d\n", value);
 #endif
         header->clusters  = value;
@@ -1046 +1064 @@
     }
 
-    // get psegs attribute
+    ////////// get psegs attribute
     value = getIntValue(reader, "psegs", &ok);
     if ( ok )
@@ -1056 +1074 @@
         }
 #if XML_PARSER_DEBUG
-printf("- psegs = %d\n", value);
+printf("  psegs = %d\n", value);
 #endif
         header->psegs = value;
@@ -1066 +1084 @@
     }
 
-    // get ttys attribute
+    ///////// get ttys attribute
     value = getIntValue(reader, "ttys", &ok);
     if ( ok )
     {
 #if XML_PARSER_DEBUG
-printf("- ttys = %d\n", value);
+printf("  ttys = %d\n", value);
 #endif
         header->ttys  = value;
@@ -1081 +1099 @@
     }
 
-    // get vspaces attribute
+    ///////// get fbs attribute
+    value = getIntValue(reader, "fbs", &ok);
+    if ( ok )
+    {
+#if XML_PARSER_DEBUG
+printf("  fbs = %d\n", value);
+#endif
+        header->fbs  = value;
+    }
+    else
+    {
+        printf("[XML ERROR] illegal or missing <fbs> attribute in header\n");
+        exit(1);
+    }
+
+    ///////// get vspaces attribute
     value = getIntValue(reader, "vspaces", &ok);
     if ( ok )
@@ -1091 +1124 @@
         }
 #if XML_PARSER_DEBUG
-printf("- vspaces = %d\n", value);
+printf("  vspaces = %d\n", value);
 #endif
         header->vspaces  = value;
@@ -1101 +1134 @@
     }
 
-    // get globals attribute
+    ////////// get globals attribute
     value = getIntValue(reader, "globals", &ok);
     if ( ok )
@@ -1111 +1144 @@
         }
 #if XML_PARSER_DEBUG
-printf("- globals = %d\n", value);
+printf("  globals = %d\n", value);
 #endif
         header->globals  = value;