Index: soft/giet_vm/giet_common/utils.c
===================================================================
--- soft/giet_vm/giet_common/utils.c	(revision 433)
+++ soft/giet_vm/giet_common/utils.c	(revision 442)
@@ -11,11 +11,10 @@
 ///////////////////////////////////////////////////////////////////////////////////
 
+#include <utils.h>
 #include <giet_config.h>
 #include <hard_config.h>
 #include <mapping_info.h>
-#include <utils.h>
+#include <tty_driver.h>
 #include <ctx_handler.h>
-#include <tty_driver.h>
-#include <stdarg.h>
 
 // This global variable is allocated in the boot.c file or in kernel_init.c file
@@ -172,5 +171,5 @@
 ////////////////////////////////////////////////////////////////////////////
 
-////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////
 unsigned int _physical_read( unsigned long long paddr ) 
 {
@@ -198,5 +197,5 @@
     return value;
 }
-////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////
 void _physical_write( unsigned long long paddr, 
                       unsigned int       value ) 
@@ -225,5 +224,5 @@
 }
 
-////////////////////////////////////////////////////////////////////////////
+/////////////////////////////////////////////////////////////////
 unsigned long long _physical_read_ull( unsigned long long paddr ) 
 {
@@ -256,5 +255,5 @@
 }
 
-////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////
 void _physical_write_ull( unsigned long long paddr, 
                           unsigned long long value ) 
@@ -286,10 +285,5 @@
 }
 
-///////////////////////////////////////////////////////////////////////////////////
-// This function makes a memcpy from a source buffer to a destination buffer
-// using physical addresses, after a temporary DTLB de-activation.
-// source and destination buffers must be word aligned, and size must be
-// multiple of 4 bytes. 
-///////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////
 void _physical_memcpy( unsigned long long dst_paddr,  // destination buffer paddr
                        unsigned long long src_paddr,  // source buffer paddr
@@ -299,5 +293,5 @@
     if ( (dst_paddr & 3) || (src_paddr & 3) || (size & 3) ) 
     {
-        _printf("\n[GIET ERROR] in _physical_memcpy() : buffer unaligned\n");
+        _puts("\n[GIET ERROR] in _physical_memcpy() : buffer unaligned\n");
         _exit();
     }
@@ -342,5 +336,5 @@
 } // end _physical_memcpy()
 
-/////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////
 void _physical_memset( unsigned long long paddr,     // destination buffer paddr
                        unsigned int       size,      // bytes
@@ -350,5 +344,5 @@
     if ( (paddr & 3) || (size & 7) )
     {
-        _printf("\n[GIET ERROR] in _physical_memset() : buffer unaligned\n");
+        _puts("\n[GIET ERROR] in _physical_memset() : buffer unaligned\n");
         _exit();
     }
@@ -381,5 +375,5 @@
 }  // _physical_memset()
 
-///////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////
 void _io_extended_write( unsigned int*  vaddr,
                          unsigned int   value )
@@ -400,5 +394,5 @@
 }
 
