Index: /soft/giet_vm/giet_libs/barrier.c
===================================================================
--- /soft/giet_vm/giet_libs/barrier.c	(revision 486)
+++ /soft/giet_vm/giet_libs/barrier.c	(revision 487)
@@ -98,5 +98,6 @@
 ////////////////////////////////////////////////////
 void sbt_barrier_init( giet_sbt_barrier_t*  barrier,
-                       unsigned int         ntasks )
+                       unsigned int         nclusters,    // number of clusters
+                       unsigned int         ntasks )      // tasks per clusters
 {
     unsigned int x;          // x coordinate for one SBT node
@@ -107,7 +108,6 @@
     unsigned int levels;     // depth of the SBT (number of levels)
 
-
     // compute SBT characteristics
-    if      ( ntasks == NB_PROCS_MAX       )  // mesh 1*1
+    if      ( nclusters == 1 )  // mesh 1*1
     {
         x_size    = 1;
@@ -115,5 +115,5 @@
         levels    = 1;
     }
-    else if ( ntasks == NB_PROCS_MAX * 2   )  // mesh 2*1
+    else if ( nclusters == 2 )  // mesh 2*1
     {
         x_size    = 2;
@@ -121,5 +121,5 @@
         levels    = 2;
     }
-    else if ( ntasks == NB_PROCS_MAX * 4   )  // mesh 2*2
+    else if ( nclusters == 4 )  // mesh 2*2
     {
         x_size    = 2;
@@ -127,5 +127,5 @@
         levels    = 3;
     }
-    else if ( ntasks == NB_PROCS_MAX * 8   )  // mesh 4*2
+    else if ( nclusters == 8 )  // mesh 4*2
     {
         x_size    = 4;
@@ -133,5 +133,5 @@
         levels    = 4;
     }
-    else if ( ntasks == NB_PROCS_MAX * 16  )  // mesh 4*4
+    else if ( nclusters == 16 )  // mesh 4*4
     {
         x_size    = 4;
@@ -139,5 +139,5 @@
         levels    = 5;
     }
-    else if ( ntasks == NB_PROCS_MAX * 32  )  // mesh 8*4
+    else if ( nclusters == 32 )  // mesh 8*4
     {
         x_size    = 8;
@@ -145,5 +145,5 @@
         levels    = 6;
     }
-    else if ( ntasks == NB_PROCS_MAX * 64  )  // mesh 8*8
+    else if ( nclusters == 64 )  // mesh 8*8
     {
         x_size    = 8;
@@ -151,5 +151,5 @@
         levels    = 7;
     }
-    else if ( ntasks == NB_PROCS_MAX * 128 )  // mesh 16*8
+    else if ( nclusters == 128 )  // mesh 16*8
     {
         x_size    = 16;
@@ -157,5 +157,5 @@
         levels    = 8; 
     }
-    else if ( ntasks == NB_PROCS_MAX * 256 )  // mesh 16*16
+    else if ( nclusters == 256 )  // mesh 16*16
     {
         x_size    = 16;
@@ -168,9 +168,9 @@
         y_size    = 0;
         levels    = 0;
-        giet_exit("error in tree_barrier_init() : number of tasks must be power of 2\n");
+        giet_exit("error in tree_barrier_init() : nclusters must be power of 2\n");
     }
 
     // ntasks initialisation
-    barrier->ntasks = ntasks;
+    barrier->ntasks = ntasks * nclusters;
     
 #if GIET_DEBUG_USER_BARRIER
@@ -214,5 +214,5 @@
 
     // recursively initialize all SBT nodes from root to bottom
-    sbt_build( barrier, 0, 0, levels-1, NULL );
+    sbt_build( barrier, 0, 0, levels-1, NULL, ntasks );
 
     asm volatile ("sync" ::: "memory");
@@ -240,5 +240,6 @@
                 unsigned int         y,
                 unsigned int         level,
-                sbt_node_t*          parent ) 
+                sbt_node_t*          parent,
+                unsigned int         ntasks ) 
 {
     // This recursive function initializes the SBT notes
@@ -251,6 +252,6 @@
     {
         // initializes target node
-        node->arity    = NB_PROCS_MAX;   
-        node->count    = NB_PROCS_MAX;   
+        node->arity    = ntasks;   
+        node->count    = ntasks;   
         node->sense    = 0;   
         node->level    = 0;   
@@ -308,6 +309,6 @@
 
         // recursive calls for children nodes
-        sbt_build( barrier , x0 , y0 , level-1 , node );
-        sbt_build( barrier , x1 , y1 , level-1 , node );
+        sbt_build( barrier , x0 , y0 , level-1 , node , ntasks );
+        sbt_build( barrier , x1 , y1 , level-1 , node , ntasks );
     }
 
Index: /soft/giet_vm/giet_libs/barrier.h
===================================================================
--- /soft/giet_vm/giet_libs/barrier.h	(revision 486)
+++ /soft/giet_vm/giet_libs/barrier.h	(revision 487)
@@ -18,6 +18,6 @@
 //    and is implemented as a physically distributed Sliced-Binary-Tree (SBT).
 //    WARNING: The following placement constraints must be respected:
-//    - The number of tasks must be a power of 2.
-//    - There is one task per processor in a given cluster.
+//    - The number of involved clusters must be a power of 2.
+//    - The number of involved tasks in a cluster is the same in all clusters.
 //    - The involved clusters form a mesh[N][N] or a mesh[N][N/2]
 //    - The lower left involved cluster is cluster(0,0)  
@@ -81,4 +81,5 @@
 ///////////////////////////////////////////////////////////
 extern void sbt_barrier_init( giet_sbt_barrier_t*  barrier,
+                              unsigned int         nclusters,
                               unsigned int         ntasks );   
 
@@ -91,5 +92,6 @@
                 unsigned int         y,
                 unsigned int         level, 
-                sbt_node_t*          parent );
+                sbt_node_t*          parent,
+                unsigned int         ntasks );
 
 ///////////////////////////////////////