-///////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////
 unsigned int _io_extended_read( unsigned int*  vaddr )
 {
@@ -418,9 +412,9 @@
 
 ///////////////////////////////////////////////////////////////////////////////////
-//     Locks access functions
-///////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////
-void _get_lock(giet_lock_t* lock) 
+//                      Locks access functions
+///////////////////////////////////////////////////////////////////////////////////
+
+///////////////////////////////////
+void _get_lock( giet_lock_t* lock ) 
 {
     register unsigned int* plock = &(lock->value);
@@ -470,6 +464,6 @@
 }
 
-///////////////////////////////////////////////////////////////////////////////////
-void _release_lock(giet_lock_t* lock) 
+///////////////////////////////////////
+void _release_lock( giet_lock_t* lock ) 
 {
     asm volatile ( "sync\n" ::: "memory" ); 
@@ -479,13 +473,8 @@
 
 ///////////////////////////////////////////////////////////////////////////////////
-//           Access functions to system terminal TTY0
-///////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////
-// Display "string" argument on TTY0.
-// It uses the low level access functions from TTY driver, using a busy waiting
-// policy if TTY buffer is full.
-// The exclusive access lock should be taken by the caller.
-///////////////////////////////////////////////////////////////////////////////////
+//           Access functions to kernel terminal TTY0
+///////////////////////////////////////////////////////////////////////////////////
+
+//////////////////////////
 void _puts( char* string ) 
 {
@@ -506,7 +495,5 @@
 }
 
-///////////////////////////////////////////////////////////////////////////////////
-// Display a 32 bits unsigned int as an hexadecimal string on TTY0.
-///////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////
 void _putx( unsigned int val )
 {
@@ -527,7 +514,5 @@
 }
 
-///////////////////////////////////////////////////////////////////////////////////
-// Display a 64 bits unsigned long as an hexadecimal string on TTY0.
-///////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////
 void _putl( unsigned long long val )
 {
@@ -548,7 +533,5 @@
 }
 
-///////////////////////////////////////////////////////////////////////////////////
-// Display a 32 bits unsigned int as a decimal string on TTY0.
-///////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////
 void _putd( unsigned int val ) 
 {
@@ -576,170 +559,6 @@
 }
 
-///////////////////////////////////////////////////////////////////////////////////
-// Display a format on TTY0.
-// To provide an atomic display, this function takes the lock protecting
-// exclusive access to TTY0, entering a critical section until the lock
-// is released.
-// Only a limited number of formats are supported:
-//   - %d : 32 bits signed   decimal
-//   - %u : 32 bits unsigned decimal
-//   - %x : 32 bits unsigned hexa
-//   - %l : 64 bits unsigned hexa
-//   - %c : char
-//   - %s : string
-///////////////////////////////////////////////////////////////////////////////////
-void _printf( char * format, ... ) 
-{
-    va_list ap;
-    va_start(ap, format);
-    unsigned int save_sr;     // to save SR value in critical section
-
-    // get TTY0 lock
-    _tty_get_lock( 0, &save_sr );
-
-printf_text:
-
-    while (*format) 
-    {
-        unsigned int i;
-        for (i = 0 ; format[i] && (format[i] != '%') ; i++);
-        if (i) 
-        {
-            if ( _tty_write( format, i, 0 ) != i ) goto return_error;
-            format += i;
-        }
-        if (*format == '%') 
-        {
-            format++;
-            goto printf_arguments;
-        }
-    }
-
-    // release TTY0 lock
-    _tty_release_lock( 0, &save_sr );
-
-    va_end(ap);
-    return;
-
-printf_arguments:
-
-    {
-        char buf[20];
-        char * pbuf;
-        unsigned int len = 0;
-        static const char HexaTab[] = "0123456789ABCDEF";
-        unsigned int i;
-
-        switch (*format++) 
-        {
-            case ('c'):             /* char conversion */
-            {
-                int val = va_arg( ap, int );
-                len = 1;
-                buf[0] = val;
-                pbuf = &buf[0];
-                break;
-            }
-            case ('d'):             /* 32 bits decimal signed  */
-            {
-                int val = va_arg( ap, int );
-                if (val < 0) 
-                {
-                    val = -val;
-                    if ( _tty_write( "-" , 1, 0 ) != 1 ) goto return_error;
-                }
-                for(i = 0; i < 10; i++) 
-                {
-                    buf[9 - i] = HexaTab[val % 10];
-                    if (!(val /= 10)) break;
-                }
-                len =  i + 1;
-                pbuf = &buf[9 - i];
-                break;
-            }
-            case ('u'):             /* 32 bits decimal unsigned  */
-            {
-                unsigned int val = va_arg( ap, unsigned int );
-                for(i = 0; i < 10; i++) 
-                {
-                    buf[9 - i] = HexaTab[val % 10];
-                    if (!(val /= 10)) break;
-                }
-                len =  i + 1;
-                pbuf = &buf[9 - i];
-                break;
-            }
-            case ('x'):             /* 32 bits hexadecimal unsigned */
-            {
-                unsigned int val = va_arg( ap, unsigned int );
-                if ( _tty_write( "0x" , 2, 0 ) != 2 ) goto return_error;
-                for(i = 0; i < 8; i++) 
-                {
-                    buf[7 - i] = HexaTab[val % 16];
-                    if (!(val /= 16))  break;
-                }
-                len =  i + 1;
-                pbuf = &buf[7 - i];
-                break;
-            }
-            case ('l'):            /* 64 bits hexadecimal unsigned */
-            {
-                unsigned long long val = va_arg( ap, unsigned long long );
-                if ( _tty_write( "0x" , 2, 0 ) != 2 ) goto return_error;
-                for(i = 0; i < 16; i++) 
-                {
-                    buf[15 - i] = HexaTab[val % 16];
-                    if (!(val /= 16))  break;
-                }
-                len =  i + 1;
-                pbuf = &buf[15 - i];
-                break;
-            }
-            case ('s'):             /* string */
-            {
-                char* str = va_arg( ap, char* );
-                while (str[len]) 
-                {
-                    len++;
-                }
-                pbuf = str;
-                break;
-            }
-            default:
-                goto return_error;
-        }
-
-        if ( _tty_write( pbuf, len, 0 ) != len ) goto return_error;
-        
-        goto printf_text;
-    }
-
-return_error:
-
-    {
-        unsigned int procid     = _get_procid();
-        unsigned int x          = (procid >> (Y_WIDTH + P_WIDTH)) & ((1<<X_WIDTH)-1);
-        unsigned int y          = (procid >> P_WIDTH) & ((1<<Y_WIDTH)-1);
-        unsigned int lpid       = procid & ((1<<P_WIDTH)-1);
-
-        _puts("\n\n[GIET ERROR] in _printf() for processor[");
-        _putd( x );
-        _puts(",");
-        _putd( y );
-        _puts(",");
-        _putd( lpid );
-        _puts("]\n");
-
-        // release TTY0 lock
-        _tty_release_lock( 0, &save_sr );
-
-        _exit();
-    }
-}
-
-///////////////////////////////////////////////////////////////////////////////////
-// Get a character from TTY0.
-///////////////////////////////////////////////////////////////////////////////////
-void _getc( char*        byte )
+/////////////////////////
+void _getc( char*  byte )
 {
     // test status register
@@ -756,5 +575,5 @@
 
 
-////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////
 unsigned int _get_current_task_id() 
 {
@@ -762,5 +581,6 @@
     return (unsigned int) (psched->current);
 }
-////////////////////////////////////////////////////////////////////////////////////
+
+////////////////////////////////////////////
 unsigned int _get_task_slot( unsigned int x,
                              unsigned int y,
@@ -772,5 +592,6 @@
     return psched->context[ltid][slot];
 }
-////////////////////////////////////////////////////////////////////////////////////
+
+////////////////////////////////////
 void _set_task_slot( unsigned int x,
                      unsigned int y,
@@ -783,5 +604,6 @@
     psched->context[ltid][slot] = value;
 }
-////////////////////////////////////////////////////////////////////////////////////
+
+///////////////////////////////////////////////////
 unsigned int _get_context_slot( unsigned int slot )
 {
@@ -790,5 +612,6 @@
     return psched->context[task_id][slot];
 }
-////////////////////////////////////////////////////////////////////////////////////
+
+///////////////////////////////////////////
 void _set_context_slot( unsigned int slot,
                        unsigned int value )
@@ -802,4 +625,6 @@
 //      Access functions to mapping_info data structure
 /////////////////////////////////////////////////////////////////////////////
+
+////////////////////////////////////////////////////////////////
 mapping_cluster_t * _get_cluster_base(mapping_header_t * header) 
 {
@@ -807,5 +632,5 @@
             MAPPING_HEADER_SIZE);
 }
-/////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////
 mapping_pseg_t * _get_pseg_base(mapping_header_t * header) 
 {
@@ -814,5 +639,5 @@
             MAPPING_CLUSTER_SIZE * X_SIZE * Y_SIZE);
 }
-/////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////
 mapping_vspace_t * _get_vspace_base(mapping_header_t * header) 
 {
@@ -822,5 +647,5 @@
             MAPPING_PSEG_SIZE * header->psegs);
 }