Index: /soft/giet_vm/giet_libs/stdio.c
===================================================================
--- /soft/giet_vm/giet_libs/stdio.c	(revision 486)
+++ /soft/giet_vm/giet_libs/stdio.c	(revision 487)
@@ -541,17 +541,17 @@
 //////////////////////////////////////////////////////////////////////////////////
 
-////////////////////////
-int giet_nic_rx_alloc()
+////////////////////////////////
+unsigned int giet_nic_rx_alloc()
 {
     int channel = sys_call( SYSCALL_NIC_ALLOC,
                             1, 
                             0, 0, 0 );
-    if ( channel < 0 ) giet_exit("error in giet_nic_tx_alloc()");
-
-    return channel;
-}
-
-///////////////////////
-int giet_nic_tx_alloc()
+    if ( channel < 0 ) giet_exit("error in giet_nic_rx_alloc()");
+
+    return (unsigned int)channel;
+}
+
+////////////////////////////////
+unsigned int giet_nic_tx_alloc()
 {
     int channel = sys_call( SYSCALL_NIC_ALLOC,
@@ -560,21 +560,23 @@
     if ( channel < 0 ) giet_exit("error in giet_nic_tx_alloc()");
 
-    return channel;
-}
-
-////////////////////////
-void giet_nic_rx_start()
+    return (unsigned int)channel;
+}
+
+//////////////////////////////////////////////
+void giet_nic_rx_start( unsigned int channel )
 {
     if ( sys_call( SYSCALL_NIC_START,
                    1,
-                   0, 0, 0 ) ) giet_exit("error in giet_nic_rx_start()");
-}
-
-////////////////////////
-void giet_nic_tx_start()
+                   channel,
+                   0, 0 ) ) giet_exit("error in giet_nic_rx_start()");
+}
+
+//////////////////////////////////////////////
+void giet_nic_tx_start( unsigned int channel )
 {
     if ( sys_call( SYSCALL_NIC_START,
                    0, 
-                   0, 0, 0 ) ) giet_exit("error in giet_nic_tx_start()");
+                   channel,
+                   0, 0 ) ) giet_exit("error in giet_nic_tx_start()");
 }
 
@@ -599,50 +601,56 @@
 }
 