-/////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////
 mapping_vseg_t * _get_vseg_base(mapping_header_t * header)
 {
@@ -831,5 +656,5 @@
             MAPPING_VSPACE_SIZE * header->vspaces);
 }
-/////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////
 mapping_vobj_t * _get_vobj_base(mapping_header_t * header) 
 {
@@ -841,5 +666,5 @@
             MAPPING_VSEG_SIZE * header->vsegs );
 }
-/////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////
 mapping_task_t * _get_task_base(mapping_header_t * header) 
 {
@@ -852,5 +677,5 @@
             MAPPING_VSEG_SIZE * header->vsegs);
 }
-/////////////////////////////////////////////////////////////////////////////
+/////////////////////////////////////////////////////////
 mapping_proc_t *_get_proc_base(mapping_header_t * header) 
 {
@@ -864,5 +689,5 @@
             MAPPING_TASK_SIZE * header->tasks);
 }
-/////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////
 mapping_irq_t *_get_irq_base(mapping_header_t * header) 
 {
@@ -877,5 +702,5 @@
             MAPPING_PROC_SIZE * header->procs);
 }
-/////////////////////////////////////////////////////////////////////////////
+/////////////////////////////////////////////////////////////
 mapping_coproc_t *_get_coproc_base(mapping_header_t * header) 
 {
@@ -891,5 +716,5 @@
             MAPPING_IRQ_SIZE * header->irqs);
 }