-///////////////////////
-void giet_nic_rx_stop()
+/////////////////////////////////////////////
+void giet_nic_rx_stop( unsigned int channel )
 {
     if ( sys_call( SYSCALL_NIC_STOP,
                    1, 
-                   0, 0, 0 ) ) giet_exit("error in giet_nic_rx_stop()");
-}
-
-///////////////////////
-void giet_nic_tx_stop()
+                   channel,
+                   0, 0 ) ) giet_exit("error in giet_nic_rx_stop()");
+}
+
+/////////////////////////////////////////////
+void giet_nic_tx_stop( unsigned int channel )
 {
     if ( sys_call( SYSCALL_NIC_STOP,
                    0, 
-                   0, 0, 0 ) ) giet_exit("error in giet_nic_tx_stop()");
-}
-
-////////////////////////
-void giet_nic_rx_stats()
+                   channel,
+                   0, 0 ) ) giet_exit("error in giet_nic_tx_stop()");
+}
+
+//////////////////////////////////////////////
+void giet_nic_rx_stats( unsigned int channel )
 {
     if ( sys_call( SYSCALL_NIC_STATS,
                    1, 
-                   0, 0, 0 ) ) giet_exit("error in giet_nic_rx_stats()");
-}
-
-////////////////////////
-void giet_nic_tx_stats()
+                   channel,
+                   0, 0 ) ) giet_exit("error in giet_nic_rx_stats()");
+}
+
+//////////////////////////////////////////////
+void giet_nic_tx_stats( unsigned int channel )
 {
     if ( sys_call( SYSCALL_NIC_STATS,
                    0, 
-                   0, 0, 0 ) ) giet_exit("error in giet_nic_tx_stats()");
-}
-
-////////////////////////
-void giet_nic_rx_clear()
+                   channel,
+                   0, 0 ) ) giet_exit("error in giet_nic_tx_stats()");
+}
+
+//////////////////////////////////////////////
+void giet_nic_rx_clear( unsigned int channel )
 {
     if ( sys_call( SYSCALL_NIC_CLEAR,
                    1, 
-                   0, 0, 0 ) ) giet_exit("error in giet_nic_rx_clear()");
-}
-
-////////////////////////
-void giet_nic_tx_clear()
+                   channel,
+                   0, 0 ) ) giet_exit("error in giet_nic_rx_clear()");
+}
+
+//////////////////////////////////////////////
+void giet_nic_tx_clear( unsigned int channel )
 {
     if ( sys_call( SYSCALL_NIC_CLEAR,
                    0, 
-                   0, 0, 0 ) ) giet_exit("error in giet_nic_tx_clear()");
+                   channel,
+                   0, 0 ) ) giet_exit("error in giet_nic_tx_clear()");
 }
 
Index: /soft/giet_vm/giet_libs/stdio.h
===================================================================
--- /soft/giet_vm/giet_libs/stdio.h	(revision 486)
+++ /soft/giet_vm/giet_libs/stdio.h	(revision 487)
@@ -212,11 +212,11 @@
 //////////////////////////////////////////////////////////////////////////
 
-extern int giet_nic_rx_alloc();
-
-extern int giet_nic_tx_alloc();
-
-extern void giet_nic_rx_start();
-
-extern void giet_nic_tx_start();
+extern unsigned int giet_nic_rx_alloc();
+
+extern unsigned int giet_nic_tx_alloc();
+
+extern void giet_nic_rx_start( unsigned int channel );
+
+extern void giet_nic_tx_start( unsigned int channel );
 
 extern void giet_nic_rx_move( unsigned int channel, void* buffer );
@@ -224,15 +224,15 @@
 extern void giet_nic_tx_move( unsigned int channel, void* buffer );
 
-extern void giet_nic_rx_stop();
-
-extern void giet_nic_tx_stop();
-
-extern void giet_nic_rx_stats();
-
-extern void giet_nic_tx_stats();
-
-extern void giet_nic_rx_clear();
-
-extern void giet_nic_tx_clear();
+extern void giet_nic_rx_stop( unsigned int channel );
+
+extern void giet_nic_tx_stop( unsigned int channel );
+
+extern void giet_nic_rx_stats( unsigned int channel );
+
+extern void giet_nic_tx_stats( unsigned int channel );
+
+extern void giet_nic_rx_clear( unsigned int channel );
+
+extern void giet_nic_tx_clear( unsigned int channel );
 
 //////////////////////////////////////////////////////////////////////////