-///////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////
 mapping_cp_port_t *_get_cp_port_base(mapping_header_t * header) 
 {
@@ -906,5 +731,5 @@
             MAPPING_COPROC_SIZE * header->coprocs);
 }
-///////////////////////////////////////////////////////////////////////////////////
+/////////////////////////////////////////////////////////////
 mapping_periph_t *_get_periph_base(mapping_header_t * header) 
 {
@@ -924,12 +749,30 @@
 
 ///////////////////////////////////////////////////////////////////////////////////
-// Miscelaneous functions
-///////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////
-// This function implements a pseudo-random delay.
-// The val argument define approximately an exponentially increasing mean delay,
-// and should not be larger than 32.
-///////////////////////////////////////////////////////////////////////////////////
+//             Miscelaneous functions
+///////////////////////////////////////////////////////////////////////////////////
+
+//////////////////////////////////////
+__attribute__((noreturn)) void _exit() 
+{
+    unsigned int procid     = _get_procid();
+    unsigned int x          = (procid >> (Y_WIDTH + P_WIDTH)) & ((1<<X_WIDTH)-1);
+    unsigned int y          = (procid >> P_WIDTH) & ((1<<Y_WIDTH)-1);
+    unsigned int lpid       = procid & ((1<<P_WIDTH)-1);
+
+
+    _puts("\n[GIET PANIC] processor[");
+    _putd( x );
+    _puts(",");
+    _putd( y );
+    _puts(",");
+    _putd( lpid );
+    _puts("] exit at cycle");
+    _putd( _get_proctime() );
+    _puts(" ...\n");
+
+    while (1) { asm volatile ("nop"); }
+}
+
+/////////////////////////////////////
 void _random_wait( unsigned int val )
 {
@@ -945,36 +788,17 @@
                   : "$3" ); 
 }
-//////////////////////////////////////////////////////////////////////////////////
-// This function implements an interactive break for debug.
-// Execution continue when typing any character on TTY0. 
-// The "str" argument is supposed to indicate the break location.
-//////////////////////////////////////////////////////////////////////////////////
+
+///////////////////////////
 void _break( char* string ) 
 {
     char byte;
 
-    _printf("\n[GIET DEBUG] break from %s / continue ?\n", string );
+    _puts("\n[GIET DEBUG] break from ");
+    _puts( string );
+    _puts(" / stoke any key to continue\n");
     _getc( &byte );
 }
 
-//////////////////////////////////////////////////////////////////////////////////
-// Processor suicide: infinite loop  
-//////////////////////////////////////////////////////////////////////////////////
-__attribute__((noreturn))
-void _exit() 
-{
-    unsigned int procid     = _get_procid();
-    unsigned int x          = (procid >> (Y_WIDTH + P_WIDTH)) & ((1<<X_WIDTH)-1);
-    unsigned int y          = (procid >> P_WIDTH) & ((1<<Y_WIDTH)-1);
-    unsigned int lpid       = procid & ((1<<P_WIDTH)-1);
-
-
-    _printf("\n[GIET PANIC] processor[%d,%d,%d] suicide...\n", x, y, lpid );
-
-    while (1) { asm volatile ("nop"); }
-}
-///////////////////////////////////////////////////////////////////////////////////
-// Compare two strings s1 & s2 (no more than n characters)
-///////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////
 unsigned int _strncmp( const char * s1, 
                        const char * s2, 
@@ -990,7 +814,5 @@
 }
 
-///////////////////////////////////////////////////////////////////////////////////
-// Copy source string to dest string
-///////////////////////////////////////////////////////////////////////////////////
+/////////////////////////////////////////
 char* _strcpy( char* dest, char* source )
 {
@@ -1003,8 +825,5 @@
 }
 
-///////////////////////////////////////////////////////////////////////////////////
-// Invalidate all data cache lines corresponding to a memory 
-// buffer (identified by virtual base address and size).
-///////////////////////////////////////////////////////////////////////////////////
+/////////////////////////////////////////////////////
 void _dcache_buf_invalidate( unsigned int buf_vbase, 
                              unsigned int buf_size ) 
@@ -1028,66 +847,5 @@
     }
 }
-///////////////////////////////////////////////////////////////////////////////////
-// This function returns the information associated to a heap : vaddr and length.
-// - If (x < X_SIZE) and (y < Y_SIZE), it return the heap associated to any task
-// running in cluster(x,y). 
-// - Else, it return the heap associated to the calling task.
-// It uses the global task index (CTX_GTID_ID, unique for each giet task) and the
-// vspace index (CTX_VSID_ID), that are defined in the calling task context
-// to find the vobj_id containing the heap. 
-// Return 0 if success. Return non zero if not found.
-///////////////////////////////////////////////////////////////////////////////////
-unsigned int _heap_info( unsigned int* vaddr, 
-                         unsigned int* length,
-                         unsigned int  x,
-                         unsigned int  y ) 
-{
-    mapping_header_t * header  = (mapping_header_t *)SEG_BOOT_MAPPING_BASE;
-    mapping_task_t *   tasks   = _get_task_base(header);
-    mapping_vobj_t *   vobjs   = _get_vobj_base(header);
-    mapping_vspace_t * vspaces = _get_vspace_base(header);
-
-    unsigned int task_id;
-    unsigned int vspace_id;
-    unsigned int vobj_id = 0xFFFFFFFF;
-
-    // searching the heap vobj_id
-    if ( (x < X_SIZE) && (y < Y_SIZE) )  // searching a task in cluster(x,y)
-    {
-        // get vspace global index
-        vspace_id = _get_context_slot(CTX_VSID_ID);
-
-        // scan all tasks in vspace
-        unsigned int min = vspaces[vspace_id].task_offset ;
-        unsigned int max = min + vspaces[vspace_id].tasks ;
-        for ( task_id = min ; task_id < max ; task_id++ )
-        {
-            if ( tasks[task_id].clusterid == (x * Y_SIZE + y) )
-            {
-                vobj_id = tasks[task_id].heap_vobj_id;
-                if ( vobj_id != 0xFFFFFFFF ) break;
-            }
-        }
-    }
-    else                                // searching in the calling task 
-    {
-        task_id = _get_context_slot(CTX_GTID_ID);
-        vobj_id = tasks[task_id].heap_vobj_id;
-    }
-
-    // analysing the vobj_id
-    if ( vobj_id != 0xFFFFFFFF ) 
-    {
-        *vaddr  = vobjs[vobj_id].vbase;
-        *length = vobjs[vobj_id].length;
-        return 0;
-    }
-    else 
-    {
-        *vaddr = 0;
-        *length = 0;
-        return 1;
-    }
-}  // end _heap_info()
+
 
 
@@ -1096,8 +854,5 @@
 ///////////////////////////////////////////////////////////////////////////////////
 
-///////////////////////////////////////////////////////////////////////////////////
-// Copy a source memory buffer content to a dest memory buffer (size bytes)
-// Code taken from MutekH.
-///////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////
 void* memcpy( void*        dest,     // dest buffer vbase
               const void*  source,   // source buffer vbase
@@ -1127,13 +882,12 @@
     return dest;
 }
-//////////////////////////////////////////////////////////////////////////////////
-// Fill a byte string with a byte value.
-//////////////////////////////////////////////////////////////////////////////////
-void * memset( void*        dest, 
-                      int          value, 
-                      unsigned int count ) 
+
+/////////////////////////////////
+void * memset( void*        dst, 
+               int          value, 
+               unsigned int count ) 
 {
     // word-by-word copy
-    unsigned int* idst = dest;
+    unsigned int* idst = dst;
     unsigned int  data = (((unsigned char)value)      ) |
                          (((unsigned char)value) <<  8) |
@@ -1151,10 +905,10 @@
    
     // byte-by-byte copy
-    unsigned char* cdst = dest;
+    unsigned char* cdst = dst;
     while (count--) 
     {
         *cdst++ = (unsigned char)value;
     }
-    return dest;
+    return dst;
 }
 
