Changeset 619 for trunk

Timestamp:

Feb 12, 2019, 1:15:47 PM (6 years ago)

Author:

alain

Message:

1) Fix a bug in KSH : after the "load" command,

the [ksh] prompt is now printed after completion
of the loaded application.

2) Fix a bug in vmm_handle_cow() : the copy-on-write

use now a hal_remote_memcpy() to replicate the page content.

Location:

trunk

Files:

• hal/generic/hal_exception.h (modified) (3 diffs)
• hal/generic/hal_remote.h (modified) (1 diff)
• hal/generic/hal_special.h (modified) (1 diff)
• hal/tsar_mips32/core/hal_exception.c (modified) (6 diffs)
• hal/tsar_mips32/core/hal_special.c (modified) (5 diffs)
• hal/tsar_mips32/drivers/soclib_tty.c (modified) (8 diffs)
• kernel/devices/dev_dma.c (modified) (1 diff)
• kernel/devices/dev_ioc.c (modified) (1 diff)
• kernel/devices/dev_nic.c (modified) (1 diff)
• kernel/devices/dev_txt.c (modified) (8 diffs)
• kernel/kern/chdev.c (modified) (16 diffs)
• kernel/kern/chdev.h (modified) (1 diff)
• kernel/kern/kernel_init.c (modified) (1 diff)
• kernel/kern/process.c (modified) (7 diffs)
• kernel/kern/rpc.c (modified) (104 diffs)
• kernel/kern/rpc.h (modified) (6 diffs)
• kernel/kern/scheduler.c (modified) (3 diffs)
• kernel/kern/thread.c (modified) (4 diffs)
• kernel/kern/thread.h (modified) (2 diffs)
• kernel/kernel_config.h (modified) (6 diffs)
• kernel/libk/remote_barrier.c (modified) (11 diffs)
• kernel/libk/remote_barrier.h (modified) (3 diffs)
• kernel/libk/remote_busylock.c (modified) (2 diffs)
• kernel/libk/remote_busylock.h (modified) (1 diff)
• kernel/libk/remote_mutex.c (modified) (9 diffs)
• kernel/libk/user_dir.c (modified) (5 diffs)
• kernel/mm/kcm.c (modified) (8 diffs)
• kernel/mm/kcm.h (modified) (1 diff)
• kernel/mm/khm.h (modified) (2 diffs)
• kernel/mm/kmem.c (modified) (4 diffs)
• kernel/mm/kmem.h (modified) (2 diffs)
• kernel/mm/vmm.c (modified) (12 diffs)
• kernel/syscalls/sys_barrier.c (modified) (11 diffs)
• kernel/syscalls/sys_display.c (modified) (6 diffs)
• kernel/syscalls/sys_exit.c (modified) (10 diffs)
• kernel/syscalls/sys_thread_create.c (modified) (1 diff)
• kernel/syscalls/sys_thread_exit.c (modified) (2 diffs)
• kernel/syscalls/syscalls.h (modified) (1 diff)
• libs/libpthread/pthread.c (modified) (3 diffs)
• libs/libsemaphore/semaphore.h (modified) (2 diffs)
• libs/mini-libc/string.c (modified) (1 diff)
• libs/mini-libc/string.h (modified) (2 diffs)
• params-hard.mk (modified) (1 diff)
• user/ksh/ksh.c (modified) (46 diffs)
• user/sort/sort.c (modified) (10 diffs)

trunk/hal/generic/hal_exception.h

@@ -26 +26 @@
 
 #include <hal_kernel_types.h>
+#include <thread.h>
 
 //////////////////////////////////////////////////////////////////////////////////////////
@@ -59 +60 @@
     EXCP_USER_ERROR,
     EXCP_KERNEL_PANIC,
+
 }
 exception_handling_type_t;
@@ -69 +71 @@
 void hal_do_exception( void );
 
+
 #endif  // _HAL_EXCEPTION_H_

trunk/hal/generic/hal_remote.h

@@ -166 +166 @@
  * destination remote buffer in kernel space.
  *****************************************************************************************
- * @ dst     : extended pointer to destination buffer
- * @ src     : extended pointer to source buffer
+ * @ dst_xp  : extended pointer to destination buffer
+ * @ src_xp  : extended pointer to source buffer
  * @ size    : number of bytes to move
  ****************************************************************************************/
-void hal_remote_memcpy( xptr_t   dst,
-                        xptr_t   src,
+void hal_remote_memcpy( xptr_t   dst_xp,
+                        xptr_t   src_xp,
                         uint32_t size );
 

trunk/hal/generic/hal_special.h

@@ -84 +84 @@
  * This function returns the current value of stack pointer from core register.
  ****************************************************************************************/
-uint32_t hal_get_stack( void );
+uint32_t hal_get_sp( void );
+
+/*****************************************************************************************
+ * This function returns the current value of the return adddress from core register.
+ ****************************************************************************************/
+uint32_t hal_get_ra( void );
 
 /*****************************************************************************************
  * This function registers a new value in the core stack pointer and returns previous one.
  ****************************************************************************************/
-inline uint32_t hal_set_stack( void * new_val );
+inline uint32_t hal_set_sp( void * new_val );
 
 /*****************************************************************************************

trunk/hal/tsar_mips32/core/hal_exception.c

@@ -219 +219 @@
 uint32_t cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_HAL_EXCEPTIONS < cycle )
-printk("\n[%s] thread[%x,%x] on core [%x,%x] enter / is_ins %d / %s / vaddr %x / cycle %d\n",
+printk("\n[%s] thread[%x,%x] on core [%x,%x] enter\n  is_ins %d / %s / vaddr %x / cycle %d\n",
 __FUNCTION__, process->pid, this->trdid, local_cxy, this->core->lid,
 is_ins, hal_mmu_exception_str(excp_code), bad_vaddr, cycle);
@@ -242 +242 @@
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_HAL_EXCEPTIONS < cycle )
-printk("\n[%s] thread[%x,%x] on core [%x,%x] exit / page-fault handled for vaddr = %x\n",
+printk("\n[%s] thread[%x,%x] on core [%x,%x] exit\n  page-fault handled for vaddr = %x\n",
 __FUNCTION__, process->pid, this->trdid, local_cxy, this->core->lid, bad_vaddr );
 #endif
@@ -342 +342 @@
 
 //////////////////////////////////////////////////////////////////////////////////////////
-// This static function prints on the kernel terminal the saved context (core registers)
+// This function prints on the kernel terminal the saved context (core registers)
 // and the thread state of a faulty thread.
 //////////////////////////////////////////////////////////////////////////////////////////
 // @ this     : pointer on faulty thread descriptor.
-// @ uzone    : pointer on register array.
 // @ error    : EXCP_USER_ERROR or EXCP_KERNEL_PANIC
 //////////////////////////////////////////////////////////////////////////////////////////
 static void hal_exception_dump( thread_t * this,
-                                reg_t    * uzone,
                                 error_t    error )
 {
     core_t    * core    = this->core;
     process_t * process = this->process;
+    reg_t     * uzone   = this->uzone_current;
 
     // get pointers on TXT0 chdev
@@ -399 +398 @@
         uzone[UZ_S0], uzone[UZ_S1], uzone[UZ_S2], uzone[UZ_S3], uzone[UZ_S4] );
   
-    nolock_printk("s5_21   %X  s6_22   %X  s7_23  %X  s8_24  %X  ra_25  %X\n",
+    nolock_printk("s5_21   %X  s6_22   %X  s7_23  %X  t8_24  %X  t9_25  %X\n",
         uzone[UZ_S5], uzone[UZ_S6], uzone[UZ_S7], uzone[UZ_T8], uzone[UZ_T9] );
 
@@ -508 +507 @@
         if( error == EXCP_USER_ERROR )          //  user error => kill user process
         {
-        hal_exception_dump( this , uzone , error );
+        hal_exception_dump( this , error );
 
         sys_exit( EXIT_FAILURE );
@@ -514 +513 @@
     else if( error == EXCP_KERNEL_PANIC )   // kernel error => kernel panic
     {
-        hal_exception_dump( this , uzone , error );
+        hal_exception_dump( this , error );
 
         hal_core_sleep();

trunk/hal/tsar_mips32/core/hal_special.c

@@ -25 +25 @@
 #include <hal_kernel_types.h>
 #include <hal_special.h>
+#include <hal_exception.h>
 #include <core.h>
 #include <thread.h>
@@ -145 +146 @@
 }
 
-//////////////////////////////
-uint32_t hal_get_stack( void )
+///////////////////////////
+uint32_t hal_get_sp( void )
 {
         register uint32_t sp;
@@ -155 +156 @@
 }
 
-////////////////////////////////////////
-uint32_t hal_set_stack( void * new_val )
+/////////////////////////////////////
+uint32_t hal_set_sp( void * new_val )
 {
         register uint32_t sp;
@@ -168 +169 @@
 }
 
+///////////////////////////
+uint32_t hal_get_ra( void )
+{
+        register uint32_t ra;
+  
+        asm volatile ("or    %0,   $0,   $31" : "=&r" (ra));
+  
+        return ra;
+}
+
 //////////////////////////////////
 uint32_t hal_get_bad_vaddr( void )
@@ -216 +227 @@
 void hal_core_sleep( void )
 {
+    thread_t * this = CURRENT_THREAD;
+
+    printk("\n*** thread[%x,%x] on core[%x,%d]/n"
+           "  sr = %X / sp = %X / ra = %X\n",
+           this->process->pid, this->trdid, local_cxy, this->core->lid,  
+           hal_get_sr(), hal_get_sp(), hal_get_ra() );
+
         while( 1 ) asm volatile ("nop");
 }

trunk/hal/tsar_mips32/drivers/soclib_tty.c

@@ -131 +131 @@
 #endif
 
+#if( DEBUG_HAL_TXT_TX || DEBUG_HAL_TXT_RX )
+thread_t * this = CURRENT_THREAD;
+#endif
+
     // get TXT device cluster and pointers
     xptr_t     dev_xp = (xptr_t)hal_remote_l64( XPTR( th_cxy , &th_ptr->txt_cmd.dev_xp ) );
@@ -160 +164 @@
 
 #if DEBUG_HAL_TXT_TX
-uint32_t tx_cycle = (uint32_t)hal_get_cycles();
+uint32_t   tx_cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_HAL_TXT_TX < tx_cycle )
-printk("\n[DBG] %s : thread %x put character <%c> to TXT%d_TX fifo / cycle %d\n",
-__FUNCTION__, CURRENT_THREAD, byte, channel, tx_cycle );
+printk("\n[%s] thread[%x,%x] put character <%c> to TXT%d_TX fifo / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, byte, channel, tx_cycle );
 #endif
                 // write byte to FIFO
@@ -195 +199 @@
     }
     ///////////////////////////
-    else if( type == TXT_READ )       // read bytes from TTY_RX FIFO   
+    else if( type == TXT_READ )       // read several bytes from TTY_RX FIFO   
     {
         fifo = &tty_rx_fifo[channel];
@@ -211 +215 @@
 uint32_t rx_cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_HAL_TXT_RX < rx_cycle )
-printk("\n[DBG] %s : thread %x get character <%c> from TXT%d_RX fifo / cycle %d\n",
-__FUNCTION__, CURRENT_THREAD, byte, channel, rx_cycle );
+printk("\n[%s] thread[%x,%x] get character <%c> from TXT%d_RX fifo / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, byte, channel, rx_cycle );
 #endif
                 // update FIFO state
@@ -328 +332 @@
 #if DEBUG_HAL_TXT_RX
 if( DEBUG_HAL_TXT_RX < rx_cycle )
-printk("\n[DBG] %s : read ^Z character from TXT%d\n", __FUNCTION__, channel );
+printk("\n[%s] read ^Z character from TXT%d\n", __FUNCTION__, channel );
 #endif
                 // get pointers on TXT owner process in owner cluster
@@ -381 +385 @@
 #if DEBUG_HAL_TXT_RX
 if( DEBUG_HAL_TXT_RX < rx_cycle )
-printk("\n[DBG] %s : read ^C character from TXT%d\n", __FUNCTION__, channel );
+printk("\n[%s] read ^C character from TXT%d\n", __FUNCTION__, channel );
 #endif
                 // get pointer on TXT owner process in owner cluster
@@ -434 +438 @@
 #if DEBUG_HAL_TXT_RX
 if( DEBUG_HAL_TXT_RX < rx_cycle )
-printk("\n[DBG] %s : put character <%c> to TXT%d_RX fifo\n",
+printk("\n[%s] put character <%c> to TXT%d_RX fifo\n",
 __FUNCTION__, byte, channel );
 #endif
@@ -481 +485 @@
 #if DEBUG_HAL_TXT_TX
 if( DEBUG_HAL_TXT_TX < tx_cycle )
-printk("\n[DBG] %s : get character <%c> from TXT%d_TX fifo\n",
+printk("\n[%s] get character <%c> from TXT%d_TX fifo\n",
 __FUNCTION__, byte, channel );
 #endif

trunk/kernel/devices/dev_dma.c

@@ -63 +63 @@
     error = thread_kernel_create( &new_thread,
                                   THREAD_DEV,
-                                  &chdev_sequencial_server,
+                                  &chdev_server_func,
                                   dma,
                                   cluster_select_local_core() );

trunk/kernel/devices/dev_ioc.c

@@ -71 +71 @@
     error = thread_kernel_create( &new_thread,
                                   THREAD_DEV,
-                                  &chdev_sequencial_server,
+                                  &chdev_server_func,
                                   ioc,
                                   lid );

trunk/kernel/devices/dev_nic.c

@@ -70 +70 @@
     error = thread_kernel_create( &new_thread,
                                   THREAD_DEV,
-                                  &chdev_sequencial_server,
+                                  &chdev_server_func,
                                   nic,
                                   lid ); 

trunk/kernel/devices/dev_txt.c

@@ -53 +53 @@
 const char * dev_txt_type_str( dev_txt_cmd_t type )
 {
-  switch (type) {
-    case (TXT_SYNC_WRITE): return "TXT_SYNC_WRITE";
-    case (TXT_READ):       return "TXT_READ";
-    case (TXT_WRITE):      return "TXT_WRITE";
-    default:               return "undefined";
-  }
+    switch (type)
+    {
+        case (TXT_SYNC_WRITE): return "TXT_SYNC_WRITE";
+        case (TXT_READ):       return "TXT_READ";
+        case (TXT_WRITE):      return "TXT_WRITE";
+        default:               return "undefined";
+    }
 }
 
@@ -115 +116 @@
         error = thread_kernel_create( &new_thread,
                                       THREAD_DEV,
-                                      &chdev_sequencial_server,
+                                      &chdev_server_func,
                                       txt,
                                       lid );
@@ -178 +179 @@
 
 #if DEBUG_DEV_TXT_TX
-uint32_t cycle = (uint32_t)hal_get_cycles();
+thread_t * this  = CURRENT_THREAD;
+uint32_t   cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_DEV_TXT_TX < cycle )
-printk("\n[DBG] %s : thread %x enters / cycle %d\n", __FUNCTION__, CURRENT_THREAD, cycle );
+printk("\n[%s] thread[%x,%x] enters / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, cycle );
 #endif
 
@@ -194 +197 @@
 
     // If we use MTTYs (vci_multi_tty), we perform only sync writes
+    // Otherwise, we use vci_tty_tsar so we can use async writes
+
     if( dev_ptr->impl == IMPL_TXT_MTY )
     {
@@ -212 +217 @@
     }
 
-    // Otherwise, we use vci_tty_tsar so we can use async writes
     else
     {
-    return dev_txt_access( TXT_WRITE , channel , buffer , count );
+        return dev_txt_access( TXT_WRITE , channel , buffer , count );
     }
 
@@ -221 +225 @@
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_DEV_TXT_TX < cycle )
-printk("\n[DBG] %s : thread %x exit / cycle %d\n", __FUNCTION__, CURRENT_THREAD, cycle );
+printk("\n[%s] thread[%x,%x] exit / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, cycle );
 #endif
 
@@ -240 +245 @@
 
 #if DEBUG_DEV_TXT_RX
-uint32_t cycle = (uint32_t)hal_get_cycles();
+thread_t * this  = CURRENT_THREAD;
+uint32_t   cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_DEV_TXT_RX < cycle )
-printk("\n[DBG] %s : thread %x enters / cycle %d\n", __FUNCTION__, CURRENT_THREAD, cycle );
+printk("\n[%s] thread[%x,%x] enters / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, cycle );
 #endif
 
@@ -250 +257 @@
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_DEV_TXT_RX < cycle )
-printk("\n[DBG] %s : thread %x exit / cycle %d\n", __FUNCTION__, CURRENT_THREAD, cycle );
+printk("\n[%s] thread[%x,%x] exit / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, cycle );
 #endif
 

trunk/kernel/kern/chdev.c

@@ -168 +168 @@
 
 #if (DEBUG_CHDEV_CMD_RX || DEBUG_CHDEV_CMD_TX)
-bool_t is_rx = hal_remote_l32( XPTR( chdev_cxy , &chdev_ptr->is_rx ) );
+bool_t      is_rx        = hal_remote_l32( XPTR( chdev_cxy , &chdev_ptr->is_rx ) );
+trdid_t     server_trdid = hal_remote_l32( XPTR( chdev_cxy , &server_ptr->trdid ) ); 
+process_t * process_ptr  = hal_remote_lpt( XPTR( chdev_cxy , &server_ptr->process ) );
+pid_t       server_pid   = hal_remote_l32( XPTR( chdev_cxy , &process_ptr->pid ) );
 #endif
     
@@ -175 +178 @@
 if( (is_rx) && (DEBUG_CHDEV_CMD_RX < rx_cycle) )
 printk("\n[%s] client[%x,%x] enter for RX / server[%x,%x] / cycle %d\n",
-__FUNCTION__, this->process->pid, this->trdid, 
-server_ptr->process->pid, server_ptr->trdid, rx_cycle );
+__FUNCTION__, this->process->pid, this->trdid, server_pid, server_trdid, rx_cycle );
 #endif
 
@@ -183 +185 @@
 if( (is_rx == 0) && (DEBUG_CHDEV_CMD_TX < tx_cycle) )
 printk("\n[%s] client[%x,%x] enter for TX / server[%x,%x] / cycle %d\n",
-__FUNCTION__, this->process->pid, this->trdid, 
-server_ptr->process->pid, server_ptr->trdid, tx_cycle );
+__FUNCTION__, this->process->pid, this->trdid, server_pid, server_trdid, tx_cycle );
 #endif
 
@@ -241 +242 @@
 if( (is_rx == 0) && (DEBUG_CHDEV_CMD_TX < tx_cycle) )
 printk("\n[%s] TX server thread[%x,%x] unblocked\n",
-__FUNCTION__, server_ptr->process->pid, server_ptr->trdid );
+__FUNCTION__, server_pid, server_trdid );
 #endif
 
@@ -247 +248 @@
 if( (is_rx) && (DEBUG_CHDEV_CMD_RX < rx_cycle) )
 printk("\n[%s] RX server thread[%x,%x] unblocked\n",
-__FUNCTION__, server_ptr->process->pid, server_ptr->trdid );
+__FUNCTION__, server_pid, server_trdid );
 #endif
 
@@ -273 +274 @@
 if( (is_rx == 0)  && (DEBUG_CHDEV_CMD_TX < tx_cycle) )
 printk("\n[%s] client thread[%x,%x] sent IPI to TX server thread[%x,%x]\n",
-__FUNCTION__, this->process->pid, this->trdid, server_ptr->process->pid, server_ptr->trdid );
+__FUNCTION__, this->process->pid, this->trdid, server_pid, server_trdid );
 #endif
 
@@ -279 +280 @@
 if( (is_rx)  && (DEBUG_CHDEV_CMD_RX < rx_cycle) )
 printk("\n[%s] client thread[%x,%x] sent IPI to RX server thread[%x,%x]\n",
-__FUNCTION__, this->process->pid, this->trdid, server_ptr->process->pid, server_ptr->trdid );
+__FUNCTION__, this->process->pid, this->trdid, server_pid, server_trdid );
 #endif
 
@@ -317 +318 @@
 }  // end chdev_register_command()
 
-///////////////////////////////////////////////
-void chdev_sequencial_server( chdev_t * chdev )
+/////////////////////////////////////////
+void chdev_server_func( chdev_t * chdev )
 {
     xptr_t          client_xp;    // extended pointer on waiting thread
@@ -340 +341 @@
     {
 
-#if DEBUG_CHDEV_SERVER_RX
+#if( DEBUG_CHDEV_SERVER_RX || DEBUG_CHDEV_SERVER_TX )
 uint32_t rx_cycle = (uint32_t)hal_get_cycles();
 if( (chdev->is_rx) && (DEBUG_CHDEV_SERVER_RX < rx_cycle) )
-printk("\n[%s] thread[%x,%x] start RX / cycle %d\n",
-__FUNCTION__ , server->process->pid, server->trdid, rx_cycle );
+printk("\n[%s] DEV thread[%x,%x] check TXT_RX channel %d / cycle %d\n",
+__FUNCTION__ , server->process->pid, server->trdid, chdev->channel, rx_cycle );
 #endif
 
@@ -350 +351 @@
 uint32_t tx_cycle = (uint32_t)hal_get_cycles();
 if( (chdev->is_rx == 0) && (DEBUG_CHDEV_SERVER_TX < tx_cycle) )
-printk("\n[%s] thread[%x,%x] start TX / cycle %d\n",
-__FUNCTION__ , server->process->pid, server->trdid, tx_cycle );
+printk("\n[%s] thread[%x,%x] check TXT_TX channel %d / cycle %d\n",
+__FUNCTION__ , server->process->pid, server->trdid, chdev->channel, tx_cycle );
 #endif
 
@@ -397 +398 @@
             client_ptr = GET_PTR( client_xp );
 
-#if( DDEBUG_CHDEV_SERVER_TX || DEBUG_CHDEV_SERVER_RX )
+#if( DEBUG_CHDEV_SERVER_TX || DEBUG_CHDEV_SERVER_RX )
 process_t * process      = hal_remote_lpt( XPTR( client_cxy , &client_ptr->process ) );
 pid_t       client_pid   = hal_remote_l32( XPTR( client_cxy , &process->pid ) );
-process_t   client_trdid = hal_remote_l32( XPTR( client_cxy , &client_ptr->trdid ) );
+trdid_t     client_trdid = hal_remote_l32( XPTR( client_cxy , &client_ptr->trdid ) );
 #endif
 
@@ -407 +408 @@
 if( (chdev->is_rx) && (DEBUG_CHDEV_SERVER_RX < rx_cycle) )
 printk("\n[%s] thread[%x,%x] for RX get client thread[%x,%x] / cycle %d\n",
-__FUNCTION__, server->process->pid, server->trdid, client_pid, client_trdid, cycle );
+__FUNCTION__, server->process->pid, server->trdid, client_pid, client_trdid, rx_cycle );
 #endif
 
@@ -414 +415 @@
 if( (chdev->is_rx == 0) && (DEBUG_CHDEV_SERVER_TX < tx_cycle) )
 printk("\n[%s] thread[%x,%x] for TX get client thread[%x,%x] / cycle %d\n",
-__FUNCTION__, server->process->pid, server->trdid, client_pid, client_trdid, cycle );
+__FUNCTION__, server->process->pid, server->trdid, client_pid, client_trdid, tx_cycle );
 #endif
 
@@ -445 +446 @@
 if( (chdev->is_rx) && (DEBUG_CHDEV_SERVER_RX < rx_cycle) )
 printk("\n[%s] thread[%x,%x] completes RX for client thread[%x,%x] / cycle %d\n",
-__FUNCTION__, server->process->pid, server->trdid, client_pid, client_trdid, cycle );
+__FUNCTION__, server->process->pid, server->trdid, client_pid, client_trdid, rx_cycle );
 #endif
 
@@ -452 +453 @@
 if( (chdev->is_rx == 0) && (DEBUG_CHDEV_SERVER_TX < tx_cycle) )
 printk("\n[%s] thread[%x,%x] completes TX for client thread[%x,%x] / cycle %d\n",
-__FUNCTION__, server->process->pid, server->trdid, client_pid, client_trdid, cycle );
+__FUNCTION__, server->process->pid, server->trdid, client_pid, client_trdid, tX_cycle );
 #endif
 
@@ -465 +466 @@
         }
     }  // end while
-}  // end chdev_sequencial_server()
+}  // end chdev_server_func()
 
 ////////////////////////////////////////

trunk/kernel/kern/chdev.h

@@ -240 +240 @@
  * @ chdev   : local pointer on device descriptor.
  *****************************************************************************************/
-void chdev_sequencial_server( chdev_t * chdev );
+void chdev_server_func( chdev_t * chdev );
 
 /******************************************************************************************

trunk/kernel/kern/kernel_init.c

@@ -154 +154 @@
     "CONDVAR_STATE",         // 17
     "SEM_STATE",             // 18
-    "RPOCESS_CWD",           // 19
-
-    "unused_20",             // 20
+    "PROCESS_CWD",           // 19
+    "BARRIER_STATE",         // 20
 
     "CLUSTER_PREFTBL",       // 21

trunk/kernel/kern/process.c

@@ -528 +528 @@
     process_t        * process_ptr;       // local pointer on process copy
     reg_t              save_sr;           // for critical section
-    rpc_desc_t         rpc;               // shared RPC descriptor
     thread_t         * client;            // pointer on client thread
     xptr_t             client_xp;         // extended pointer on client thread
     process_t        * local;             // pointer on process copy in local cluster
     uint32_t           remote_nr;         // number of remote process copies
+    rpc_desc_t         rpc;               // shared RPC descriptor
+    uint32_t           responses;         // shared RPC responses counter
 
     client    = CURRENT_THREAD;
@@ -579 +580 @@
     thread_block( client_xp , THREAD_BLOCKED_RPC );
 
+    // initialize RPC responses counter
+    responses = 0;
+
     // initialize shared RPC descriptor
-    rpc.responses = 0;
+    // can be shared, because no out arguments
+    rpc.rsp       = &responses;
     rpc.blocking  = false;
     rpc.index     = RPC_PROCESS_SIGACTION;
@@ -608 +613 @@
             remote_nr++;
 
-            // atomically increment responses counter
-            hal_atomic_add( (void *)&rpc.responses , 1 );
+            // atomically increment RPC responses counter
+            hal_atomic_add( &responses , 1 );
 
 #if DEBUG_PROCESS_SIGACTION 
@@ -617 +622 @@
 #endif
             // call RPC in target cluster
-            rpc_process_sigaction_client( process_cxy , &rpc );
+            rpc_send( process_cxy , &rpc );
         }
     }  // end list of copies
@@ -685 +690 @@
 
 // check target process is an user process
-assert( (LPID_FROM_PID( process->pid ) != 0 ), "target process must be an user process" );
+assert( (LPID_FROM_PID( process->pid ) != 0 ),
+"process %x is not an user process\n", process->pid );
 
     // get target process owner cluster
@@ -773 +779 @@
 
 // check target process is an user process
-assert( (LPID_FROM_PID( process->pid ) != 0), "process %x not an user process", process->pid );
+assert( (LPID_FROM_PID( process->pid ) != 0),
+"process %x is not an user process\n", process->pid );
 
     // get lock protecting process th_tbl[]
@@ -831 +838 @@
 
 // check target process is an user process
-assert( ( process->pid != 0 ),
-"target process must be an user process" );
+assert( ( LPID_FROM_PID( process->pid ) != 0 ),
+"process %x is not an user process\n", process->pid );
 
     // get lock protecting process th_tbl[]

trunk/kernel/kern/rpc.c

@@ -143 +143 @@
     client_core_lid = this->core->lid;
 
-    // check calling thread can yield when client thread is not the IDLE thread
+    // check calling thread can yield when is not the IDLE thread
     // RPCs executed by the IDLE thread during kernel_init do not deschedule
     if( this->type != THREAD_IDLE ) thread_assert_can_yield( this , __FUNCTION__ );
@@ -184 +184 @@
     while( full );
  
-    hal_fence();
-
 #if DEBUG_RPC_CLIENT_GENERIC
 uint32_t cycle = (uint32_t)hal_get_cycles();
@@ -199 +197 @@
 
     // wait RPC completion before returning if blocking RPC :
-    // - descheduling without blocking if thread idle (in kernel init)
+    // - deschedule without blocking if thread idle (in kernel init)
     // - block and deschedule policy for any other thread
     if ( rpc->blocking )
@@ -212 +210 @@
 __FUNCTION__, this->process->pid, this->trdid, rpc_str[rpc->index], cycle );
 #endif
-
-             while( rpc->responses ) sched_yield( "busy waiting on RPC");
-    
+             while( 1 )
+             {
+                 // check responses counter
+                 if( hal_remote_l32( XPTR( local_cxy , rpc->rsp ) ) == 0 ) break;
+                   
+                 // deschedule
+                 sched_yield("busy_waiting RPC completion");
+             }
+
 #if DEBUG_RPC_CLIENT_GENERIC
 cycle = (uint32_t)hal_get_cycles();
@@ -242 +246 @@
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_RPC_CLIENT_GENERIC < cycle ) 
-printk("\n[%s] thread[%x,%x] resumes for rpc %s / cycle %d\n",
+printk("\n[%s] thread[%x,%x] resumes after rpc %s / cycle %d\n",
 __FUNCTION__, this->process->pid, this->trdid, rpc_str[rpc->index], cycle );
 #endif
@@ -248 +252 @@
 
 // response must be available for a blocking RPC
-assert( (rpc->responses == 0) , "illegal response for RPC %s\n", rpc_str[rpc->index] );
+assert( (*rpc->rsp == 0) , "illegal response for RPC %s\n", rpc_str[rpc->index] );
 
     }
@@ -270 +274 @@
 
 ////////////////////////////
-void rpc_thread_func( void )
+void rpc_server_func( void )
 {
     error_t         empty;              // local RPC fifo state
@@ -278 +282 @@
     uint32_t        index;              // RPC request index 
     thread_t      * client_ptr;         // local pointer on client thread
+    xptr_t          client_xp;          // extended pointer on client thread
+    lid_t           client_lid;         // local index of client core
         thread_t      * server_ptr;         // local pointer on server thread
     xptr_t          server_xp;          // extended pointer on server thread
-    lid_t           client_core_lid;    // local index of client core
-    lid_t           server_core_lid;    // local index of server core
-    bool_t          blocking;           // blocking RPC when true
+    lid_t           server_lid;         // local index of server core
         remote_fifo_t * rpc_fifo;           // local pointer on RPC fifo
-    uint32_t        count;              // current number of expected responses
- 
+    uint32_t      * rsp_ptr;            // local pointer on responses counter
+    xptr_t          rsp_xp;             // extended pointer on responses counter
+    uint32_t        responses;          // number of expected responses
+
     // makes RPC thread not preemptable
         hal_disable_irq( NULL );
@@ -291 +297 @@
         server_ptr      = CURRENT_THREAD;
     server_xp       = XPTR( local_cxy , server_ptr );
-    server_core_lid = server_ptr->core->lid;
-        rpc_fifo        = &LOCAL_CLUSTER->rpc_fifo[server_core_lid];
+    server_lid      = server_ptr->core->lid;
+        rpc_fifo        = &LOCAL_CLUSTER->rpc_fifo[server_lid];
 
     // "infinite" RPC thread loop
@@ -305 +311 @@
 if( DEBUG_RPC_SERVER_GENERIC < cycle ) 
 printk("\n[%s] RPC thread[%x,%x] on core[%d] takes RPC_FIFO ownership / cycle %d\n",
-__FUNCTION__, server_ptr->process->pid, server_ptr->trdid, server_core_lid, cycle );
+__FUNCTION__, server_ptr->process->pid, server_ptr->trdid, server_lid, cycle );
 #endif
                 // try to consume one RPC request  
@@ -320 +326 @@
                 desc_ptr = GET_PTR( desc_xp );
 
+                // get relevant infos from RPC descriptor
                     index      = hal_remote_l32( XPTR( desc_cxy , &desc_ptr->index ) );
-                blocking   = hal_remote_l32( XPTR( desc_cxy , &desc_ptr->blocking ) );
                 client_ptr = hal_remote_lpt( XPTR( desc_cxy , &desc_ptr->thread ) );
+                rsp_ptr    = hal_remote_lpt( XPTR( desc_cxy , &desc_ptr->rsp ) );
+                client_lid = hal_remote_l32( XPTR( desc_cxy , &desc_ptr->lid ) );
+
+                rsp_xp     = XPTR( desc_cxy , rsp_ptr );
+                client_xp  = XPTR( desc_cxy , client_ptr );
 
 #if DEBUG_RPC_SERVER_GENERIC
@@ -332 +343 @@
 #endif
                 // register client thread in RPC thread descriptor
-                server_ptr->rpc_client_xp = XPTR( desc_cxy , client_ptr );
+                server_ptr->rpc_client_xp = client_xp;
  
                 // call the relevant server function
@@ -343 +354 @@
 __FUNCTION__, server_ptr->process->pid, server_ptr->trdid, rpc_str[index], desc_cxy, cycle );
 #endif
-                // decrement expected responses counter in RPC descriptor
-                count = hal_remote_atomic_add( XPTR( desc_cxy, &desc_ptr->responses ), -1 );
-
-                // decrement response counter in RPC descriptor if last response
-                if( count == 1 ) 
+                // decrement expected responses counter 
+                responses = hal_remote_atomic_add( rsp_xp , -1 );
+
+                // unblock client thread if last response
+                if( responses == 1 ) 
                 {
-                    // get client thread pointer and client core lid from RPC descriptor
-                    client_ptr      = hal_remote_lpt( XPTR( desc_cxy , &desc_ptr->thread ) );
-                    client_core_lid = hal_remote_l32 ( XPTR( desc_cxy , &desc_ptr->lid ) );
-
                     // unblock client thread
-                    thread_unblock( XPTR( desc_cxy , client_ptr ) , THREAD_BLOCKED_RPC );
+                    thread_unblock( client_xp , THREAD_BLOCKED_RPC );
 
                     hal_fence();
@@ -360 +367 @@
 #if DEBUG_RPC_SERVER_GENERIC
 cycle = (uint32_t)hal_get_cycles();
+trdid_t     client_trdid = hal_remote_l32( XPTR( desc_cxy , &client_ptr->trdid ) );
+process_t * process      = hal_remote_lpt( XPTR( desc_cxy , &client_ptr->process ) );
+pid_t       client_pid   = hal_remote_l32( XPTR( desc_cxy , &process->pid ) );
 if( DEBUG_RPC_SERVER_GENERIC < cycle ) 
 printk("\n[%s] RPC thread[%x,%x] unblocked client thread[%x,%x] / cycle %d\n",
 __FUNCTION__, server_ptr->process->pid, server_ptr->trdid,
-client_ptr->process->pid, client_ptr->trdid, cycle );
+client_pid, client_trdid, cycle );
 #endif
                     // send IPI to client core
-                    dev_pic_send_ipi( desc_cxy , client_core_lid );
+                    dev_pic_send_ipi( desc_cxy , client_lid );
                 }
             }  // end RPC handling if fifo non empty
@@ -372 +382 @@
 
         // sucide if too many RPC threads 
-        if( LOCAL_CLUSTER->rpc_threads[server_core_lid] >= CONFIG_RPC_THREADS_MAX )
+        if( LOCAL_CLUSTER->rpc_threads[server_lid] >= CONFIG_RPC_THREADS_MAX )
             {
 
@@ -382 +392 @@
 #endif
             // update RPC threads counter
-                hal_atomic_add( &LOCAL_CLUSTER->rpc_threads[server_core_lid] , -1 );
+                hal_atomic_add( &LOCAL_CLUSTER->rpc_threads[server_lid] , -1 );
 
             // RPC thread blocks on GLOBAL
@@ -397 +407 @@
 uint32_t cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_RPC_SERVER_GENERIC < cycle ) 
-printk("\n[%s] RPC thread[%x,%x] block IDLE & deschedules / cycle %d\n",
+printk("\n[%s] RPC thread[%x,%x] blocks & deschedules / cycle %d\n",
 __FUNCTION__, server_ptr->process->pid, server_ptr->trdid, cycle );
 #endif
@@ -407 +417 @@
         }
         } // end infinite loop
-} // end rpc_thread_func()
+
+} // end rpc_server_func()
 
 
@@ -427 +438 @@
 #endif
 
-    assert( (cxy != local_cxy) , "server cluster is not remote\n");
+    uint32_t responses = 1;
 
     // initialise RPC descriptor header 
@@ -433 +444 @@
     rpc.index     = RPC_PMEM_GET_PAGES;
     rpc.blocking  = true;
-    rpc.responses = 1;
+    rpc.rsp       = &responses;
 
     // set input arguments in RPC descriptor 
@@ -485 +496 @@
 
 /////////////////////////////////////////////////////////////////////////////////////////
-// [1]       Marshaling functions attached to RPC_PMEM_RELEASE_PAGES (blocking)
+// [1]       Marshaling functions attached to RPC_PMEM_RELEASE_PAGES 
 /////////////////////////////////////////////////////////////////////////////////////////
 
@@ -500 +511 @@
 #endif
 
-    assert( (cxy != local_cxy) , "server cluster is not remote\n");
+    uint32_t responses = 1;
 
     // initialise RPC descriptor header 
@@ -506 +517 @@
     rpc.index    = RPC_PMEM_RELEASE_PAGES;
     rpc.blocking = true;
-    rpc.responses = 1;
+    rpc.rsp      = &responses;
 
     // set input arguments in RPC descriptor 
@@ -559 +570 @@
 
 /////////////////////////////////////////////////////////////////////////////////////////
-// [3]           Marshaling functions attached to RPC_PROCESS_MAKE_FORK (blocking)
+// [3]           Marshaling functions attached to RPC_PROCESS_MAKE_FORK 
 /////////////////////////////////////////////////////////////////////////////////////////
 
@@ -578 +589 @@
 #endif
 
-    assert( (cxy != local_cxy) , "server cluster is not remote\n");
+    uint32_t responses = 1;
 
     // initialise RPC descriptor header 
@@ -584 +595 @@
     rpc.index    = RPC_PROCESS_MAKE_FORK;
     rpc.blocking = true;
-    rpc.responses = 1;
+    rpc.rsp      = &responses;
 
     // set input arguments in RPC descriptor  
@@ -651 +662 @@
 
 /////////////////////////////////////////////////////////////////////////////////////////
-// [4]      Marshaling functions attached to RPC_USER_DIR_CREATE (blocking) 
+// [4]      Marshaling functions attached to RPC_USER_DIR_CREATE  
 /////////////////////////////////////////////////////////////////////////////////////////
 
@@ -668 +679 @@
 #endif
 
-    assert( (cxy != local_cxy) , "server cluster is not remote\n");
+    uint32_t responses = 1;
 
     // initialise RPC descriptor header 
@@ -674 +685 @@
     rpc.index    = RPC_USER_DIR_CREATE;
     rpc.blocking = true;
-    rpc.responses = 1;
+    rpc.rsp      = &responses;
 
     // set input arguments in RPC descriptor 
@@ -732 +743 @@
 
 /////////////////////////////////////////////////////////////////////////////////////////
-// [5]      Marshaling functions attached to RPC_USER_DIR_DESTROY (blocking) 
+// [5]      Marshaling functions attached to RPC_USER_DIR_DESTROY 
 /////////////////////////////////////////////////////////////////////////////////////////
 
@@ -748 +759 @@
 #endif
 
-    assert( (cxy != local_cxy) , "server cluster is not remote\n");
+    uint32_t responses = 1;
 
     // initialise RPC descriptor header 
@@ -754 +765 @@
     rpc.index    = RPC_USER_DIR_DESTROY;
     rpc.blocking = true;
-    rpc.responses = 1;
+    rpc.rsp      = &responses;
 
     // set input arguments in RPC descriptor 
@@ -805 +816 @@
 
 /////////////////////////////////////////////////////////////////////////////////////////
-// [6]      Marshaling functions attached to RPC_THREAD_USER_CREATE (blocking)  
+// [6]      Marshaling functions attached to RPC_THREAD_USER_CREATE   
 /////////////////////////////////////////////////////////////////////////////////////////
 
@@ -824 +835 @@
 __FUNCTION__, this->process->pid, this->trdid, this->core->lid, cycle );
 #endif
-
-    assert( (cxy != local_cxy) , "server cluster is not remote\n");
+   
+    uint32_t responses = 1;
 
     // initialise RPC descriptor header 
@@ -831 +842 @@
     rpc.index    = RPC_THREAD_USER_CREATE;
     rpc.blocking = true;
-    rpc.responses = 1;
+    rpc.rsp      = &responses;
 
     // set input arguments in RPC descriptor 
@@ -929 +940 @@
 #endif
 
-    assert( (cxy != local_cxy) , "server cluster is not remote\n");
+    uint32_t responses = 1;
 
     // initialise RPC descriptor header 
@@ -935 +946 @@
     rpc.index    = RPC_THREAD_KERNEL_CREATE;
     rpc.blocking = true;
-    rpc.responses = 1;
+    rpc.rsp      = &responses;
 
     // set input arguments in RPC descriptor 
@@ -1007 +1018 @@
 
 /////////////////////////////////////////////////////////////////////////////////////////
-// [9]   Marshaling functions attached to RPC_PROCESS_SIGACTION (non blocking)
+// [9]   Marshaling functions attached to RPC_PROCESS_SIGACTION 
 /////////////////////////////////////////////////////////////////////////////////////////
 
 ////////////////////////////////////////////////////
 void rpc_process_sigaction_client( cxy_t        cxy,
-                                   rpc_desc_t * rpc )
+                                   pid_t        pid,
+                                   uint32_t     action )
 {
 #if DEBUG_RPC_PROCESS_SIGACTION
@@ -1018 +1030 @@
 thread_t * this = CURRENT_THREAD;
 if( DEBUG_RPC_PROCESS_SIGACTION < cycle )
-printk("\n[%s] thread[%x,%x] on core %d enter / cycle %d\n",
-__FUNCTION__, this->process->pid, this->trdid, this->core->lid, cycle );
-#endif
-
-// check RPC "index" and "blocking" arguments
-assert( (rpc->blocking == false) , "must be non-blocking\n");
-assert( (rpc->index == RPC_PROCESS_SIGACTION ) , "bad RPC index\n" );
-
-    // register RPC request in remote RPC fifo and return
-    rpc_send( cxy , rpc );
+printk("\n[%s] thread[%x,%x] on core %d : enter to %s process %x / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, this->core->lid,
+process_action_str( action ), pid, cycle );
+#endif
+
+    uint32_t    responses = 1;
+    rpc_desc_t  rpc;
+
+    // initialise RPC descriptor header 
+    rpc.index    = RPC_PROCESS_SIGACTION;
+    rpc.blocking = true;
+    rpc.rsp      = &responses;
+
+    // set input arguments in RPC descriptor 
+    rpc.args[0] = (uint64_t)pid;
+    rpc.args[1] = (uint64_t)action;
+
+    // register RPC request in remote RPC fifo 
+    rpc_send( cxy , &rpc );
 
 #if DEBUG_RPC_PROCESS_SIGACTION
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_RPC_PROCESS_SIGACTION < cycle )
-printk("\n[%s] thread[%x,%x] on core %d exit / cycle %d\n",
-__FUNCTION__, this->process->pid, this->trdid, this->core->lid, cycle );
+printk("\n[%s] thread[%x,%x] on core %d : exit after %s process %x / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, this->core->lid,
+process_action_str( action ), pid, cycle );
 #endif
 }  // end rpc_process_sigaction_client() 
@@ -1040 +1062 @@
 void rpc_process_sigaction_server( xptr_t xp )
 {
-#if DEBUG_RPC_PROCESS_SIGACTION
-uint32_t cycle = (uint32_t)hal_get_cycles();
-thread_t * this = CURRENT_THREAD;
-if( DEBUG_RPC_PROCESS_SIGACTION < cycle )
-printk("\n[%s] thread[%x,%x] on core %d enter / cycle %d\n",
-__FUNCTION__, this->process->pid, this->trdid, this->core->lid, cycle );
-#endif
-
     // get client cluster identifier and pointer on RPC descriptor
     cxy_t        client_cxy = GET_CXY( xp );
@@ -1056 +1070 @@
     uint32_t action = (uint32_t)hal_remote_l64( XPTR(client_cxy , &desc->args[1]) );
 
+#if DEBUG_RPC_PROCESS_SIGACTION
+uint32_t cycle = (uint32_t)hal_get_cycles();
+thread_t * this = CURRENT_THREAD;
+if( DEBUG_RPC_PROCESS_SIGACTION < cycle )
+printk("\n[%s] thread[%x,%x] on core %d : enter to %s process %x / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, this->core->lid,
+process_action_str( action ), pid, cycle );
+#endif
+
     // get client thread pointers
     thread_t * client_ptr = hal_remote_lpt( XPTR( client_cxy , &desc->thread ) );
@@ -1063 +1086 @@
     process_t * process = cluster_get_local_process_from_pid( pid );
 
-    // call relevant kernel function
-    if      ( action == DELETE_ALL_THREADS  ) process_delete_threads ( process , client_xp ); 
-    else if ( action == BLOCK_ALL_THREADS   ) process_block_threads  ( process ); 
-    else if ( action == UNBLOCK_ALL_THREADS ) process_unblock_threads( process );
+    // call relevant kernel function if found / does nothing if not found
+    if( process != NULL )
+    {
+        if ( action == DELETE_ALL_THREADS  ) process_delete_threads ( process , client_xp ); 
+        if ( action == BLOCK_ALL_THREADS   ) process_block_threads  ( process ); 
+        if ( action == UNBLOCK_ALL_THREADS ) process_unblock_threads( process );
+    }
 
 #if DEBUG_RPC_PROCESS_SIGACTION
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_RPC_PROCESS_SIGACTION < cycle )
-printk("\n[%s] thread[%x,%x] on core %d exit / cycle %d\n",
-__FUNCTION__, this->process->pid, this->trdid, this->core->lid, cycle );
+printk("\n[%s] thread[%x,%x] on core %d : exit after %s process %x / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, this->core->lid,
+process_action_str( action ), pid, cycle );
 #endif
 } // end rpc_process_sigaction_server() 
 
 /////////////////////////////////////////////////////////////////////////////////////////
-// [10]     Marshaling functions attached to RPC_VFS_INODE_CREATE  (blocking)
+// [10]     Marshaling functions attached to RPC_VFS_INODE_CREATE 
 /////////////////////////////////////////////////////////////////////////////////////////
 
@@ -1099 +1126 @@
 #endif
 
-    assert( (cxy != local_cxy) , "server cluster is not remote\n");
+    uint32_t responses = 1;
 
     // initialise RPC descriptor header 
@@ -1105 +1132 @@
     rpc.index    = RPC_VFS_INODE_CREATE;
     rpc.blocking = true;
-    rpc.responses = 1;
+    rpc.rsp      = &responses;
 
     // set input arguments in RPC descriptor 
@@ -1184 +1211 @@
 
 /////////////////////////////////////////////////////////////////////////////////////////
-// [11]          Marshaling functions attached to RPC_VFS_INODE_DESTROY  (blocking)
+// [11]          Marshaling functions attached to RPC_VFS_INODE_DESTROY 
 /////////////////////////////////////////////////////////////////////////////////////////
 
@@ -1199 +1226 @@
 #endif
 
-    assert( (cxy != local_cxy) , "server cluster is not remote\n");
+    uint32_t responses = 1;
 
     // initialise RPC descriptor header 
@@ -1205 +1232 @@
     rpc.index    = RPC_VFS_INODE_DESTROY;
     rpc.blocking = true;
-    rpc.responses = 1;
+    rpc.rsp      = &responses;
 
     // set input arguments in RPC descriptor 
@@ -1253 +1280 @@
 
 /////////////////////////////////////////////////////////////////////////////////////////
-// [12]          Marshaling functions attached to RPC_VFS_DENTRY_CREATE  (blocking)
+// [12]          Marshaling functions attached to RPC_VFS_DENTRY_CREATE 
 /////////////////////////////////////////////////////////////////////////////////////////
 
@@ -1271 +1298 @@
 #endif
 
-    assert( (cxy != local_cxy) , "server cluster is not remote\n");
+    uint32_t responses = 1;
 
     // initialise RPC descriptor header 
@@ -1277 +1304 @@
     rpc.index    = RPC_VFS_DENTRY_CREATE;
     rpc.blocking = true;
-    rpc.responses = 1;
+    rpc.rsp      = &responses;
 
     // set input arguments in RPC descriptor 
@@ -1344 +1371 @@
 
 /////////////////////////////////////////////////////////////////////////////////////////
-// [13]          Marshaling functions attached to RPC_VFS_DENTRY_DESTROY  (blocking)
+// [13]          Marshaling functions attached to RPC_VFS_DENTRY_DESTROY 
 /////////////////////////////////////////////////////////////////////////////////////////
 
@@ -1359 +1386 @@
 #endif
 
-    assert( (cxy != local_cxy) , "server cluster is not remote\n");
+    uint32_t responses = 1;
 
     // initialise RPC descriptor header 
@@ -1365 +1392 @@
     rpc.index    = RPC_VFS_DENTRY_DESTROY;
     rpc.blocking = true;
-    rpc.responses = 1;
+    rpc.rsp      = &responses;
 
     // set input arguments in RPC descriptor 
@@ -1414 +1441 @@
 
 /////////////////////////////////////////////////////////////////////////////////////////
-// [14]          Marshaling functions attached to RPC_VFS_FILE_CREATE  (blocking)
+// [14]          Marshaling functions attached to RPC_VFS_FILE_CREATE  
 /////////////////////////////////////////////////////////////////////////////////////////
 
@@ -1432 +1459 @@
 #endif
 
-    assert( (cxy != local_cxy) , "server cluster is not remote\n");
+    uint32_t responses = 1;
 
     // initialise RPC descriptor header 
@@ -1438 +1465 @@
     rpc.index    = RPC_VFS_FILE_CREATE;
     rpc.blocking = true;
-    rpc.responses = 1;
+    rpc.rsp      = &responses;
 
     // set input arguments in RPC descriptor 
@@ -1501 +1528 @@
 
 /////////////////////////////////////////////////////////////////////////////////////////
-// [15]          Marshaling functions attached to RPC_VFS_FILE_DESTROY  (blocking)
+// [15]          Marshaling functions attached to RPC_VFS_FILE_DESTROY  
 /////////////////////////////////////////////////////////////////////////////////////////
 
@@ -1516 +1543 @@
 #endif
 
-    assert( (cxy != local_cxy) , "server cluster is not remote\n");
+    uint32_t responses = 1;
 
     // initialise RPC descriptor header 
@@ -1522 +1549 @@
     rpc.index    = RPC_VFS_FILE_DESTROY;
     rpc.blocking = true;
-    rpc.responses = 1;
+    rpc.rsp      = &responses;
 
     // set input arguments in RPC descriptor 
@@ -1570 +1597 @@
 
 /////////////////////////////////////////////////////////////////////////////////////////
-// [16]      Marshaling functions attached to RPC_VFS_FS_GET_DENTRY  (blocking)
+// [16]      Marshaling functions attached to RPC_VFS_FS_GET_DENTRY 
 /////////////////////////////////////////////////////////////////////////////////////////
 
@@ -1588 +1615 @@
 #endif
 
-    assert( (cxy != local_cxy) , "server cluster is not remote\n");
+    uint32_t responses = 1;
 
     // initialise RPC descriptor header 
@@ -1594 +1621 @@
     rpc.index    = RPC_VFS_FS_GET_DENTRY;
     rpc.blocking = true;
-    rpc.responses = 1;
+    rpc.rsp      = &responses;
 
     // set input arguments in RPC descriptor 
@@ -1661 +1688 @@
 
 /////////////////////////////////////////////////////////////////////////////////////////
-// [17]      Marshaling function attached to RPC_VFS_FS_ADD_DENTRY  (blocking)
+// [17]      Marshaling function attached to RPC_VFS_FS_ADD_DENTRY  
 /////////////////////////////////////////////////////////////////////////////////////////
 
@@ -1677 +1704 @@
 #endif
 
-    assert( (cxy != local_cxy) , "server cluster is not remote\n");
+    uint32_t responses = 1;
 
     // initialise RPC descriptor header 
@@ -1683 +1710 @@
     rpc.index    = RPC_VFS_FS_ADD_DENTRY;
     rpc.blocking = true;
-    rpc.responses = 1;
+    rpc.rsp      = &responses;
 
     // set input arguments in RPC descriptor 
@@ -1703 +1730 @@
 }
 
-/////////////////////////////////////////////////
+//////////////////////////////////////////////
 void rpc_vfs_fs_add_dentry_server( xptr_t xp )
 {
@@ -1741 +1768 @@
 
 /////////////////////////////////////////////////////////////////////////////////////////
-// [18]      Marshaling function attached to RPC_VFS_FS_REMOVE_DENTRY  (blocking)
+// [18]      Marshaling function attached to RPC_VFS_FS_REMOVE_DENTRY 
 /////////////////////////////////////////////////////////////////////////////////////////
 
@@ -1757 +1784 @@
 #endif
 
-    assert( (cxy != local_cxy) , "server cluster is not remote\n");
+    uint32_t responses = 1;
 
     // initialise RPC descriptor header 
@@ -1763 +1790 @@
     rpc.index    = RPC_VFS_FS_REMOVE_DENTRY;
     rpc.blocking = true;
-    rpc.responses = 1;
+    rpc.rsp      = &responses;
 
     // set input arguments in RPC descriptor 
@@ -1821 +1848 @@
 
 /////////////////////////////////////////////////////////////////////////////////////////
-// [19]     Marshaling functions attached to RPC_VFS_INODE_LOAD_ALL_PAGES  (blocking)
+// [19]     Marshaling functions attached to RPC_VFS_INODE_LOAD_ALL_PAGES 
 /////////////////////////////////////////////////////////////////////////////////////////
 
@@ -1837 +1864 @@
 #endif
 
-    assert( (cxy != local_cxy) , "server cluster is not remote\n");
+    uint32_t responses = 1;
 
     // initialise RPC descriptor header 
@@ -1843 +1870 @@
     rpc.index    = RPC_VFS_INODE_LOAD_ALL_PAGES;
     rpc.blocking = true;
-    rpc.responses = 1;
+    rpc.rsp      = &responses;
 
     // set input arguments in RPC descriptor 
@@ -1898 +1925 @@
 
 /////////////////////////////////////////////////////////////////////////////////////////
-// [20]          Marshaling functions attached to RPC_VMM_GET_VSEG  (blocking)
+// [20]          Marshaling functions attached to RPC_VMM_GET_VSEG 
 /////////////////////////////////////////////////////////////////////////////////////////
 
@@ -1916 +1943 @@
 #endif
 
-    assert( (cxy != local_cxy) , "server cluster is not remote\n");
+    uint32_t responses = 1;
 
     // initialise RPC descriptor header 
@@ -1922 +1949 @@
     rpc.index    = RPC_VMM_GET_VSEG;
     rpc.blocking = true;
-    rpc.responses = 1;
+    rpc.rsp      = &responses;
 
     // set input arguments in RPC descriptor 
@@ -1986 +2013 @@
 
 /////////////////////////////////////////////////////////////////////////////////////////
-// [21]    Marshaling functions attached to RPC_VMM_GLOBAL_UPDATE_PTE  (blocking)
+// [21]    Marshaling functions attached to RPC_VMM_GLOBAL_UPDATE_PTE 
 /////////////////////////////////////////////////////////////////////////////////////////
 
@@ -2004 +2031 @@
 #endif
 
-    assert( (cxy != local_cxy) , "server cluster is not remote\n");
+    uint32_t responses = 1;
 
     // initialise RPC descriptor header 
@@ -2010 +2037 @@
     rpc.index    = RPC_VMM_GLOBAL_UPDATE_PTE;
     rpc.blocking = true;
-    rpc.responses = 1;
+    rpc.rsp      = &responses;
 
     // set input arguments in RPC descriptor 
@@ -2067 +2094 @@
 
 /////////////////////////////////////////////////////////////////////////////////////////
-// [22]          Marshaling functions attached to RPC_KCM_ALLOC  (blocking)
+// [22]          Marshaling functions attached to RPC_KCM_ALLOC 
 /////////////////////////////////////////////////////////////////////////////////////////
 
@@ -2073 +2100 @@
 void rpc_kcm_alloc_client( cxy_t      cxy,
                            uint32_t   kmem_type,   // in
-                           xptr_t *   buf_xp )     // out
+                           xptr_t   * buf_xp )     // out
 {
 #if DEBUG_RPC_KCM_ALLOC
@@ -2083 +2110 @@
 #endif
 
-    assert( (cxy != local_cxy) , "server cluster is not remote\n");
+    uint32_t responses = 1;
 
     // initialise RPC descriptor header 
@@ -2089 +2116 @@
     rpc.index    = RPC_KCM_ALLOC;
     rpc.blocking = true;
-    rpc.responses = 1;
+    rpc.rsp      = &responses;
 
     // set input arguments in RPC descriptor 
@@ -2145 +2172 @@
 
 /////////////////////////////////////////////////////////////////////////////////////////
-// [23]          Marshaling functions attached to RPC_KCM_FREE  (blocking)
+// [23]          Marshaling functions attached to RPC_KCM_FREE 
 /////////////////////////////////////////////////////////////////////////////////////////
 
@@ -2161 +2188 @@
 #endif
 
-    assert( (cxy != local_cxy) , "server cluster is not remote\n");
+    uint32_t responses = 1;
 
     // initialise RPC descriptor header 
@@ -2167 +2194 @@
     rpc.index    = RPC_KCM_FREE;
     rpc.blocking = true;
-    rpc.responses = 1;
+    rpc.rsp      = &responses;
 
     // set input arguments in RPC descriptor 
@@ -2222 +2249 @@
 
 /////////////////////////////////////////////////////////////////////////////////////////
-// [25]          Marshaling functions attached to RPC_MAPPER_HANDLE_MISS (blocking)
+// [25]          Marshaling functions attached to RPC_MAPPER_HANDLE_MISS 
 /////////////////////////////////////////////////////////////////////////////////////////
 
@@ -2240 +2267 @@
 #endif
 
-    assert( (cxy != local_cxy) , "server cluster is not remote\n");
+    uint32_t responses = 1;
 
     // initialise RPC descriptor header 
@@ -2246 +2273 @@
     rpc.index    = RPC_MAPPER_HANDLE_MISS;
     rpc.blocking = true;
-    rpc.responses = 1;
+    rpc.rsp      = &responses;
 
     // set input arguments in RPC descriptor 
@@ -2309 +2336 @@
 
 /////////////////////////////////////////////////////////////////////////////////////////
-// [26]  Marshaling functions attached to RPC_VMM_DELETE_VSEG (parallel / non blocking)
+// [26]  Marshaling functions attached to RPC_VMM_DELETE_VSEG 
 /////////////////////////////////////////////////////////////////////////////////////////
 
 //////////////////////////////////////////////////
 void rpc_vmm_delete_vseg_client( cxy_t        cxy,
-                                 rpc_desc_t * rpc )
+                                 pid_t        pid,
+                                 intptr_t     vaddr )
 {
 #if DEBUG_RPC_VMM_DELETE_VSEG
@@ -2324 +2352 @@
 #endif
 
-// check RPC "index" and "blocking" arguments
-assert( (rpc->blocking == false) , "must be non-blocking\n");
-assert( (rpc->index == RPC_VMM_DELETE_VSEG ) , "bad RPC index\n" );
+    uint32_t    responses = 1;
+    rpc_desc_t  rpc;
+
+    // initialise RPC descriptor header 
+    rpc.index    = RPC_VMM_DELETE_VSEG;
+    rpc.blocking = true;
+    rpc.rsp      = &responses;
+
+    // set input arguments in RPC descriptor 
+    rpc.args[0] = (uint64_t)pid;
+    rpc.args[1] = (uint64_t)vaddr;
 
     // register RPC request in remote RPC fifo
-    rpc_send( cxy , rpc );
+    rpc_send( cxy , &rpc );
 
 #if DEBUG_RPC_VMM_DELETE_VSEG
@@ -2370 +2406 @@
 
 /////////////////////////////////////////////////////////////////////////////////////////
-// [27]          Marshaling functions attached to RPC_VMM_CREATE_VSEG (blocking)
+// [27]          Marshaling functions attached to RPC_VMM_CREATE_VSEG 
 /////////////////////////////////////////////////////////////////////////////////////////
 
@@ -2393 +2429 @@
 #endif
 
-    assert( (cxy != local_cxy) , "server cluster is not remote\n");
+    uint32_t responses = 1;
 
     // initialise RPC descriptor header 
@@ -2399 +2435 @@
     rpc.index    = RPC_VMM_CREATE_VSEG;
     rpc.blocking = true;
-    rpc.responses = 1;
+    rpc.rsp      = &responses;
 
     // set input arguments in RPC descriptor 
@@ -2472 +2508 @@
 
 /////////////////////////////////////////////////////////////////////////////////////////
-// [28]          Marshaling functions attached to RPC_VMM_SET_COW (blocking)
+// [28]          Marshaling functions attached to RPC_VMM_SET_COW 
 /////////////////////////////////////////////////////////////////////////////////////////
 
@@ -2479 +2515 @@
                              process_t * process )
 {
-    assert( (cxy != local_cxy) , "server cluster is not remote\n");
+#if DEBUG_RPC_VMM_SET_COW
+thread_t * this = CURRENT_THREAD;
+uint32_t cycle = (uint32_t)hal_get_cycles();
+if( cycle > DEBUG_RPC_VMM_SET_COW )
+printk("\n[%s] thread[%x,%x] on core %d enter / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, this->core->lid , cycle );
+#endif
+
+    uint32_t responses = 1;
 
     // initialise RPC descriptor header 
@@ -2485 +2529 @@
     rpc.index    = RPC_VMM_SET_COW;
     rpc.blocking = true;
-    rpc.responses = 1;
+    rpc.rsp      = &responses;
 
     // set input arguments in RPC descriptor 
@@ -2493 +2537 @@
     rpc_send( cxy , &rpc );
 
+#if DEBUG_RPC_VMM_SET_COW
+cycle = (uint32_t)hal_get_cycles();
+if( cycle > DEBUG_RPC_VMM_SET_COW )
+printk("\n[%s] thread[%x,%x] on core %d exit / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, this->core->lid , cycle );
+#endif
 }
 
@@ -2498 +2548 @@
 void rpc_vmm_set_cow_server( xptr_t xp )
 {
+#if DEBUG_RPC_VMM_SET_COW
+thread_t * this = CURRENT_THREAD;
+uint32_t cycle = (uint32_t)hal_get_cycles();
+if( cycle > DEBUG_RPC_VMM_SET_COW )
+printk("\n[%s] thread[%x,%x] on core %d enter / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, this->core->lid , cycle );
+#endif
+
     process_t * process;
 
@@ -2510 +2568 @@
     vmm_set_cow( process );
 
-}
-
-/////////////////////////////////////////////////////////////////////////////////////////
-// [29]          Marshaling functions attached to RPC_VMM_DISPLAY (blocking)
+#if DEBUG_RPC_VMM_SET_COW
+cycle = (uint32_t)hal_get_cycles();
+if( cycle > DEBUG_RPC_VMM_SET_COW )
+printk("\n[%s] thread[%x,%x] on core %d exit / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, this->core->lid , cycle );
+#endif
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////
+// [29]          Marshaling functions attached to RPC_VMM_DISPLAY 
 /////////////////////////////////////////////////////////////////////////////////////////
 
@@ -2521 +2585 @@
                              bool_t      detailed )
 {
-    assert( (cxy != local_cxy) , "server cluster is not remote\n");
+#if DEBUG_RPC_VMM_DISPLAY
+thread_t * this = CURRENT_THREAD;
+uint32_t cycle = (uint32_t)hal_get_cycles();
+if( cycle > DEBUG_RPC_VMM_DISPLAY )
+printk("\n[%s] thread[%x,%x] on core %d enter / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, this->core->lid , cycle );
+#endif
+
+    uint32_t responses = 1;
 
     // initialise RPC descriptor header 
@@ -2527 +2599 @@
     rpc.index    = RPC_VMM_DISPLAY;
     rpc.blocking = true;
-    rpc.responses = 1;
+    rpc.rsp      = &responses;
 
     // set input arguments in RPC descriptor 
@@ -2536 +2608 @@
     rpc_send( cxy , &rpc );
 
+#if DEBUG_RPC_VMM_DISPLAY
+cycle = (uint32_t)hal_get_cycles();
+if( cycle > DEBUG_RPC_VMM_DISPLAY )
+printk("\n[%s] thread[%x,%x] on core %d exit / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, this->core->lid , cycle );
+#endif
 }
 
@@ -2541 +2619 @@
 void rpc_vmm_display_server( xptr_t xp )
 {
+#if DEBUG_RPC_VMM_DISPLAY
+thread_t * this = CURRENT_THREAD;
+uint32_t cycle = (uint32_t)hal_get_cycles();
+if( cycle > DEBUG_RPC_VMM_DISPLAY )
+printk("\n[%s] thread[%x,%x] on core %d enter / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, this->core->lid , cycle );
+#endif
+
     process_t * process;
     bool_t      detailed;
@@ -2555 +2641 @@
     vmm_display( process , detailed );
 
-}
-
-
+#if DEBUG_RPC_VMM_DISPLAY
+cycle = (uint32_t)hal_get_cycles();
+if( cycle > DEBUG_RPC_VMM_DISPLAY )
+printk("\n[%s] thread[%x,%x] on core %d exit / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, this->core->lid , cycle );
+#endif
+}
+
+

trunk/kernel/kern/rpc.h

@@ -69 +69 @@
     RPC_THREAD_KERNEL_CREATE      = 7,
     RPC_UNDEFINED_8               = 8,
-    RPC_PROCESS_SIGACTION         = 9,       // non blocking
+    RPC_PROCESS_SIGACTION         = 9,
 
     RPC_VFS_INODE_CREATE          = 10,
@@ -88 +88 @@
     RPC_UNDEFINED_24              = 24,
     RPC_MAPPER_HANDLE_MISS        = 25,
-    RPC_VMM_DELETE_VSEG           = 26,      // non blocking
+    RPC_VMM_DELETE_VSEG           = 26,
     RPC_VMM_CREATE_VSEG           = 27,
     RPC_VMM_SET_COW               = 28,
@@ -105 +105 @@
 
 /***********************************************************************************
- *  This structure defines the RPC descriptor
+ *  This structure defines the RPC descriptor (100 bytes on a 32bits core)
  **********************************************************************************/
 
 typedef struct rpc_desc_s
 {
-        rpc_index_t         index;       /*! index of requested RPC service           */
-        volatile uint32_t   responses;   /*! number of expected responses             */
-    struct thread_s   * thread;      /*! local pointer on client thread           */
-    uint32_t            lid;         /*! index of core running the calling thread */ 
-    bool_t              blocking;    /*! blocking RPC when true                   */
-    uint64_t            args[10];    /*! input/output arguments buffer            */
+        rpc_index_t         index;       /*! index of requested RPC service      ( 4) */
+        uint32_t          * rsp;         /*! local pointer ond responses counter ( 4) */
+    struct thread_s   * thread;      /*! local pointer on client thread      ( 4) */
+    uint32_t            lid;         /*! index of core running client thread ( 4) */ 
+    bool_t              blocking;    /*! simple RPC mode when true           ( 4) */
+    uint64_t            args[10];    /*! input/output arguments buffer       (80) */
 } 
 rpc_desc_t;
@@ -161 +161 @@
  * - it block on IDLE and deschedule otherwise.  
  **********************************************************************************/
-void rpc_thread_func( void );
+void rpc_server_func( void );
 
 /***********************************************************************************
@@ -309 +309 @@
 
 /***********************************************************************************
- * [9] The non blocking RPC_PROCESS_SIGACTION allows any client thread running in
- * any cluster to send parallel RPC requests to one or several servers (that can be 
- * local or remote), to execute a given sigaction, defined by the <action_type>
- * argument[1], for a given process identified by the <pid> argument[0].
- *
- * WARNING : It is implemented as a NON BLOCKING RPC, that can be sent in parallel
- * to several servers. The RPC descriptor, containing the <action_type> and <pid>
- * arguments, as well as the RPC <index>, <blocked>, and <response> fields, must
- * be allocated and initialised by the calling function itself.
- * Each RPC server thread atomically decrements the <response> field in this 
- * shared RPC descriptor. The last server thread unblock the client thread,
- * that blocked only after sending all parallel RPC requests to all servers.
+ * [9] The RPC_PROCESS_SIGACTION allows any client thread to request to any cluster
+ * execute a given sigaction, defined by the <action_type> for a given process,
+ * identified by the <pid> argument.
  ***********************************************************************************
  * @ cxy     : server cluster identifier.
- * @ rpc     : pointer on shared RPC descriptor initialized by the client thread.
- **********************************************************************************/
-void rpc_process_sigaction_client( cxy_t               cxy,
-                                   struct rpc_desc_s * rpc );
+ * @ pid     : [in] target process identifier.
+ * @ action  : [in] sigaction index.
+ **********************************************************************************/
+void rpc_process_sigaction_client( cxy_t     cxy,
+                                   pid_t     pid,
+                                   uint32_t  action );
                              
 void rpc_process_sigaction_server( xptr_t xp );
@@ -596 +589 @@
 
 /***********************************************************************************
- * [26] The non blocking RPC_VMM_DELETE_VSEG allows any client thread running in
- * any cluster to send parallel RPC requests to one or several clusters (that can be 
- * local or remote), to delete from a given VMM, identified by the <pid> argument[0]
- * a given vseg, identified by the <vaddr> argument[1].
- *
- * WARNING : It is implemented as a NON BLOCKING RPC, that can be sent in parallel
- * to several servers. The RPC descriptor, containing the <pid> and <vaddr> 
- * arguments, as well as the RPC <index>, <blocked>, and <response> fields, must
- * be allocated and initialised by the calling function itself.
- * Each RPC server thread atomically decrements the the <response> field in this 
- * shared RPC descriptor. The last server thread unblock the client thread,
- * that blocked only after sending all paralle RPC requests to all servers.
+ * [26] The RPC_VMM_DELETE_VSEG allows any client thread  to request a remote
+ * cluster to delete from a given VMM, identified by the <pid> argument
+ * a given vseg, identified by the <vaddr> argument.
  ***********************************************************************************
  * @ cxy         : server cluster identifier.
- * @ rpc     : pointer on shared RPC descriptor initialized by the client thread.
- **********************************************************************************/
-void rpc_vmm_delete_vseg_client( cxy_t               cxy,
-                                 struct rpc_desc_s * rpc );
+ * @ pid         : [in] target process identifier.
+ * @ vaddr       : [in] vseg base address.
+ **********************************************************************************/
+void rpc_vmm_delete_vseg_client( cxy_t       cxy,
+                                 pid_t       pid,
+                                 intptr_t    vaddr );
  
 void rpc_vmm_delete_vseg_server( xptr_t xp );

trunk/kernel/kern/scheduler.c

@@ -29 +29 @@
 #include <printk.h>
 #include <list.h>
+#include <rpc.h>
 #include <core.h>
 #include <thread.h>
@@ -146 +147 @@
 ////////////////////////////////////////////////////////////////////////////////////////////
 // This static function is the only function that can actually delete a thread,
-// and the associated process descriptor, if required.
-// It is private, because it is called by the sched_yield() public function.
+// (and the associated process descriptor if required).
+// It is private, because it is only called by the sched_yield() public function.
 // It scan all threads attached to a given scheduler, and executes the relevant
 // actions for two types of pending requests: 
@@ -376 +377 @@
         error = thread_kernel_create( &thread,
                                       THREAD_RPC, 
-                                              &rpc_thread_func, 
+                                              &rpc_server_func, 
                                       NULL,
                                           lid );

trunk/kernel/kern/thread.c

@@ -1378 +1378 @@
 }  // end thread_assert_can yield()
 
-//////////////////////////////////////////////////
-void thread_display_busylocks( xptr_t  thread_xp )
-{
-    // get cluster and local pointer of target thread
+//////////////////////////////////////////////////////
+void thread_display_busylocks( xptr_t       thread_xp,
+                               const char * string )
+{
     cxy_t      thread_cxy = GET_CXY( thread_xp );
     thread_t * thread_ptr = GET_PTR( thread_xp );
@@ -1389 +1389 @@
     xptr_t    iter_xp;
 
-    // get target thread TRDID and busylocks
-    trdid_t  trdid = hal_remote_l32(XPTR( thread_cxy , &thread_ptr->trdid ));
-    uint32_t locks = hal_remote_l32(XPTR( thread_cxy , &thread_ptr->busylocks ));
-
-    // get target thread process and PID;
-    process_t * process = hal_remote_lpt(XPTR( thread_cxy , &thread_ptr->process ));
-    pid_t       pid     = hal_remote_l32(XPTR( thread_cxy , &process->pid ));
+    // get relevant info from target trhead descriptor
+    uint32_t    locks   = hal_remote_l32( XPTR( thread_cxy , &thread_ptr->busylocks ) );
+    trdid_t     trdid   = hal_remote_l32( XPTR( thread_cxy , &thread_ptr->trdid ) );
+    process_t * process = hal_remote_lpt( XPTR( thread_cxy , &thread_ptr->process ) );
+    pid_t       pid     = hal_remote_l32( XPTR( thread_cxy , &process->pid ) );
 
     // get extended pointer on root of busylocks
-    xptr_t    root_xp = XPTR( thread_cxy , &thread_ptr->busylocks_root );
+    xptr_t root_xp = XPTR( thread_cxy , &thread_ptr->busylocks_root );
 
     // get pointers on TXT0 chdev
@@ -1412 +1410 @@
 
     // display header 
-    nolock_printk("\n***** thread %x in process %x : %d busylocks at cycle %d\n",
-    trdid, pid, locks, (uint32_t)hal_get_cycles() );
+    nolock_printk("\n***** thread[%x,%x] in <%s> : %d busylocks *****\n",
+    pid, trdid, string, locks );
 
     // scan the xlist of busylocks when required
@@ -1436 +1434 @@
 
     // display a warning
-    printk("\n[WARNING] set the DEBUG_BUSYLOCK parmeter in kernel_config.h"
-    " to display busylocks for thread %x/%x\n", thread_cxy, thread_ptr );
+    printk("\n[WARNING] set the DEBUG_BUSYLOCK parameter in kernel_config.h"
+    " to display busylocks for thread(%x,%x)\n", pid, trdid );
 
 }  // end thread_display_busylock()

trunk/kernel/kern/thread.h

@@ -143 +143 @@
 typedef struct thread_s
 {
-        void              * cpu_context;     /*! pointer on CPU context switch            */
-        void              * fpu_context;     /*! pointer on FPU context switch            */
+        void              * cpu_context;     /*! CPU context used by sched_yield          */
+        void              * fpu_context;     /*! FPU context used by sched_yield          */
     void              * uzone_current;   /*! used by hal_do_syscall & hal_do_except   */
     void              * uzone_previous;  /*! used by hal_do_syscall & hal_do_except   */
@@ -465 +465 @@
 
 /***************************************************************************************
- * This debug function display the list of busylocks (local or remote) currently owned
- * by a thread identified by the <thread_xp> argument. 
- * WARNING : it can be called by the idbg tool, but the DEBUG_BUSYLOCK parameter
- * must be set in the kernel_config.h file.
+ * This debug function display the list of busylocks (local or remote) 
+ * currently owned by a the thread identified by the <thead_xp> argument.
+ * The <string> argument is printed in header (can be the calling function name). 
+ * WARNING : the DEBUG_BUSYLOCK parameter must be set in the kernel_config.h file.
  ***************************************************************************************
  * @ thread_xp  : extended pointer on target thread.
- **************************************************************************************/
-void thread_display_busylocks( xptr_t  thread_xp );
+ * @ string     : defines the calling context.
+ **************************************************************************************/
+void thread_display_busylocks( xptr_t       thread_xp,
+                               const char * string );
 
 

trunk/kernel/kernel_config.h

@@ -35 +35 @@
 ////////////////////////////////////////////////////////////////////////////////////////////
 
-#define DEBUG_BARRIER                     0
-
-#define DEBUG_BUSYLOCK                    0
-#define DEBUG_BUSYLOCK_THREAD_XP          0x0000000000ULL  // selected thread xptr
+#define DEBUG_BARRIER_CREATE              1
+#define DEBUG_BARRIER_DESTROY             1
+#define DEBUG_BARRIER_WAIT                0
+
+#define DEBUG_BUSYLOCK                    1
+#define DEBUG_BUSYLOCK_THREAD_XP          0x0ULL  // selected thread xptr
                  
 #define DEBUG_CHDEV_CMD_RX                0
@@ -104 +106 @@
 #define DEBUG_KMEM                        0
 
-#define DEBUG_KERNEL_INIT                 2
+#define DEBUG_KERNEL_INIT                 0
 
 #define DEBUG_MAPPER_GET_PAGE             0
@@ -153 +155 @@
 #define DEBUG_RPC_VMM_GET_PTE             0
 #define DEBUG_RPC_VMM_GET_VSEG            0
-#define DEBUG_RPC_VMM_UNMAP_VSEG          0
+#define DEBUG_RPC_VMM_DELETE_VSEG         0
 
 #define DEBUG_RWLOCK_TYPE                 0    // lock type (0 is undefined) 
@@ -276 +278 @@
 #define LOCK_SEM_STATE        18   // remote (B)  protect user semaphore state
 #define LOCK_PROCESS_CWD      19   // remote (B)  protect current working directory in process
-
-#define BUSYLOCK_TYPE_MAX     20
+#define LOCK_BARRIER_STATE    20   // remote (B)  protect user barrier state
 
 #define LOCK_CLUSTER_PREFTBL  21   // local  (Q)  protect array of ref. processes in cluster
@@ -285 +286 @@
 #define LOCK_CLUSTER_COPIES   24   // remote (Q)  protect xlist of process copies in cluster
 #define LOCK_PROCESS_CHILDREN 25   // remote (Q)  protect xlist of chidren process in process
-#define LOCK_PROCESS_USERSYNC 26   // remote (Q)  protect all lists of user synchros in process
+#define LOCK_PROCESS_USERSYNC 26   // remote (Q)  protect lists of user synchros in process
 #define LOCK_PROCESS_FDARRAY  27   // remote (Q)  protect array of open files in owner process 
 #define LOCK_FATFS_FREE       28   // remote (Q)  protect the FATFS context (free clusters)
@@ -419 +420 @@
 
 ////////////////////////////////////////////////////////////////////////////////////////////
-//     PHYSICAL MEMORY MANAGEMENT (GENERIC)        
+//                      PHYSICAL MEMORY MANAGEMENT         
 ////////////////////////////////////////////////////////////////////////////////////////////
 

trunk/kernel/libk/remote_barrier.c

@@ -2 +2 @@
  * remote_barrier.c -  POSIX barrier implementation.
  *
- * Author   Alain Greiner (2016,2017,2018)
+ * Author   Alain Greiner (2016,2017,2018,2019)
  *
  * Copyright (c) UPMC Sorbonne Universites
@@ -23 +23 @@
 
 #include <hal_kernel_types.h>
+#include <hal_macros.h>
 #include <hal_remote.h>
 #include <hal_irqmask.h>
@@ -33 +34 @@
 #include <remote_barrier.h>
 
+////////////////////////////////////////////////////
+//  generic (implementation independant) functions
+////////////////////////////////////////////////////
 
 ///////////////////////////////////////////////////
-xptr_t remote_barrier_from_ident( intptr_t  ident )
+xptr_t generic_barrier_from_ident( intptr_t  ident )
 {
     // get pointer on local process_descriptor
     process_t * process = CURRENT_THREAD->process;
 
-    // get extended pointer on reference process
-    xptr_t      ref_xp = process->ref_xp;
-
-    // get cluster and local pointer on reference process
+    // get pointers on reference process
+    xptr_t         ref_xp  = process->ref_xp;
     cxy_t          ref_cxy = GET_CXY( ref_xp );
     process_t    * ref_ptr = (process_t *)GET_PTR( ref_xp );
@@ -51 +53 @@
 
     // scan reference process barriers list
-    xptr_t             iter_xp;
-    xptr_t             barrier_xp;
-    cxy_t              barrier_cxy;
-    remote_barrier_t * barrier_ptr;
-    intptr_t           current;
-    bool_t             found = false;
+    xptr_t              iter_xp;
+    xptr_t              barrier_xp;
+    cxy_t               barrier_cxy;
+    generic_barrier_t * barrier_ptr;
+    intptr_t            current;
+    bool_t              found = false;
 
     XLIST_FOREACH( root_xp , iter_xp )
     {
-        barrier_xp  = XLIST_ELEMENT( iter_xp , remote_barrier_t , list );
+        barrier_xp  = XLIST_ELEMENT( iter_xp , generic_barrier_t , list );
         barrier_cxy = GET_CXY( barrier_xp );
-        barrier_ptr = (remote_barrier_t *)GET_PTR( barrier_xp );
+        barrier_ptr = (generic_barrier_t *)GET_PTR( barrier_xp );
         current     = (intptr_t)hal_remote_lpt( XPTR( barrier_cxy , &barrier_ptr->ident ) );
         if( ident == current )
@@ -73 +75 @@
     if( found == false )  return XPTR_NULL;
     else                  return barrier_xp;
-}
-
-//////////////////////////////////////////////
-error_t remote_barrier_create( intptr_t ident,
-                               uint32_t count )
+
+} // end generic_barrier_from_ident()
+
+//////////////////////////////////////////////////////////////
+error_t generic_barrier_create( intptr_t                ident,
+                                uint32_t                count,
+                                pthread_barrierattr_t * attr )
+{
+    xptr_t              gen_barrier_xp;   // extended pointer on generic barrier descriptor
+    generic_barrier_t * gen_barrier_ptr;  // local pointer on generic barrier descriptor
+    void              * barrier;          // local pointer on implementation barrier descriptor      
+    kmem_req_t          req;              // kmem request
+
+    // get pointer on local process_descriptor
+    process_t * process = CURRENT_THREAD->process;
+
+    // get pointers on reference process
+    xptr_t         ref_xp  = process->ref_xp;
+    cxy_t          ref_cxy = GET_CXY( ref_xp );
+    process_t    * ref_ptr = (process_t *)GET_PTR( ref_xp );
+
+    // allocate memory for generic barrier descriptor
+    if( ref_cxy == local_cxy )                         // reference cluster is local
+    {
+        req.type          = KMEM_GEN_BARRIER;
+        req.flags         = AF_ZERO;
+        gen_barrier_ptr   = kmem_alloc( &req );
+        gen_barrier_xp    = XPTR( local_cxy , gen_barrier_ptr );
+    }
+    else                                               // reference cluster is remote
+    {
+        rpc_kcm_alloc_client( ref_cxy,
+                              KMEM_GEN_BARRIER,
+                              &gen_barrier_xp );
+        gen_barrier_ptr = GET_PTR( gen_barrier_xp );
+    }
+
+    if( gen_barrier_ptr == NULL )
+    {
+        printk("\n[ERROR] in %s : cannot create generic barrier\n", __FUNCTION__ );
+        return -1;
+    }
+
+    // create implementation specific barrier descriptor
+    if( attr == NULL )                                    // simple barrier implementation
+    {
+        // create simple barrier descriptor
+         barrier = simple_barrier_create( count );
+
+        if( barrier == NULL )
+        {
+            printk("\n[ERROR] in %s : cannot create simple barrier\n", __FUNCTION__);
+            return -1;
+        }
+    }
+    else                                                  // QDT barrier implementation
+    {
+        uint32_t x_size   = attr->x_size;
+        uint32_t y_size   = attr->y_size;
+        uint32_t nthreads = attr->nthreads;
+
+        // check attributes / count
+        if( (x_size * y_size * nthreads) != count )
+        {
+            printk("\n[ERROR] in %s : count(%d) != x_size(%d) * y_size(%d) * nthreads(%d)\n",
+            __FUNCTION__, count, x_size, y_size, nthreads );
+            return -1;
+        }
+
+        // create DQT barrier descriptor
+        barrier = dqt_barrier_create( x_size , y_size , nthreads );
+
+        if( barrier == NULL )
+        {
+            printk("\n[ERROR] in %s : cannot create DQT barrier descriptor\n", __FUNCTION__);
+            return -1;
+        }
+    }
+
+    // initialize the generic barrier descriptor
+    hal_remote_spt( XPTR( ref_cxy , &gen_barrier_ptr->ident  ) , (void*)ident );
+    hal_remote_s32( XPTR( ref_cxy , &gen_barrier_ptr->is_dqt ) , (attr != NULL) );
+    hal_remote_spt( XPTR( ref_cxy , &gen_barrier_ptr->extend ) , barrier );
+
+    // build extended pointers on lock, root and entry for reference process xlist
+    xptr_t root_xp  = XPTR( ref_cxy , &ref_ptr->barrier_root );
+    xptr_t lock_xp  = XPTR( ref_cxy , &ref_ptr->sync_lock );
+    xptr_t entry_xp = XPTR( ref_cxy , &gen_barrier_ptr->list );
+
+    // register barrier in reference process xlist of barriers
+    remote_busylock_acquire( lock_xp );
+    xlist_add_first( root_xp , entry_xp );
+    remote_busylock_release( lock_xp );
+
+    return 0;
+
+}  // en generic_barrier_create() 
+
+/////////////////////////////////////////////////////
+void generic_barrier_destroy( xptr_t gen_barrier_xp )
+{
+    kmem_req_t  req;              // kmem request
+
+    // get pointer on local process_descriptor
+    process_t * process = CURRENT_THREAD->process;
+
+    // get pointers on reference process
+    xptr_t      ref_xp  = process->ref_xp;
+    cxy_t       ref_cxy = GET_CXY( ref_xp );
+    process_t * ref_ptr = GET_PTR( ref_xp );
+
+    // get cluster and local pointer on generic barrier descriptor
+    generic_barrier_t * gen_barrier_ptr = GET_PTR( gen_barrier_xp );
+    cxy_t               gen_barrier_cxy = GET_CXY( gen_barrier_xp );
+
+    // get barrier type and extension pointer
+    bool_t  is_dqt = hal_remote_l32( XPTR( gen_barrier_cxy , &gen_barrier_ptr->is_dqt ) );
+    void  * extend = hal_remote_lpt( XPTR( gen_barrier_cxy , &gen_barrier_ptr->extend ) );
+
+    // build extended pointer on implementation dependant barrier descriptor
+    xptr_t barrier_xp = XPTR( gen_barrier_cxy , extend );
+
+    // delete the implementation specific barrier
+    if( is_dqt ) dqt_barrier_destroy( barrier_xp );
+    else         simple_barrier_destroy( barrier_xp );
+
+    // build extended pointers on lock and entry for reference process xlist
+    xptr_t  lock_xp  = XPTR( ref_cxy , &ref_ptr->sync_lock );
+    xptr_t  entry_xp = XPTR( gen_barrier_cxy , &gen_barrier_ptr->list );
+
+    // remove barrier from reference process xlist
+    remote_busylock_acquire( lock_xp );
+    xlist_unlink( entry_xp );
+    remote_busylock_release( lock_xp );
+
+    // release memory allocated to barrier descriptor
+    if( gen_barrier_cxy == local_cxy )            
+    {
+        req.type          = KMEM_GEN_BARRIER;
+        req.ptr           = gen_barrier_ptr;
+        kmem_free( &req );
+    }
+    else         
+    {
+        rpc_kcm_free_client( gen_barrier_cxy,
+                             gen_barrier_ptr,
+                             KMEM_GEN_BARRIER );
+    }
+}  // end generic_barrier_destroy()
+
+//////////////////////////////////////////////////
+void generic_barrier_wait( xptr_t gen_barrier_xp )
+{
+    // get generic barrier descriptor cluster and pointer
+    cxy_t               gen_barrier_cxy = GET_CXY( gen_barrier_xp );
+    generic_barrier_t * gen_barrier_ptr = GET_PTR( gen_barrier_xp );
+
+    // get implementation type and extend local pointer
+    bool_t  is_dqt = hal_remote_l32( XPTR( gen_barrier_cxy , &gen_barrier_ptr->is_dqt ) );
+    void  * extend = hal_remote_lpt( XPTR( gen_barrier_cxy , &gen_barrier_ptr->extend ) );
+
+    // build extended pointer on implementation specific barrier descriptor
+    xptr_t barrier_xp = XPTR( gen_barrier_cxy , extend );
+
+    // call the relevant wait function
+    if( is_dqt ) dqt_barrier_wait( barrier_xp );
+    else         simple_barrier_wait( barrier_xp );
+    
+}  // end generic_barrier_wait()
+
+
+
+
+
+/////////////////////////////////////////////////////////////
+//      simple barrier functions
+/////////////////////////////////////////////////////////////
+
+///////////////////////////////////////////////////////////
+simple_barrier_t * simple_barrier_create( uint32_t  count )
 {
     xptr_t             barrier_xp;
-    remote_barrier_t * barrier_ptr;
-
-    // get pointer on local process descriptor
+    simple_barrier_t * barrier;
+
+    // get pointer on local client process descriptor
     thread_t  * this    = CURRENT_THREAD;
     process_t * process = this->process;
 
-#if DEBUG_BARRIER
+    // get reference process cluster
+    xptr_t         ref_xp  = process->ref_xp;
+    cxy_t          ref_cxy = GET_CXY( ref_xp );
+
+    // allocate memory for simple barrier descriptor
+    if( ref_cxy == local_cxy )                        // reference is local
+    {
+        kmem_req_t req;
+        req.type      = KMEM_SMP_BARRIER;
+        req.flags     = AF_ZERO;
+        barrier       = kmem_alloc( &req );
+        barrier_xp    = XPTR( local_cxy , barrier );
+    }
+    else                                             // reference is remote
+    {
+        rpc_kcm_alloc_client( ref_cxy,
+                              KMEM_SMP_BARRIER,
+                              &barrier_xp );
+        barrier = GET_PTR( barrier_xp );
+    }
+
+    if( barrier == NULL ) return NULL;
+
+    // initialise simple barrier descriptor
+    hal_remote_s32      ( XPTR( ref_cxy , &barrier->arity )      , count );
+    hal_remote_s32      ( XPTR( ref_cxy , &barrier->current    ) , 0 );
+    hal_remote_s32      ( XPTR( ref_cxy , &barrier->sense      ) , 0 );
+
+    xlist_root_init     ( XPTR( ref_cxy , &barrier->root ) );
+    remote_busylock_init( XPTR( ref_cxy , &barrier->lock ) , LOCK_BARRIER_STATE );
+
+#if DEBUG_BARRIER_CREATE
 uint32_t cycle = (uint32_t)hal_get_cycles();
-if( cycle > DEBUG_BARRIER )
-printk("\n[DBG] %s : thread %x in process %x enter / count %d / cycle %d\n",
-__FUNCTION__, this->trdid, process->pid, count, cycle );
-#endif
-
-    // get extended pointer on reference process
-    xptr_t      ref_xp = process->ref_xp;
-
-    // get reference process cluster and local pointer
-    cxy_t       ref_cxy = GET_CXY( ref_xp );
-    process_t * ref_ptr = GET_PTR( ref_xp );
-
-    // allocate memory for barrier descriptor
-    if( ref_cxy == local_cxy )                  // local cluster is the reference
-    {
-        kmem_req_t req;
-        req.type      = KMEM_BARRIER;
-        req.flags     = AF_ZERO;
-        barrier_ptr   = kmem_alloc( &req );
-        barrier_xp    = XPTR( local_cxy , barrier_ptr );
-    }
-    else                                       // reference is remote
-    {
-        rpc_kcm_alloc_client( ref_cxy , KMEM_BARRIER , &barrier_xp );
-        barrier_ptr = (remote_barrier_t *)GET_PTR( barrier_xp );
-    }
-
-    if( barrier_ptr == NULL ) return ENOMEM;
-
-    // initialise barrier
-    hal_remote_s32( XPTR( ref_cxy , &barrier_ptr->nb_threads ) , count );
-    hal_remote_s32( XPTR( ref_cxy , &barrier_ptr->current    ) , 0 );
-    hal_remote_s32( XPTR( ref_cxy , &barrier_ptr->sense      ) , 0 );
-    hal_remote_spt( XPTR( ref_cxy , &barrier_ptr->ident      ) , (void*)ident );
-
-    xlist_root_init( XPTR( ref_cxy , &barrier_ptr->root ) );
-
-    // register  barrier in reference process xlist
-    xptr_t root_xp  = XPTR( ref_cxy , &ref_ptr->barrier_root );
-    xptr_t entry_xp = XPTR( ref_cxy , &barrier_ptr->list );
-
-    remote_busylock_acquire( XPTR( ref_cxy , &ref_ptr->sync_lock ) );
-    xlist_add_first( root_xp , entry_xp );
-    remote_busylock_release( XPTR( ref_cxy , &ref_ptr->sync_lock ) );
-
-#if DEBUG_BARRIER
-cycle = (uint32_t)hal_get_cycles();
-if( cycle > DEBUG_BARRIER )
-printk("\n[DBG] %s : thread %x in process %x exit / barrier %x in cluster %x / cycle %d\n",
-__FUNCTION__, this->trdid, process->pid, barrier_ptr, ref_cxy, cycle );
-#endif
-
-    return 0;
-
-}  // end remote_barrier_create()
+if( cycle > DEBUG_BARRIER_CREATE )
+printk("\n[%s] thread[%x,%x] created barrier (%x,%x) / count %d / cycle %d\n",
+__FUNCTION__, process->pid, this->trdid, ref_cxy, barrier, count, cycle );
+#endif
+
+    return barrier;
+
+}  // end simple_barrier_create()
 
 ////////////////////////////////////////////////
-void remote_barrier_destroy( xptr_t barrier_xp )
+void simple_barrier_destroy( xptr_t barrier_xp )
 {
-    // get pointer on local process descriptor
-    process_t * process = CURRENT_THREAD->process;
-
-    // get extended pointer on reference process
-    xptr_t      ref_xp = process->ref_xp;
-
-    // get reference process cluster and local pointer
-    cxy_t       ref_cxy = GET_CXY( ref_xp );
-    process_t * ref_ptr = (process_t *)GET_PTR( ref_xp );
-
     // get barrier cluster and local pointer
     cxy_t              barrier_cxy = GET_CXY( barrier_xp );
-    remote_barrier_t * barrier_ptr = (remote_barrier_t *)GET_PTR( barrier_xp );
-
-    // remove barrier from reference process xlist
-    remote_busylock_acquire( XPTR( ref_cxy , &ref_ptr->sync_lock ) );
-    xlist_unlink( XPTR( barrier_cxy , &barrier_ptr->list ) );
-    remote_busylock_release( XPTR( ref_cxy , &ref_ptr->sync_lock ) );
+    simple_barrier_t * barrier_ptr = GET_PTR( barrier_xp );
 
     // release memory allocated for barrier descriptor
-    if( barrier_cxy == local_cxy )                        // reference is local
+    if( barrier_cxy == local_cxy ) 
     {
         kmem_req_t  req;
-        req.type = KMEM_BARRIER;
+        req.type = KMEM_SMP_BARRIER;
         req.ptr  = barrier_ptr;
         kmem_free( &req );
     }
-    else                                                  // reference is remote
-    {
-        rpc_kcm_free_client( barrier_cxy , barrier_ptr , KMEM_BARRIER );
-    }
-}  // end remote_barrier_destroy()
+    else  
+    {
+        rpc_kcm_free_client( barrier_cxy,
+                             barrier_ptr,
+                             KMEM_SMP_BARRIER );
+    }
+
+#if DEBUG_BARRIER_DESTROY
+uint32_t    cycle   = (uint32_t)hal_get_cycles();
+thread_t  * this    = CURRENT_THREAD;
+process_t * process = this->process;
+if( cycle > DEBUG_BARRIER_DESTROY )
+printk("\n[%s] thread[%x,%x] deleted barrier (%x,%x) / cycle %d\n",
+__FUNCTION__, process->pid, this->trdid, barrier_ptr, barrier_cxy, cycle );
+#endif
+
+}  // end simple_barrier_destroy()
 
 /////////////////////////////////////////////
-void remote_barrier_wait( xptr_t barrier_xp )
+void simple_barrier_wait( xptr_t barrier_xp )
 {
     uint32_t  expected;
     uint32_t  sense;
     uint32_t  current;
-    uint32_t  nb_threads;
+    uint32_t  arity;
     xptr_t    root_xp;
     xptr_t    lock_xp;
     xptr_t    current_xp;
     xptr_t    sense_xp;
-    xptr_t    nb_threads_xp;
+    xptr_t    arity_xp;
 
     // get pointer on calling thread
@@ -200 +358 @@
 
     // get cluster and local pointer on remote barrier
-    remote_barrier_t * barrier_ptr = GET_PTR( barrier_xp );
+    simple_barrier_t * barrier_ptr = GET_PTR( barrier_xp );
     cxy_t              barrier_cxy = GET_CXY( barrier_xp );
 
-#if DEBUG_BARRIER
+#if DEBUG_BARRIER_WAIT
 uint32_t cycle = (uint32_t)hal_get_cycles();
-if( cycle > DEBUG_BARRIER )
-printk("\n[DBG] %s : thread %x in process %x enter / barrier %x in cluster %x / cycle %d\n",
-__FUNCTION__, this->trdid, this->process->pid, barrier_ptr, barrier_cxy, cycle );
-#endif
-
-    // compute extended pointers on various barrier fields
-    lock_xp       = XPTR( barrier_cxy , &barrier_ptr->lock );
-    root_xp       = XPTR( barrier_cxy , &barrier_ptr->root );
-    current_xp    = XPTR( barrier_cxy , &barrier_ptr->current );
-    sense_xp      = XPTR( barrier_cxy , &barrier_ptr->sense );
-    nb_threads_xp = XPTR( barrier_cxy , &barrier_ptr->nb_threads );
-
-    // take busylock protecting the remote_barrier
+if( cycle > DEBUG_BARRIER_WAIT )
+printk("\n[%s] thread[%x,%x] enter / barrier (%x,%x) / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, barrier_cxy, barrier_ptr, cycle );
+#endif
+
+    // build extended pointers on various barrier descriptor fields
+    lock_xp    = XPTR( barrier_cxy , &barrier_ptr->lock );
+    root_xp    = XPTR( barrier_cxy , &barrier_ptr->root );
+    current_xp = XPTR( barrier_cxy , &barrier_ptr->current );
+    sense_xp   = XPTR( barrier_cxy , &barrier_ptr->sense );
+    arity_xp   = XPTR( barrier_cxy , &barrier_ptr->arity );
+
+    // take busylock protecting the barrier state
     remote_busylock_acquire( lock_xp );
 
-#if (DEBUG_BARRIER & 1)
-cycle = (uint32_t)hal_get_cycles();
-if( cycle > DEBUG_BARRIER )
-printk("\n[DBG] %s : thread %x in process %x get lock / cycle %d\n",
-__FUNCTION__, this->trdid, this->process->pid, cycle );
-#endif
-
-    // get sense and nb_threads values from barrier descriptor
-    sense      = hal_remote_l32( sense_xp );
-    nb_threads = hal_remote_l32( nb_threads_xp );
+    // get sense and threads values from barrier descriptor
+    sense = hal_remote_l32( sense_xp );
+    arity = hal_remote_l32( arity_xp );
 
     // compute expected value
@@ -235 +386 @@
     else              expected = 0;
 
-#if (DEBUG_BARRIER & 1)
-cycle = (uint32_t)hal_get_cycles();
-if( cycle > DEBUG_BARRIER )
-printk("\n[DBG] %s : thread %x in process %x / count %d / sense %d / cycle %d\n",
-__FUNCTION__, this->trdid, this->process->pid, nb_threads, sense, cycle );
-#endif
-
-    // atomically increment current, and get value before increment
+    // increment current number of arrived threads / get value before increment
     current = hal_remote_atomic_add( current_xp , 1 );
 
@@ -248 +392 @@
     // other threads block, register in queue, and deschedule
 
-    if( current == (nb_threads-1) )                       // last thread
+    if( current == (arity - 1) )                       // last thread
     {
         hal_remote_s32( current_xp , 0 );
@@ -261 +405 @@
             thread_t * thread_ptr = GET_PTR( thread_xp );
 
-#if (DEBUG_BARRIER & 1)
-cycle = (uint32_t)hal_get_cycles();
-if( cycle > DEBUG_BARRIER )
-printk("\n[DBG] %s : thread %x in process %x / unblock thread %x / cycle %d\n",
-__FUNCTION__, this->trdid, this->process->pid, thread_ptr, cycle );
+#if (DEBUG_BARRIER_WAIT & 1)
+trdid_t     trdid   = hal_remote_l32( XPTR( thread_cxy , &thread_ptr->trdid ) );
+process_t * process = hal_remote_lpt( XPTR( thread_cxy , &thread_ptr->process ) );
+pid_t       pid     = hal_remote_l32( XPTR( thread_cxy , &process->pid ) ); 
+if( cycle > DEBUG_BARRIER_WAIT )
+printk("\n[%s] thread[%x,%x] unblocks thread[%x,%x]\n",
+__FUNCTION__, this->process->pid, this->trdid, pid, trdid );
 #endif
 
@@ -275 +421 @@
         }
 
+        // release busylock protecting the barrier
+        remote_busylock_release( lock_xp );
+    }
+    else                                             // not the last thread
+    {
+
+#if (DEBUG_BARRIER_WAIT & 1)
+if( cycle > DEBUG_BARRIER_WAIT )
+printk("\n[%s] thread[%x,%x] blocks\n",
+__FUNCTION__, this->process->pid, this->trdid );
+#endif
+
+        // register calling thread in barrier waiting queue
+        xlist_add_last( root_xp , XPTR( local_cxy , &this->wait_list ) );
+
+        // block calling thread
+        thread_block( XPTR( local_cxy , this ) , THREAD_BLOCKED_USERSYNC );
+
         // release busylock protecting the remote_barrier
         remote_busylock_release( lock_xp );
-    }
-    else                                             // not the last thread
-    {
-
-#if (DEBUG_BARRIER & 1)
+
+        // deschedule
+        sched_yield("blocked on barrier");
+    }
+
+#if DEBUG_BARRIER_WAIT
 cycle = (uint32_t)hal_get_cycles();
-if( cycle > DEBUG_BARRIER )
-printk("\n[DBG] %s : thread %x in process %x / blocked / cycle %d\n",
-__FUNCTION__, this->trdid, this->process->pid, cycle );
-#endif
-
+if( cycle > DEBUG_BARRIER_WAIT )
+printk("\n[%s] thread[%x,%x] exit / barrier (%x,%x) / cycle %d\n",
+__FUNCTION__, this->trdid, this->process->pid, barrier_cxy, barrier_ptr, cycle );
+#endif
+
+}  // end simple_barrier_wait()
+
+
+/////////////////////////////////////////////////////////////
+//      DQT barrier functions
+/////////////////////////////////////////////////////////////
+
+static void dqt_barrier_increment( xptr_t node_xp );
+
+#if DEBUG_BARRIER_CREATE
+static void dqt_barrier_display( xptr_t  barrier_xp );
+#endif
+
+///////////////////////////////////////////////////////
+dqt_barrier_t * dqt_barrier_create( uint32_t    x_size,
+                                    uint32_t    y_size,
+                                    uint32_t    nthreads )
+{
+    page_t        * dqt_page;
+    xptr_t          dqt_page_xp;     
+    page_t        * rpc_page;
+    xptr_t          rpc_page_xp;     
+    dqt_barrier_t * barrier;       // local pointer on DQT barrier descriptor
+    xptr_t          barrier_xp;    // extended pointer on DQT barrier descriptor
+    uint32_t        z;             // actual DQT size == max(x_size,y_size)
+    uint32_t        levels;        // actual number of DQT levels
+    kmem_req_t      req;           // kmem request
+    xptr_t          rpc_xp;        // extended pointer on RPC descriptors array
+    rpc_desc_t    * rpc;           // pointer on RPC descriptors array
+    uint32_t        responses;     // responses counter for parallel RPCs
+    reg_t           save_sr;       // for critical section
+    uint32_t        x;             // X coordinate in QDT mesh
+    uint32_t        y;             // Y coordinate in QDT mesh
+    uint32_t        l;             // level coordinate
+
+    // compute size and number of DQT levels
+    z      = (x_size > y_size) ? x_size : y_size;
+    levels = (z < 2) ? 1 : (z < 3) ? 2 : (z < 5) ? 3 : (z < 9) ? 4 : 5;
+
+// check x_size and y_size arguments
+assert( (z <= 16) , "DQT dqth larger than (16*16)\n");
+
+// check RPC descriptor size
+assert( (sizeof(rpc_desc_t) <= 128), "RPC descriptor  larger than 128 bytes\n");
+
+// check size of an array of 5 DQT nodes
+assert( (sizeof(dqt_node_t) * 5 <= 512 ), "array of DQT nodes larger than 512 bytes\n");
+
+// check size of DQT barrier descriptor
+assert( (sizeof(dqt_barrier_t) <= 0x4000 ), "DQT barrier descriptor larger than 4 pages\n");
+
+    // get pointer on local client process descriptor
+    thread_t  * this    = CURRENT_THREAD;
+    process_t * process = this->process;
+
+#if DEBUG_BARRIER_CREATE
+uint32_t   cycle = (uint32_t)hal_get_cycles();
+if( cycle > DEBUG_BARRIER_CREATE ) 
+printk("\n[%s] thread[%x,%x] enter : x_size %d / y_size %d / levels %d / cycle %d\n",
+__FUNCTION__, process->pid, this->trdid, x_size, y_size, levels, cycle );
+#endif
+
+    // get reference process cluster
+    xptr_t         ref_xp  = process->ref_xp;
+    cxy_t          ref_cxy = GET_CXY( ref_xp );
+
+    // 1. allocate memory for DQT barrier descriptor in reference cluster
+    if( ref_cxy == local_cxy )                    
+     {
+        req.type     = KMEM_PAGE;
+        req.size     = 2;               // 4 pages == 16 Kbytes
+        req.flags    = AF_ZERO;
+        dqt_page     = kmem_alloc( &req );
+        dqt_page_xp  = XPTR( local_cxy , dqt_page );
+    }
+    else                                         
+    {
+        rpc_pmem_get_pages_client( ref_cxy,
+                                   2,
+                                   &dqt_page );
+        dqt_page_xp  = XPTR( ref_cxy , dqt_page );
+    }
+
+    if( dqt_page == NULL ) return NULL;
+
+    // get pointers on DQT barrier descriptor
+    barrier_xp = ppm_page2base( dqt_page_xp );
+    barrier    = GET_PTR( barrier_xp );
+
+    // initialize global parameters in DQT barrier descriptor
+    hal_remote_s32( XPTR( ref_cxy , &barrier->x_size   ) , x_size );
+    hal_remote_s32( XPTR( ref_cxy , &barrier->y_size   ) , x_size );
+    hal_remote_s32( XPTR( ref_cxy , &barrier->nthreads ) , nthreads );
+
+#if DEBUG_BARRIER_CREATE
+if( cycle > DEBUG_BARRIER_CREATE ) 
+printk("\n[%s] thread[%x,%x] created DQT barrier descriptor at (%x,%x)\n",
+__FUNCTION__, process->pid, this->trdid, ref_cxy, barrier );
+#endif
+
+    // 2. allocate memory from local cluster for an array of 256 RPCs descriptors
+    //    cannot share the RPC descriptor, because the returned argument is not shared
+    req.type    = KMEM_PAGE;
+    req.size    = 3;            // 8 pages == 32 Kbytes 
+    req.flags   = AF_ZERO;
+    rpc_page    = kmem_alloc( &req );
+    rpc_page_xp = XPTR( local_cxy , rpc_page );
+
+    // get pointers on RPC descriptors array
+    rpc_xp    = ppm_page2base( rpc_page_xp );
+    rpc       = GET_PTR( rpc_xp );
+
+#if DEBUG_BARRIER_CREATE
+if( cycle > DEBUG_BARRIER_CREATE ) 
+printk("\n[%s] thread[%x,%x] created RPC descriptors array at (%x,%s)\n",
+__FUNCTION__, process->pid, this->trdid, local_cxy, rpc );
+#endif
+
+    // 3. send parallel RPCs to all existing clusters covered by the DQT
+    //    to allocate memory for an array of 5 DQT nodes in each cluster
+    //    (5 nodes per cluster <= 512 bytes per cluster)
+
+    responses = 0;    // initialize RPC responses counter
+
+    // mask IRQs
+    hal_disable_irq( &save_sr);
+
+    // client thread blocks itself
+    thread_block( XPTR( local_cxy , this ) , THREAD_BLOCKED_RPC );
+
+    for ( x = 0 ; x < x_size ; x++ )
+    {
+        for ( y = 0 ; y < y_size ; y++ )
+        {
+            // send RPC to existing clusters only
+            if( LOCAL_CLUSTER->cluster_info[x][y] )
+            {
+                cxy_t cxy = HAL_CXY_FROM_XY( x , y );   // target cluster identifier
+
+                // build a specific RPC descriptor for each target cluster
+                rpc[cxy].rsp       = &responses;
+                rpc[cxy].blocking  = false;
+                rpc[cxy].index     = RPC_KCM_ALLOC;
+                rpc[cxy].thread    = this;
+                rpc[cxy].lid       = this->core->lid;
+                rpc[cxy].args[0]   = (uint64_t)KMEM_512_BYTES;  
+
+                // atomically increment expected responses counter
+                hal_atomic_add( &responses , 1 );
+
+                // send a non-blocking RPC to allocate 512 bytes in target cluster 
+                rpc_send( cxy , &rpc[cxy] ); 
+            }
+        }
+    }
+
+#if DEBUG_BARRIER_CREATE
+if( cycle > DEBUG_BARRIER_CREATE ) 
+printk("\n[%s] thread[%x,%x] sent all RPC requests to allocate dqt_nodes array\n",
+__FUNCTION__, process->pid, this->trdid );
+#endif
+
+    // client thread deschedule
+    sched_yield("blocked on parallel rpc_kcm_alloc");
+
+    // restore IRQs
+    hal_restore_irq( save_sr);
+
+    // 4. initialize the node_xp[x][y][l] array in DQT barrier descriptor
+    //    the node_xp[x][y][0] value is available in rpc.args[1]
+
+#if DEBUG_BARRIER_CREATE
+if( cycle > DEBUG_BARRIER_CREATE ) 
+printk("\n[%s] thread[%x,%x] initialises array of pointers on dqt_nodes\n",
+__FUNCTION__, process->pid, this->trdid );
+#endif
+
+    for ( x = 0 ; x < x_size ; x++ )
+    {
+        for ( y = 0 ; y < y_size ; y++ )
+        {
+            cxy_t    cxy      = HAL_CXY_FROM_XY( x , y );   // target cluster identifier
+            xptr_t   array_xp = (xptr_t)rpc[cxy].args[1];   // x_pointer on node array 
+            uint32_t offset   = sizeof( dqt_node_t );       // size of a DQT node
+                
+            // set values into the node_xp[x][y][l] array 
+            for ( l = 0 ; l < levels ; l++ )
+            {
+                xptr_t  node_xp = array_xp + (offset * l);
+                hal_remote_s64( XPTR( ref_cxy , &barrier->node_xp[x][y][l] ), node_xp );
+
+#if DEBUG_BARRIER_CREATE
+if( cycle > DEBUG_BARRIER_CREATE )
+printk(" - dqt_node_xp[%d,%d,%d] = (%x,%x) / &dqt_node_xp = %x\n",
+x , y , l , GET_CXY( node_xp ), GET_PTR( node_xp ), &barrier->node_xp[x][y][l] );
+#endif
+            }
+        }
+    }
+
+    // 5. release memory locally allocated for the RPCs array
+    req.type  = KMEM_PAGE;
+    req.ptr   = rpc_page;
+    kmem_free( &req );
+
+#if DEBUG_BARRIER_CREATE
+if( cycle > DEBUG_BARRIER_CREATE ) 
+printk("\n[%s] thread[%x,%x] released memory for RPC descriptors array\n",
+__FUNCTION__, process->pid, this->trdid );
+#endif
+
+    // 6. initialise all distributed DQT nodes using remote accesses
+    //    and the pointers stored in the node_xp[x][y][l] array
+    for ( x = 0 ; x < x_size ; x++ )
+    {
+        for ( y = 0 ; y < y_size ; y++ )
+        {
+            // initialize existing clusters only
+            if( LOCAL_CLUSTER->cluster_info[x][y] )
+            {
+                for ( l = 0 ; l < levels ; l++ )
+                {
+                                    xptr_t    parent_xp;
+                    xptr_t    child_xp[4];
+                    uint32_t  arity = 0;
+
+                    // get DQT node pointers
+                    xptr_t       node_xp  = hal_remote_l64( XPTR( ref_cxy,
+                                            &barrier->node_xp[x][y][l] ) );
+                    cxy_t        node_cxy = GET_CXY( node_xp );
+                    dqt_node_t * node_ptr = GET_PTR( node_xp ); 
+
+                    // compute arity and child_xp[i] 
+                    if (l == 0 )                            // bottom DQT node
+                    {
+                        arity       = nthreads;
+
+                        child_xp[0] = XPTR_NULL;
+                        child_xp[1] = XPTR_NULL;
+                        child_xp[2] = XPTR_NULL;
+                        child_xp[3] = XPTR_NULL;
+                    }
+                    else                                    // not a bottom DQT node
+                    {
+                        arity = 0;
+
+                        // only few non-bottom nodes must be initialised
+                        if( ((x & ((1<<l)-1)) == 0) && ((y & ((1<<l)-1)) == 0) )
+                        {
+                            uint32_t cx[4];       // x coordinate for children
+                            uint32_t cy[4];       // y coordinate for children
+                            uint32_t i;
+
+                            // the child0 coordinates are equal to the parent coordinates
+                            // other children coordinates depend on the level value
+                            cx[0] = x;
+                            cy[0] = y;
+
+                            cx[1] = x;
+                            cy[1] = y + (1 << (l-1));
+
+                            cx[2] = x + (1 << (l-1));
+                            cy[2] = y;
+
+                            cx[3] = x + (1 << (l-1));
+                            cy[3] = y + (1 << (l-1));
+
+                            for ( i = 0 ; i < 4 ; i++ )
+                            {
+                                // child pointer is NULL if  outside the mesh
+                                if ( (cx[i] < x_size) && (cy[i] < y_size) ) 
+                                {
+                                    // get child_xp[i] 
+                                    child_xp[i] = hal_remote_l64( XPTR( ref_cxy,
+                                                  &barrier->node_xp[cx[i]][cy[i]][l-1] ) );
+
+                                    // increment arity
+                                    arity++;
+                                }
+                                else
+                                {
+                                    child_xp[i] = XPTR_NULL;
+                                }
+                            }
+                        }
+                    }
+
+                    // compute parent_xp
+                    if( l == (levels - 1) )                      // root DQT node
+                    {
+                        parent_xp = XPTR_NULL;
+                    }
+                    else                                          // not the root
+                    {
+                        uint32_t px = 0;           // parent X coordinate
+                        uint32_t py = 0;           // parent Y coordinate
+                        bool_t   found = false;
+
+                        // compute macro_cluster x_min, x_max, y_min, y_max                
+                        uint32_t x_min = x & ~((1<<(l+1))-1);
+                        uint32_t x_max = x_min + (1<<(l+1));
+                        uint32_t y_min = y & ~((1<<(l+1))-1);
+                        uint32_t y_max = y_min + (1<<(l+1));
+
+                        // scan all clusters in macro-cluster[x][y][l] / take first active
+                        for( px = x_min ; px < x_max ; px++ )
+                        {
+                            for( py = y_min ; py < y_max ; py++ )
+                            {
+                                if( LOCAL_CLUSTER->cluster_info[px][py] ) found = true;
+                                if( found ) break;
+                            }
+                            if( found ) break;
+                        }
+
+                        parent_xp = hal_remote_l64( XPTR( ref_cxy ,
+                                    &barrier->node_xp[px][py][l+1] ) );
+                    }
+
+                    // initializes  the DQT node
+                    hal_remote_s32( XPTR( node_cxy , &node_ptr->arity )       , arity );   
+                    hal_remote_s32( XPTR( node_cxy , &node_ptr->current )     , 0 );   
+                    hal_remote_s32( XPTR( node_cxy , &node_ptr->sense )       , 0 );   
+                    hal_remote_s32( XPTR( node_cxy , &node_ptr->level )       , l );   
+                    hal_remote_s64( XPTR( node_cxy , &node_ptr->parent_xp )   , parent_xp );
+                    hal_remote_s64( XPTR( node_cxy , &node_ptr->child_xp[0] ) , child_xp[0] );
+                    hal_remote_s64( XPTR( node_cxy , &node_ptr->child_xp[1] ) , child_xp[1] );
+                    hal_remote_s64( XPTR( node_cxy , &node_ptr->child_xp[2] ) , child_xp[2] );
+                    hal_remote_s64( XPTR( node_cxy , &node_ptr->child_xp[3] ) , child_xp[3] );
+
+                    xlist_root_init( XPTR( node_cxy , &node_ptr->root ) );
+
+                    remote_busylock_init( XPTR( node_cxy , &node_ptr->lock ),
+                                          LOCK_BARRIER_STATE );
+                }
+            }
+        }
+    }
+
+#if DEBUG_BARRIER_CREATE 
+cycle = (uint32_t)hal_get_cycles();
+if( cycle > DEBUG_BARRIER_CREATE ) 
+printk("\n[%s] thread[%x,%x] completed DQT barrier initialisation / cycle %d\n",
+__FUNCTION__, process->pid, this->trdid, cycle );
+dqt_barrier_display( barrier_xp );
+#endif
+
+    return barrier;
+
+}  // end dqt_barrier_create()
+
+///////////////////////////////////////////////
+void dqt_barrier_destroy( xptr_t   barrier_xp )
+{
+    page_t     * rpc_page;
+    xptr_t       rpc_page_xp;
+    rpc_desc_t * rpc;                      // local pointer on RPC descriptors array
+    xptr_t       rpc_xp;                   // extended pointer on RPC descriptor array
+    reg_t        save_sr;                  // for critical section
+    kmem_req_t   req;                      // kmem request
+
+    thread_t * this = CURRENT_THREAD;
+
+    // get DQT barrier descriptor cluster and local pointer
+    dqt_barrier_t * barrier_ptr = GET_PTR( barrier_xp );
+    cxy_t           barrier_cxy = GET_CXY( barrier_xp );
+
+#if DEBUG_BARRIER_DESTROY
+uint32_t   cycle = (uint32_t)hal_get_cycles();
+if( cycle > DEBUG_BARRIER_DESTROY ) 
+printk("\n[%s] thread[%x,%x] enter for barrier (%x,%x) / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, barrier_cxy, barrier_ptr, cycle );
+#endif
+
+    // get x_size and y_size global parameters
+    uint32_t x_size = hal_remote_l32( XPTR( barrier_cxy , &barrier_ptr->x_size ) );
+    uint32_t y_size = hal_remote_l32( XPTR( barrier_cxy , &barrier_ptr->y_size ) );
+
+    // 1. allocate memory from local cluster for an array of 256 RPCs descriptors
+    //    cannot share the RPC descriptor, because the "buf" argument is not shared
+    req.type    = KMEM_PAGE;
+    req.size    = 3;            // 8 pages == 32 Kbytes 
+    req.flags   = AF_ZERO;
+    rpc_page    = kmem_alloc( &req );
+    rpc_page_xp = XPTR( local_cxy , rpc_page );
+
+    // get pointers on RPC descriptors array
+    rpc_xp    = ppm_page2base( rpc_page_xp );
+    rpc       = GET_PTR( rpc_xp );
+   
+    // 2. send parallel RPCs to all existing clusters covered by the DQT
+    //    to release memory allocated for the arrays of DQT nodes in each cluster
+
+    uint32_t responses = 0;    // initialize RPC responses counter
+
+    // mask IRQs
+    hal_disable_irq( &save_sr);
+
+    // client thread blocks itself
+    thread_block( XPTR( local_cxy , this ) , THREAD_BLOCKED_RPC );
+
+    uint32_t x , y;
+    
+#if DEBUG_BARRIER_DESTROY
+if( cycle > DEBUG_BARRIER_DESTROY ) 
+printk("\n[%s] thread[%x,%x] send RPCs to release the distributed dqt_node array\n",
+__FUNCTION__, this->process->pid, this->trdid );
+#endif
+
+    for ( x = 0 ; x < x_size ; x++ )
+    {
+        for ( y = 0 ; y < y_size ; y++ )
+        {
+            // send RPC to existing cluster only
+            if( LOCAL_CLUSTER->cluster_info[x][y] )
+            {
+                // compute target cluster identifier
+                cxy_t   cxy       = HAL_CXY_FROM_XY( x , y ); 
+
+                // get local pointer on dqt_nodes array in target cluster  
+                xptr_t  buf_xp_xp = XPTR( barrier_cxy , &barrier_ptr->node_xp[x][y][0] );
+                xptr_t  buf_xp    = hal_remote_l64( buf_xp_xp );
+                void  * buf       = GET_PTR( buf_xp );
+
+assert( (cxy == GET_CXY(buf_xp)) , "bad extended pointer on dqt_nodes array\n" );
+
+                // build a specific RPC descriptor 
+                rpc[cxy].rsp       = &responses;
+                rpc[cxy].blocking  = false;
+                rpc[cxy].index     = RPC_KCM_FREE;
+                rpc[cxy].thread    = this;
+                rpc[cxy].lid       = this->core->lid;
+                rpc[cxy].args[0]   = (uint64_t)(intptr_t)buf;  
+                rpc[cxy].args[1]   = (uint64_t)KMEM_512_BYTES;  
+
+                // atomically increment expected responses counter
+                hal_atomic_add( &responses , 1 );
+            
+#if DEBUG_BARRIER_DESTROY
+if( cycle > DEBUG_BARRIER_DESTROY ) 
+printk(" - target cluster(%d,%d) / buffer %x\n", x, y, buf );
+#endif
+                // send a non-blocking RPC to release 512 bytes in target cluster 
+                rpc_send( cxy , &rpc[cxy] ); 
+            }
+        }
+    }
+
+    // client thread deschedule
+    sched_yield("blocked on parallel rpc_kcm_free");
+
+    // restore IRQs
+    hal_restore_irq( save_sr);
+
+    // 3. release memory locally allocated for the RPC descriptors array
+    req.type  = KMEM_PAGE;
+    req.ptr   = rpc_page;
+    kmem_free( &req );
+
+    // 4. release memory allocated for barrier descriptor 
+    xptr_t   page_xp = ppm_base2page( barrier_xp );
+    page_t * page    = GET_PTR( page_xp );
+
+    if( barrier_cxy == local_cxy )                    
+    {
+        req.type      = KMEM_PAGE;
+        req.ptr       = page;
+        kmem_free( &req );
+    }
+    else                                         
+    {
+        rpc_pmem_release_pages_client( barrier_cxy,
+                                       page );
+    }
+
+#if DEBUG_BARRIER_DESTROY
+cycle = (uint32_t)hal_get_cycles();
+if( cycle > DEBUG_BARRIER_DESTROY ) 
+printk("\n[%s] thread[%x,%x] exit for barrier (%x,%x) / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, barrier_cxy, barrier_ptr, cycle );
+#endif
+
+}  // end dqt_barrier_destroy()
+
+////////////////////////////////////////////
+void dqt_barrier_wait( xptr_t   barrier_xp )
+{
+    thread_t * this = CURRENT_THREAD;
+
+    // check calling thread can yield
+    thread_assert_can_yield( this , __FUNCTION__ );
+
+    // get cluster and local pointer on DQT barrier descriptor
+    dqt_barrier_t * barrier_ptr = GET_PTR( barrier_xp );
+    cxy_t           barrier_cxy = GET_CXY( barrier_xp );
+
+#if DEBUG_BARRIER_WAIT
+uint32_t cycle = (uint32_t)hal_get_cycles();
+if( cycle > DEBUG_BARRIER_WAIT )
+printk("\n[%s] thread[%x,%x] enter / barrier (%x,%x) / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, barrier_cxy, barrier_ptr, cycle );
+#endif
+
+    // get extended pointer on local bottom DQT node
+    uint32_t x       = HAL_X_FROM_CXY( local_cxy );
+    uint32_t y       = HAL_Y_FROM_CXY( local_cxy );
+    xptr_t   node_xp = hal_remote_l64( XPTR( barrier_cxy , &barrier_ptr->node_xp[x][y][0] ) );
+
+    // call recursive function to traverse DQT from bottom to root
+    dqt_barrier_increment( node_xp );
+
+#if DEBUG_BARRIER_WAIT
+cycle = (uint32_t)hal_get_cycles();
+if( cycle > DEBUG_BARRIER_WAIT )
+printk("\n[%s] thread[%x,%x] exit / barrier (%x,%x) / cycle %d\n",
+__FUNCTION__, this->trdid, this->process->pid, barrier_cxy, barrier_ptr, cycle );
+#endif
+
+}  // end dqt_barrier_wait()
+
+
+////////////////////////////////////////////////////////////////////////////////////////////
+//          DQT static functions 
+////////////////////////////////////////////////////////////////////////////////////////////
+
+
+//////////////////////////////////////////////////////////////////////////////////////////
+// This recursive function decrements the distributed "count" variables,
+// traversing the DQT from bottom to root.
+// The last arrived thread reset the local node before returning.
+//////////////////////////////////////////////////////////////////////////////////////////
+static void dqt_barrier_increment( xptr_t  node_xp )
+{
+    uint32_t   expected;
+    uint32_t   sense;
+    uint32_t   arity;
+
+    thread_t * this = CURRENT_THREAD;
+
+    // get node cluster and local pointer
+    dqt_node_t * node_ptr = GET_PTR( node_xp );
+    cxy_t        node_cxy = GET_CXY( node_xp );
+
+    // build relevant extended pointers
+    xptr_t  arity_xp   = XPTR( node_cxy , &node_ptr->arity );
+    xptr_t  sense_xp   = XPTR( node_cxy , &node_ptr->sense );
+    xptr_t  current_xp = XPTR( node_cxy , &node_ptr->current );
+    xptr_t  lock_xp    = XPTR( node_cxy , &node_ptr->lock );
+    xptr_t  root_xp    = XPTR( node_cxy , &node_ptr->root );
+
+#if DEBUG_BARRIER_WAIT
+uint32_t   cycle = (uint32_t)hal_get_cycles();
+uint32_t   level = hal_remote_l32( XPTR( node_cxy, &node_ptr->level ) );
+if( cycle > DEBUG_BARRIER_WAIT )
+printk("\n[%s] thread[%x,%x] increments DQT node(%d,%d,%d) / cycle %d\n",
+__FUNCTION__ , this->process->pid, this->trdid, 
+HAL_X_FROM_CXY(node_cxy), HAL_Y_FROM_CXY(node_cxy), level );
+#endif
+
+    // get extended pointer on parent node
+    xptr_t  parent_xp  = hal_remote_l64( XPTR( node_cxy , &node_ptr->parent_xp ) );
+
+    // take busylock
+    remote_busylock_acquire( lock_xp );
+    
+    // get sense and arity values from barrier descriptor
+    sense = hal_remote_l32( sense_xp );
+    arity = hal_remote_l32( arity_xp );
+
+    // compute expected value 
+    expected = (sense == 0) ? 1 : 0;
+
+    // increment current number of arrived threads / get value before increment
+    uint32_t current = hal_remote_atomic_add( current_xp , 1 );
+
+    // last arrived thread reset the local node, makes the recursive call 
+    // on parent node, and reactivates all waiting thread when returning.
+    // other threads block, register in queue, and deschedule.
+
+    if ( current == (arity - 1) )                        // last thread  
+    {
+
+#if DEBUG_BARRIER_WAIT
+if( cycle > DEBUG_BARRIER_WAIT )
+printk("\n[%s] thread[%x,%x] reset DQT node(%d,%d,%d)\n",
+__FUNCTION__ , this->process->pid, this->trdid,
+HAL_X_FROM_CXY(node_cxy), HAL_Y_FROM_CXY(node_cxy), level );
+#endif
+        // reset the current node
+        hal_remote_s32( sense_xp   , expected );
+        hal_remote_s32( current_xp , 0 );
+
+        // release busylock protecting the current node
+        remote_busylock_release( lock_xp );
+
+        // recursive call on parent node when current node is not the root
+        if( parent_xp != XPTR_NULL) dqt_barrier_increment( parent_xp );
+
+        // unblock all waiting threads on this node
+        while( xlist_is_empty( root_xp ) == false )
+        {
+            // get pointers on first waiting thread
+            xptr_t     thread_xp  = XLIST_FIRST( root_xp , thread_t , wait_list );
+            cxy_t      thread_cxy = GET_CXY( thread_xp );
+            thread_t * thread_ptr = GET_PTR( thread_xp );
+
+#if (DEBUG_BARRIER_WAIT & 1)
+trdid_t     trdid   = hal_remote_l32( XPTR( thread_cxy , &thread_ptr->trdid ) );
+process_t * process = hal_remote_lpt( XPTR( thread_cxy , &thread_ptr->process ) );
+pid_t       pid     = hal_remote_l32( XPTR( thread_cxy , &process->pid ) ); 
+if( cycle > DEBUG_BARRIER_WAIT )
+printk("\n[%s] thread[%x,%x] unblock thread[%x,%x]\n",
+__FUNCTION__, this->process->pid, this->trdid, pid, trdid );
+#endif
+            // remove waiting thread from queue
+            xlist_unlink( XPTR( thread_cxy , &thread_ptr->wait_list ) );
+
+            // unblock waiting thread
+            thread_unblock( thread_xp , THREAD_BLOCKED_USERSYNC );
+        }
+    }
+    else                                               // not the last thread
+    {
+        // get extended pointer on xlist entry from thread
+        xptr_t  entry_xp = XPTR( local_cxy , &this->wait_list );
+        
         // register calling thread in barrier waiting queue
-        xlist_add_last( root_xp , XPTR( local_cxy , &this->wait_list ) );
+        xlist_add_last( root_xp , entry_xp );
 
         // block calling thread
@@ -297 +1088 @@
         remote_busylock_release( lock_xp );
 
+#if DEBUG_BARRIER_WAIT
+if( cycle > DEBUG_BARRIER_WAIT )
+printk("\n[%s] thread[%x,%x] blocks on node(%d,%d,%d)\n",
+__FUNCTION__ , this->process->pid, this->trdid,
+HAL_X_FROM_CXY(node_cxy), HAL_Y_FROM_CXY(node_cxy), level );
+#endif
         // deschedule
         sched_yield("blocked on barrier");
     }
 
-#if DEBUG_BARRIER
-cycle = (uint32_t)hal_get_cycles();
-if( cycle > DEBUG_BARRIER )
-printk("\n[DBG] %s : thread %x in process %x exit / barrier %x in cluster %x / cycle %d\n",
-__FUNCTION__, this->trdid, this->process->pid, barrier_ptr, barrier_cxy, cycle );
-#endif
-
-}  // end remote_barrier_wait()
+    return;
+
+} // end dqt_barrier_decrement()
+
+#if DEBUG_BARRIER_CREATE 
+
+////////////////////////////////////////////////////////////////////////////////////////////
+// This debug function displays all DQT nodes in all clusters.
+////////////////////////////////////////////////////////////////////////////////////////////
+// @ barrier_xp   : extended pointer on DQT barrier descriptor.
+////////////////////////////////////////////////////////////////////////////////////////////
+static void dqt_barrier_display( xptr_t  barrier_xp )
+{
+    // get cluster and local pointer on DQT barrier 
+    dqt_barrier_t * barrier_ptr = GET_PTR( barrier_xp );
+    cxy_t           barrier_cxy = GET_CXY( barrier_xp );
+
+    // get barrier global parameters
+    uint32_t x_size   = hal_remote_l32( XPTR( barrier_cxy , &barrier_ptr->x_size ) );
+    uint32_t y_size   = hal_remote_l32( XPTR( barrier_cxy , &barrier_ptr->y_size ) );
+    uint32_t nthreads = hal_remote_l32( XPTR( barrier_cxy , &barrier_ptr->nthreads ) );
+
+    // compute size and number of DQT levels
+    uint32_t z      = (x_size > y_size) ? x_size : y_size;
+    uint32_t levels = (z < 2) ? 1 : (z < 3) ? 2 : (z < 5) ? 3 : (z < 9) ? 4 : 5;
+
+    printk("\n***** DQT barrier : x_size %d / y_size %d / nthreads %d / levels %d *****\n",
+    x_size, y_size, nthreads, levels );
+
+    uint32_t x , y , l;
+
+    for ( x = 0 ; x < x_size ; x++ )
+    {
+        for ( y = 0 ; y < y_size ; y++ )
+        {
+            printk(" - cluster[%d,%d]\n", x , y );
+
+            for ( l = 0 ; l < levels ; l++ )
+            {
+                // get pointers on target node
+                xptr_t       node_xp  = hal_remote_l64( XPTR( barrier_cxy ,
+                                        &barrier_ptr->node_xp[x][y][l] ) );
+                dqt_node_t * node_ptr = GET_PTR( node_xp );
+                cxy_t        node_cxy = GET_CXY( node_xp );
+
+                if( node_xp != XPTR_NULL )
+                {
+                     uint32_t level = hal_remote_l32( XPTR( node_cxy , &node_ptr->level       ));
+                     uint32_t arity = hal_remote_l32( XPTR( node_cxy , &node_ptr->arity       ));
+                     xptr_t   pa_xp = hal_remote_l32( XPTR( node_cxy , &node_ptr->parent_xp   ));
+                     xptr_t   c0_xp = hal_remote_l32( XPTR( node_cxy , &node_ptr->child_xp[0] ));
+                     xptr_t   c1_xp = hal_remote_l32( XPTR( node_cxy , &node_ptr->child_xp[1] ));
+                     xptr_t   c2_xp = hal_remote_l32( XPTR( node_cxy , &node_ptr->child_xp[2] ));
+                     xptr_t   c3_xp = hal_remote_l32( XPTR( node_cxy , &node_ptr->child_xp[3] ));
+
+                     printk("   . level %d : (%x,%x) / arity %d / P(%x,%x) / C0(%x,%x)"
+                            " C1(%x,%x) / C2(%x,%x) / C3(%x,%x)\n",
+                     level, node_cxy, node_ptr, arity, 
+                     GET_CXY(pa_xp), GET_PTR(pa_xp),
+                     GET_CXY(c0_xp), GET_PTR(c0_xp),
+                     GET_CXY(c1_xp), GET_PTR(c1_xp),
+                     GET_CXY(c2_xp), GET_PTR(c2_xp),
+                     GET_CXY(c3_xp), GET_PTR(c3_xp) );
+                }
+            }
+        }
+    }
+}   // end dqt_barrier_display()
+
+#endif

trunk/kernel/libk/remote_barrier.h

@@ -2 +2 @@
  * remote_barrier.h - POSIX barrier definition.               
  * 
- * Author  Alain Greiner (2016,2017,2018)
+ * Author  Alain Greiner (2016,2017,2018,2019)
  *
  * Copyright (c) UPMC Sorbonne Universites
@@ -29 +29 @@
 #include <remote_busylock.h>
 #include <xlist.h>
+#include <shared_pthread.h>
 
 /***************************************************************************************
- *          This file defines a POSIX compliant barrier.
+ *       This file defines two implementations for a POSIX compliant barrier.
  *
  * It is used by multi-threaded user applications to synchronise threads running in
- * different clusters, as all access functions uses hal_remote_l32() / hal_remote_s32()
- * remote access primitives.
- *
- * A barrier is declared by a given user process as a "pthread_barrier_t" global variable.
- * This user type is implemented as an unsigned long, but the value is not used by the 
- * kernel. ALMOS-MKH uses only the barrier virtual address as an identifier.
- * For each user barrier, ALMOS-MKH creates a kernel "remote_barrier_t" structure,
- * dynamically allocated in the reference cluster by the remote_barrier_create() function, 
- * and destroyed by the remote_barrier_destroy() function, using RPC if the calling thread
- * is not running in the reference cluster.
- *
- * The blocking "remote_barrier_wait()" function implements a descheduling policy when
- * the calling thread is not the last expected thread: the calling thread is registered 
- * in a waiting queue, rooted in the barrier structure, and the the calling thread 
- * is blocked on the THREAD_BLOCKED_USERSYNC condition. The last arrived thread
- * unblocks all registtered waiting threads.
+ * different clusters. Access functions use RPCs for barrier creation/destruction,
+ * and use remote access primitives for actual synchronisation (wait function).
+ *
+ * A barrier is declared by a given user process as a "pthread_barrier_t" user variable.
+ * This user type is implemented in user space as an unsigned long, but the value is not
+ * used by the kernel. ALMOS-MKH uses only the barrier virtual address as an identifier.
+ * For each user barrier, ALMOS-MKH creates a kernel structure, dynamically allocated 
+ * by the "generic_barrier_create()" function, destroyed by the "remote_barrier_destroy()"
+ * function, and used by the "generic_barrier_wait()" function.
+ *
+ * Implementation note:
+ * ALMOS-MKH supports two barrier implementations:
+ *
+ * 1) simple_barrier_t
+ *    If the pointer on the barrier attributes is NULL, the barrier is implemented as
+ *    a shared variable localized in the reference process cluster. 
+ *    There is a risk of contention when the number of synchronizing threads is large.
+ *
+ * 2) dqt_barrier_t
+ *    If the (x_size, y_size, nthreads) arguments are defined in the barrier attributes,
+ *    the barrier is implemented as a hierarchical quad-tree covering all clusters in the
+ *    (x_size * ysize) mesh, including cluster (0,0), with nthreads per cluster, and called
+ *    DQT : Distributed Quad Tree. This DQT implementation supposes a regular architecture, 
+ *    and a strong contraint on the threads placement: exactly "nthreads" threads per 
+ *    cluster in the (x_size * y_size) mesh.
+ *
+ * For both implementations, the blocking "generic_barrier_wait()" function implements
+ * a descheduling policy when the calling thread is not the last expected thread: 
+ * the calling thread is registered in a waiting queue, rooted in the barrier structure, 
+ * and the the calling thread is blocked on the THREAD_BLOCKED_USERSYNC condition. 
+ * The last arrived thread unblocks all registered waiting threads.
  * **************************************************************************************/
 
-/*****************************************************************************************
- * This structure defines the barrier descriptor.
- * - It contains an xlist of all barriers dynamically created by a given process,
- *   rooted in the reference process descriptor.
- * - It contains the root of another xlist to register all arrived threads.
- ****************************************************************************************/
-
-typedef struct remote_barrier_s
-{
-    remote_busylock_t  lock;          /*! lock protecting list of waiting threads       */
-    intptr_t           ident;         /*! virtual address in user space == identifier   */
-    uint32_t           current;       /*! number of arrived threads                     */
-    uint32_t           sense;         /*! barrier state (toggle)                        */
-    uint32_t           nb_threads;    /*! number of expected threads                    */ 
-    xlist_entry_t      list;          /*! member of list of barriers in same process    */
-    xlist_entry_t      root;          /*! root of list of waiting threads               */
+
+
+/*****************************************************************************************
+ *                 generic barrier descriptor and access functions
+ *****************************************************************************************
+ * This generic structure is used by both the simple and the QOT implementations.
+ * It is implemented in the reference process cluster, and contains
+ * - the barrier identifier,
+ * - the implementation type (simple or QDT),
+ * - an xlist implementing the set of barriers dynamically created by a given process,
+ * - a pointer on the implementation specific descriptor (simple_barrier / sqt_barrier).
+ ****************************************************************************************/
+
+typedef struct generic_barrier_s
+{
+    intptr_t              ident;      /*! virtual address in user space == identifier   */
+    xlist_entry_t         list;       /*! member of list of barriers in same process    */
+    bool_t                is_dqt;     /*! DQT implementation when true                  */
+    void                * extend;     /*! implementation specific barrier descriptor    */
 } 
-remote_barrier_t;
-
+generic_barrier_t;
 
 /*****************************************************************************************
@@ -76 +94 @@
  * by its virtual address in a given user process. It makes an associative search, 
  * scanning the list of barriers rooted in the reference process descriptor.
+ * It can be used for both simple and DQT barriers, registered in the same list.
  *****************************************************************************************
  * @ ident    : barrier virtual address, used as identifier.
  * @ returns extended pointer on barrier if success / returns XPTR_NULL if not found. 
  ****************************************************************************************/
-xptr_t remote_barrier_from_ident( intptr_t  ident );
-
-/*****************************************************************************************
- * This function implement the pthread_barrier_init() syscall.
- * It allocates memory for the barrier descriptor in the reference cluster for
- * the calling process, it initializes the barrier state, and register it in the 
- * list of barriers owned by the reference process.
- *****************************************************************************************
- * @ count       : number of expected threads.
- * @ ident       : barrier identifier (virtual address in user space).
- * @ return 0 if success / return ENOMEM if failure.
- ****************************************************************************************/
-error_t remote_barrier_create( intptr_t ident,
-                               uint32_t count );
-
-/*****************************************************************************************
- * This function implement the pthread_barrier_destroy() syscall.
- * It releases thr memory allocated for the barrier descriptor, and remove the barrier 
- * from the list of barriers owned by the reference process.
- *****************************************************************************************
- * @ barrier_xp  : extended pointer on barrier descriptor.
- ****************************************************************************************/
-void remote_barrier_destroy( xptr_t   barrier_xp );
-
-/*****************************************************************************************
- * This function implement the pthread_barrier_wait() syscall.
- * It returns only when the number of expected threads (registered in the barrier
- * dexcriptor) reach the barrier.
- *****************************************************************************************
- * @ barrier_xp   : extended pointer on barrier descriptor.
- ****************************************************************************************/
-void remote_barrier_wait( xptr_t   barrier_xp );
+xptr_t generic_barrier_from_ident( intptr_t  ident );
+
+/*****************************************************************************************
+ * This function implements the pthread_barrier_init() syscall.
+ * It allocates and initialises the generic barrier descriptor in the reference process 
+ * cluster, and - depending on the <attr> argument, calls the relevant (simple or DQT) 
+ * function to allocate and initialize the implementation dependant barrier descriptor.
+ * Finally, it registers the barrier in the reference process xlist of user barriers.
+ * It can be called by a thread running in any cluster, as it use RPC if required.
+ *****************************************************************************************
+ * @ ident    : barrier virtual address, used as identifier.
+ * @ count    : number of expected threads.
+ * @ attr     : barrier attributes (x_size,y_size,nthreads), used by QDT implementation.
+ * @ returns 0 if success / returns -1 if not found. 
+ ****************************************************************************************/
+error_t generic_barrier_create( intptr_t                ident,
+                                uint32_t                count,
+                                pthread_barrierattr_t * attr );
+
+/*****************************************************************************************
+ * This function implements the pthread_barrier_destroy() syscall.
+ * It calls the relevant function (simple or DQT) to release the memory allocated for 
+ * the implementation specific barrier descriptor, and releases the memory allocated
+ * for the generic barrier descriptor.
+ * It removes the barrier from the list of barriers rooted in the reference process.
+ * It can be called by a thread running in any cluster, as it use RPC if required.
+ *****************************************************************************************
+ * @ gen_barrier_xp  : extended pointer on generic barrier descriptor.
+ ****************************************************************************************/
+void generic_barrier_destroy( xptr_t gen_barrier_xp );
+
+/*****************************************************************************************
+ * This blocking function implements the pthread_barrier_wait() syscall.
+ * It calls the relevant function (simple or DQT) depending on the implementation,
+ * and returns only when all expected threads reach the barrier.
+ * It can be called by a thread running in any cluster, as it use remote accesses.
+ *****************************************************************************************
+ * @ gen_barrier_xp   : extended pointer on generic barrier descriptor.
+ ****************************************************************************************/
+void generic_barrier_wait( xptr_t gen_barrier_xp );
+
+
+
+
+
+
+/*****************************************************************************************
+ *                        simple barrier descriptor
+ *****************************************************************************************
+ * This structure defines the simple barrier descriptor. It is localized in the process
+ * reference cluster, as an extension of the generic barrier descriptor.
+ * It implements a toggle barrier remotely accessed by all threads.
+ * It contains the root of the xlist registering all arrived threads.
+ ****************************************************************************************/
+
+typedef struct simple_barrier_s
+{
+    remote_busylock_t  lock;          /*! lock protecting list of waiting threads       */
+    uint32_t           current;       /*! number of arrived threads                     */
+    uint32_t           sense;         /*! barrier state (toggle)                        */
+    uint32_t           arity;         /*! number of expected threads                    */ 
+    xlist_entry_t      root;          /*! root of list of waiting threads               */
+} 
+simple_barrier_t;
+
+/*****************************************************************************************
+ * This function allocates memory for the simple barrier descriptor in the reference 
+ * cluster of the calling process. It initializes the barrier state and returns
+ * a local pointer on the created simple barrier descriptor in reference cluster.
+ * It can be called by a thread running in any cluster, as it use RPC if required.
+ *****************************************************************************************
+ * @ count          : [in] number of expected threads.
+ * @ return Local pointer on barrier descriptor if success / return NULL if failure.
+ ****************************************************************************************/
+simple_barrier_t * simple_barrier_create( uint32_t  count );
+
+/*****************************************************************************************
+ * This function releases the memory allocated for the simple barrier descriptor. 
+ * It can be called by a thread running in any cluster, as it use RPC if required.
+ *****************************************************************************************
+ * @ barrier_xp  : extended pointer on simple barrier descriptor.
+ ****************************************************************************************/
+void simple_barrier_destroy( xptr_t   barrier_xp );
+
+/*****************************************************************************************
+ * This blocking function returns only when all expected threads reach the barrier.
+ * It can be called by a thread running in any cluster, as it use remote accesses.
+ * Waiting threads use a descheduling policy.
+ *****************************************************************************************
+ * @ barrier_xp   : extended pointer on simple barrier descriptor.
+ ****************************************************************************************/
+void simple_barrier_wait( xptr_t   barrier_xp );
+
+
+
+
+
+/*****************************************************************************************
+ *                              dqt_barrier
+ *****************************************************************************************
+ * These structuree define  the hierarchical DQT barrier, physically distributed in a
+ * mesh of clusters defined by the (x_size, y_size, nthreads) arguments:
+ *   . The involved clusters form a mesh [x_size * y_size]
+ *   . The lower left involved cluster is cluster(0,0)  
+ *   . The number of threads per cluster is the same in all clusters.
+ *
+ * Implementation note:
+ * - The quad three is implemented as a three dimensions array of node[x][y][l]
+ *   . [x][y] are the cluster coordinates / max values are (DQT_XMAX-1), (DQT_YMAX-1)
+ *   . [l] is the node level / 0 for terminal nodes / (DQT_LMAX-1) for the root node
+ * - The dqt_barrier_t is the global barrier descriptor, allocated in the reference
+ *   process cluster as an extension of the generic barrier descriptor. It contains a
+ *   3D array of extended pointers on all DQT nodes implementing the DQT barrier.
+ * - The dqt_node_t is a local barrier implementing a togle barrier between all threads
+ *   of a given cluster (for a terminal node), or between all representatives of the four
+ *   children nodes (for a non terminal node).
+ ****************************************************************************************/
+
+#define  DQT_XMAX    16               // max number of clusters in a row
+#define  DQT_YMAX    16               // max number of clusters in a column
+#define  DQT_LMAX    5                // max depth of the quad tree
+
+typedef struct dqt_node_s
+{
+    remote_busylock_t  lock;          /*! lock protecting list of waiting threads       */
+    volatile uint32_t  sense;         /*! barrier state (toggle)                        */
+    volatile uint32_t  current;       /*! number of locally arrived threads             */
+    uint32_t           arity;         /*! total number of locally expected threads      */
+    uint32_t           level;         /*! hierarchical level (0 is bottom)              */
+    xptr_t             parent_xp;     /*! x_pointer on parent node (NULL for root)      */
+    xptr_t             child_xp[4];   /*! x_pointer on children node (NULL for bottom)  */
+    xlist_entry_t      root;          /*! root of list of waiting threads               */
+}
+dqt_node_t;
+
+typedef struct dqt_barrier_s
+{
+    xptr_t    node_xp[DQT_XMAX][DQT_YMAX][DQT_LMAX];  /*! array of xptr on DQT nodes    */
+
+    uint32_t  x_size;                 /*! number of clusters in one row of DQT mesh     */
+    uint32_t  y_size;                 /*! number of clusters in one column of DQT mesh  */
+    uint32_t  nthreads;               /*! number of expected threads in one cluster     */
+} 
+dqt_barrier_t;
+
+/*****************************************************************************************
+ * This function allocates memory for the DQT barrier descriptor in the reference cluster
+ * of the calling process. It allocates also memory in all clusters of the QDT mesh, 
+ * to store up to 5 QDT nodes per cluster. 
+ * It initializes the barrier descriptor, including initialisation of the parent/children
+ * extended pointers in the distributed QDT nodes.
+ * It returns a local pointer on the QDT barrier descriptor in reference cluster.
+ * It can be called by a thread running in any cluster, as it use RPCs for memory
+ * allocation, and remote access for QDT initialisation.
+ *****************************************************************************************
+ * @ x_size      : [in] number of clusters in a line of DQT mesh.
+ * @ y_size      : [in] number of clusters in a column of DQT mesh.
+ * @ nthreads    : [in] number of threads per cluster.
+ * @ return Local pointer on barrier descriptor if success / return NULL if failure.
+ ****************************************************************************************/
+dqt_barrier_t * dqt_barrier_create( uint32_t  x_size,
+                                    uint32_t  y_size,
+                                    uint32_t  nthreads );
+
+/*****************************************************************************************
+ * This function releases all memory allocated for the QDT barrier descriptor.
+ * It removes the barrier from the list of barriers rooted in the reference process.
+ * It can be called by a thread running in any cluster, as it use RPCs.
+ *****************************************************************************************
+ * @ barrier_xp  : extended pointer on DQT barrier descriptor.
+ ****************************************************************************************/
+void dqt_barrier_destroy( xptr_t   barrier_xp );
+
+/*****************************************************************************************
+ * This blocking function returns only when all expected threads reach the barrier.
+ * It can be called by a thread running in any cluster, as it use remote accesses.
+ * Waiting threads use a descheduling policy.
+ *****************************************************************************************
+ * @ barrier_xp   : extended pointer on DQT barrier descriptor.
+ ****************************************************************************************/
+void dqt_barrier_wait( xptr_t   barrier_xp );
+
 
 

trunk/kernel/libk/remote_busylock.c

@@ -101 +101 @@
     (XPTR( local_cxy , this ) == DEBUG_BUSYLOCK_THREAD_XP) )
 {
-    // get cluster and local pointer of target thread
-    cxy_t      thread_cxy = GET_CXY( DEBUG_BUSYLOCK_THREAD_XP );
-    thread_t * thread_ptr = GET_PTR( DEBUG_BUSYLOCK_THREAD_XP );
-
-    // display message on kernel TXT0
     printk("\n[%s] thread[%x,%x] ACQUIRE lock %s\n",
-    __FUNCTION_, this->process->pid, this->trdid, lock_type_str[type] );
+    __FUNCTION__, this->process->pid, this->trdid, lock_type_str[type] );
 }
 #endif
@@ -149 +144 @@
     (XPTR( local_cxy , this ) == DEBUG_BUSYLOCK_THREAD_XP) )
 {
-    // get cluster and local pointer of target thread
-    cxy_t      thread_cxy = GET_CXY( DEBUG_BUSYLOCK_THREAD_XP );
-    thread_t * thread_ptr = GET_PTR( DEBUG_BUSYLOCK_THREAD_XP );
-
-    // display message on kernel TXT0
     printk("\n[%s] thread[%x,%x] RELEASE lock %s\n",
     __FUNCTION__, this->process->pid, this->trdid, lock_type_str[type] );

trunk/kernel/libk/remote_busylock.h

@@ -42 +42 @@
  *   makes an atomic increment on a "ticket" allocator, and keep polling the "current" 
  *   value  until current == ticket. 
-
+ *
  * - To release the lock, the owner thread increments the "current" value,
  *   decrements its busylocks counter.

trunk/kernel/libk/remote_mutex.c

@@ -138 +138 @@
 thread_t * this = CURRENT_THREAD;
 if( (uint32_t)hal_get_cycles() > DEBUG_MUTEX )
-printk("\n[DBG] %s : thread %x in %x process / mutex(%x,%x)\n",
-__FUNCTION__, this->trdid, this->process->pid, local_cxy, mutex_ptr );
+printk("\n[%s] : thread[%x,%x] created mutex(%x,%x)\n",
+__FUNCTION__, this->process->pid, this->trdid, local_cxy, mutex_ptr );
 #endif
 
@@ -173 +173 @@
     remote_queuelock_release( XPTR( ref_cxy , &ref_ptr->sync_lock ) );
 
-    // release memory allocated for mutexaphore descriptor
+    // release memory allocated for mutex descriptor
     if( mutex_cxy == local_cxy )                            // reference is local
     {
@@ -183 +183 @@
     else                                                  // reference is remote
     {
-        rpc_kcm_free_client( mutex_cxy , mutex_ptr , KMEM_BARRIER );
+        rpc_kcm_free_client( mutex_cxy , mutex_ptr , KMEM_MUTEX );
     }
 
@@ -226 +226 @@
 thread_t * this = CURRENT_THREAD;
 if( (uint32_t)hal_get_cycles() > DEBUG_MUTEX )
-printk("\n[DBG] %s : thread %x in process %x SUCCESS on mutex(%x,%x)\n",
-__FUNCTION__, this->trdid, this->process->pid, mutex_cxy, mutex_ptr );
+printk("\n[%s] thread[%x,%x] SUCCESS on mutex(%x,%x)\n",
+__FUNCTION__, this->process->pid, this->trdid, mutex_cxy, mutex_ptr );
 #endif
 
@@ -247 +247 @@
 thread_t * this = CURRENT_THREAD;
 if( (uint32_t)hal_get_cycles() > DEBUG_MUTEX )
-printk("\n[DBG] %s : thread %x in process %x BLOCKED on mutex(%x,%x)\n",
-__FUNCTION__, this->trdid, this->process->pid, mutex_cxy, mutex_ptr );
+printk("\n[%s] thread[%x,%x] BLOCKED on mutex(%x,%x)\n",
+__FUNCTION__, this->process->pid, this->trdid, mutex_cxy, mutex_ptr );
 #endif
 
@@ -296 +296 @@
 thread_t * this = CURRENT_THREAD;
 if( (uint32_t)hal_get_cycles() > DEBUG_MUTEX )
-printk("\n[DBG] %s : thread %x in %x process EXIT / mutex(%x,%x)\n",
-__FUNCTION__, this->trdid, this->process->pid, mutex_cxy, mutex_ptr );
+printk("\n[%s] thread[%x,%x] EXIT / mutex(%x,%x)\n",
+__FUNCTION__, this->process->pid, this->trdid, mutex_cxy, mutex_ptr );
 #endif
 
@@ -320 +320 @@
 process_t * process = hal_remote_lpt( XPTR( thread_cxy , &thread_ptr->process ) );
 pid_t       pid     = hal_remote_l32( XPTR( thread_cxy , &process->pid ) );
-printk("\n[DBG] %s : thread %x in process %x UNBLOCK thread %x in process %d / mutex(%x,%x)\n",
-__FUNCTION__, this->trdid, this->process->pid, trdid, pid, mutex_cxy, mutex_ptr );
+printk("\n[%s] thread[%x,%x] UNBLOCK thread %x in process %d / mutex(%x,%x)\n",
+__FUNCTION__, this->process->pid, this->trdid, trdid, pid, mutex_cxy, mutex_ptr );
 }
 #endif
@@ -371 +371 @@
 thread_t * this = CURRENT_THREAD;
 if( (uint32_t)hal_get_cycles() > DEBUG_QUEUELOCK )
-printk("\n[DBG] %s : SUCCESS for thread %x in process %x / mutex(%x,%x)\n",
-__FUNCTION__, this->trdid, this->process->pid, mutex_cxy, mutex_ptr );
+printk("\n[%s] SUCCESS for thread[%x,%x] / mutex(%x,%x)\n",
+__FUNCTION__, this->process->pid, this->trdid, mutex_cxy, mutex_ptr );
 #endif
         // release busylock protecting mutex state
@@ -385 +385 @@
 thread_t * this = CURRENT_THREAD;
 if( (uint32_t)hal_get_cycles() > DEBUG_QUEUELOCK )
-printk("\n[DBG] %s : FAILURE for thread %x in process %x / mutex(%x,%x)\n",
-__FUNCTION__, this->trdid, this->process->pid, mutex_cxy, mutex_ptr );
+printk("\n[%s] FAILURE for thread[%x,%x] / mutex(%x,%x)\n",
+__FUNCTION__, this->process->pid, this->trdid, mutex_cxy, mutex_ptr );
 #endif
         // release busylock protecting mutex state

trunk/kernel/libk/user_dir.c

@@ -286 +286 @@
             printk("\n[ERROR] in %s : cannot map vpn %x in GPT\n",
             __FUNCTION__, (vpn + page_id) );
-            // use the non blocking RPC to delete the remote vseg 
-            rpc_desc_t     desc;
-            desc.index     = RPC_VMM_DELETE_VSEG;
-            desc.responses = 1;
-            desc.thread    = CURRENT_THREAD;
-            desc.lid       = CURRENT_THREAD->core->lid;
-            desc.blocking  = true;
-            desc.args[0]   = ref_pid;
-            desc.args[1]   = vpn << CONFIG_PPM_PAGE_SHIFT;
-            rpc_vmm_delete_vseg_client( ref_cxy , &desc );
+
+            // delete the vseg
+            if( ref_cxy == local_cxy) vmm_delete_vseg( ref_pid, vpn<<CONFIG_PPM_PAGE_SHIFT );
+            else rpc_vmm_delete_vseg_client( ref_cxy, ref_pid, vpn<<CONFIG_PPM_PAGE_SHIFT );
+
             // release the user_dir descriptor
             req.type = KMEM_DIR;
@@ -387 +382 @@
     lpid_t         lpid;       // process local index
     rpc_desc_t     rpc;        // rpc descriptor
+    uint32_t       responses;  // response counter
      
     // get pointers on calling process & thread
@@ -441 +437 @@
     thread_block( XPTR( local_cxy , this ) , THREAD_BLOCKED_RPC );
 
-    // initialize RPC descriptor shared fields
-    rpc.responses = 0;
+    // initialize responses counter
+    responses = 0;
+
+    // initialize a shared RPC descriptor
+    // can be shared, because no out arguments
+    rpc.rsp       = &responses;
     rpc.blocking  = false;
     rpc.index     = RPC_VMM_DELETE_VSEG;
@@ -461 +461 @@
 
         // atomically increment responses counter
-        hal_atomic_add( (void *)&rpc.responses , 1 );
-
-        // call RPC  
-        rpc_vmm_delete_vseg_client( process_cxy , &rpc );
-
-    }  // end list of copies
+        hal_atomic_add( &responses , 1 );
+
+        // send RPC to target cluster  
+        rpc_send( process_cxy , &rpc );
+    }
 
     // release the lock protecting process copies
@@ -472 +471 @@
 
     // client thread deschedule
-    sched_yield("blocked on rpc_vmm_unmap_vseg");
+    sched_yield("blocked on rpc_vmm_delete_vseg");
  
     // restore IRQs

trunk/kernel/mm/kcm.c

@@ -3 +3 @@
  *
  * Author  Ghassan Almaless (2008,2009,2010,2011,2012)
- *         Alain Greiner    (2016,2017,2018)
+ *         Alain Greiner    (2016,2017,2018,2019)
  *
  * Copyright (c) UPMC Sorbonne Universites
@@ -51 +51 @@
 
 #if DEBUG_KCM
+thread_t * this = CURRENT_THREAD;
 uint32_t cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_KCM < cycle )
-printk("\n[DBG] %s : thread %x enters for %s / page %x / count %d / active %d\n",
-__FUNCTION__ , CURRENT_THREAD , kmem_type_str( kcm->type ) ,
+printk("\n[%s] thread[%x,%x] enters for %s / page %x / count %d / active %d\n",
+__FUNCTION__, this->process->pid, this->trdid, kmem_type_str(kcm->type),
 (intptr_t)kcm_page , kcm_page->count , kcm_page->active );
 #endif
 
-        assert( kcm_page->active , "kcm_page should be active" );
+assert( kcm_page->active , "kcm_page should be active" );
 
         // get first block available
         int32_t index = bitmap_ffs( kcm_page->bitmap , kcm->blocks_nr );
 
-        assert( (index != -1) , "kcm_page should not be full" );
+assert( (index != -1) , "kcm_page should not be full" );
 
         // allocate block
@@ -90 +91 @@
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_KCM < cycle )
-printk("\n[DBG] %s : thread %x exit / type  %s / ptr %x / page %x / count %d\n",
-       __FUNCTION__ , CURRENT_THREAD , kmem_type_str( kcm->type ) , (intptr_t)ptr ,
-(intptr_t)kcm_page , kcm_page->count );
+printk("\n[%s] thread[%x,%x] exit for %s / ptr %x / page %x / count %d\n",
+__FUNCTION__, this->process->pid, this->trdid, kmem_type_str(kcm->type),
+(intptr_t)ptr, (intptr_t)kcm_page, kcm_page->count );
 #endif
 
@@ -115 +116 @@
         index = ((uint8_t *)ptr - (uint8_t *)kcm_page - CONFIG_KCM_SLOT_SIZE) / kcm->block_size;
 
-        assert( !bitmap_state( kcm_page->bitmap , index ) , "page already freed" );
-        assert( (kcm_page->count > 0) , "count already zero" );
+assert( !bitmap_state( kcm_page->bitmap , index ) , "page already freed" );
+
+assert( (kcm_page->count > 0) , "count already zero" );
 
         bitmap_set( kcm_page->bitmap , index );
@@ -163 +165 @@
         if( page == NULL )
         {
-                printk("\n[ERROR] in %s : failed to allocate page in cluster %d\n",
-                       __FUNCTION__ , local_cxy );
+                printk("\n[ERROR] in %s : failed to allocate page in cluster %x\n",
+            __FUNCTION__ , local_cxy );
                 return ENOMEM;
         }
@@ -216 +218 @@
                    uint32_t   type )
 {
-        // the kcm_page descriptor mut fit in the KCM slot
-        assert( (sizeof(kcm_page_t) <= CONFIG_KCM_SLOT_SIZE) ,
-                "KCM slot too small\n" );
+
+// the kcm_page descriptor must fit in the KCM slot
+assert( (sizeof(kcm_page_t) <= CONFIG_KCM_SLOT_SIZE) , "KCM slot too small\n" );
+
+// the allocated object must fit in one single page
+assert( (kmem_type_size(type) <= (CONFIG_PPM_PAGE_SIZE - CONFIG_KCM_SLOT_SIZE)),
+"allocated object requires more than one single page\n" );
 
         // initialize lock
@@ -241 +247 @@
         uint32_t  blocks_nr = (CONFIG_PPM_PAGE_SIZE - CONFIG_KCM_SLOT_SIZE) / block_size;
         kcm->blocks_nr = blocks_nr;
+
+#if DEBUG_KCM
+thread_t * this  = CURRENT_THREAD;
+uint32_t   cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_KCM < cycle )
+printk("\n[%s] thread[%x,%x] initialised KCM %s : block_size %d / blocks_nr %d\n",
+__FUNCTION__, this->process->pid, this->trdid,
+kmem_type_str( kcm->type ), block_size, blocks_nr );
+#endif
+
 }
 
@@ -331 +347 @@
         kcm_t      * kcm;
 
-        assert( (ptr != NULL) , "pointer cannot be NULL" );
+// check argument
+assert( (ptr != NULL) , "pointer cannot be NULL" );
 
         kcm_page = (kcm_page_t *)((intptr_t)ptr & ~CONFIG_PPM_PAGE_MASK);

trunk/kernel/mm/kcm.h

@@ -37 +37 @@
  * for fixed size objects. It exists a specific KCM allocator for each object type.
  * The actual allocated block size is the smallest multiple of the KCM slot, that
- * contain one single object. The KCM slot is typically 64 bytes, as it must be large
- * enough to store the kcm_page descriptor, defined below.
+ * contain one single object. The KCM slot is 64 bytes, as it must be large enough
+ * to store the kcm_page descriptor, defined below.
  * The various KCM allocators themselves are not statically allocated in the cluster
  * manager, but are dynamically allocated when required, using the embedded KCM

trunk/kernel/mm/khm.h

@@ -3 +3 @@
  *
  * Authors  Ghassan Almaless (2008,2009,2010,2011,2012)
- *          Alain Greiner (2016,2017,2018)
+ *          Alain Greiner (2016,2017,2018,2019)
  *
  * Copyright (c) UPMC Sorbonne Universites
@@ -32 +32 @@
 /*******************************************************************************************
  * This structure defines a Kernel Heap Manager (KHM) in a given cluster.
- * It is used to allocate memory objects, that are not enough replicated to justify
- * a dedicated KCM allocator.
+ * It is used to allocate memory objects, that too large, or not enough replicated
+ * to use a dedicated KCM allocator.
  ******************************************************************************************/
 

trunk/kernel/mm/kmem.c

@@ -90 +90 @@
     else if( type == KMEM_CPU_CTX )       return CONFIG_CPU_CTX_SIZE;
     else if( type == KMEM_FPU_CTX )       return CONFIG_FPU_CTX_SIZE;
-    else if( type == KMEM_BARRIER )       return sizeof( remote_barrier_t );
-
+    else if( type == KMEM_GEN_BARRIER )   return sizeof( generic_barrier_t );
+
+    else if( type == KMEM_SMP_BARRIER )   return sizeof( simple_barrier_t );
     else if( type == KMEM_DEVFS_CTX )     return sizeof( fatfs_ctx_t );
     else if( type == KMEM_FATFS_CTX )     return sizeof( fatfs_ctx_t );
@@ -101 +102 @@
     else if( type == KMEM_CONDVAR )       return sizeof( remote_condvar_t );
     else if( type == KMEM_MUTEX )         return sizeof( remote_mutex_t );
+
     else if( type == KMEM_DIR )           return sizeof( user_dir_t );
-
         else if( type == KMEM_512_BYTES )     return 512;
 
@@ -120 +121 @@
         else if( type == KMEM_CPU_CTX )       return "KMEM_CPU_CTX";
         else if( type == KMEM_FPU_CTX )       return "KMEM_FPU_CTX";
-        else if( type == KMEM_BARRIER )       return "KMEM_BARRIER";
-
+        else if( type == KMEM_GEN_BARRIER )   return "KMEM_GEN_BARRIER";
+
+    else if( type == KMEM_SMP_BARRIER )   return "KMEM_SMP_BARRIER";
     else if( type == KMEM_DEVFS_CTX )     return "KMEM_DEVFS_CTX";
     else if( type == KMEM_FATFS_CTX )     return "KMEM_FATFS_CTX";
@@ -131 +133 @@
     else if( type == KMEM_CONDVAR )       return "KMEM_CONDVAR";
     else if( type == KMEM_MUTEX )         return "KMEM_MUTEX";
+
     else if( type == KMEM_DIR )           return "KMEM_DIR";
-
         else if( type == KMEM_512_BYTES )     return "KMEM_512_BYTES";
 

trunk/kernel/mm/kmem.h

@@ -45 +45 @@
     KMEM_CPU_CTX          = 7,   /*! hal_cpu_context_t                              */
     KMEM_FPU_CTX          = 8,   /*! hal_fpu_context_t                              */
-    KMEM_BARRIER          = 9,   /*! remote_barrier_t                               */
+    KMEM_GEN_BARRIER      = 9,   /*! generi_cbarrier_t                              */
 
-    KMEM_DEVFS_CTX        = 10,  /*! fatfs_inode_t                                  */
-    KMEM_FATFS_CTX        = 11,  /*! fatfs_ctx_t                                    */
-    KMEM_VFS_CTX          = 12,  /*! vfs_context_t                                  */
-    KMEM_VFS_INODE        = 13,  /*! vfs_inode_t                                    */
-    KMEM_VFS_DENTRY       = 14,  /*! vfs_dentry_t                                   */
-    KMEM_VFS_FILE         = 15,  /*! vfs_file_t                                     */
-    KMEM_SEM              = 16,  /*! remote_sem_t                                   */
-    KMEM_CONDVAR          = 17,  /*! remote_condvar_t                               */
-    KMEM_MUTEX            = 18,  /*! remote_mutex_t                                 */
-    KMEM_DIR              = 19,  /*! remote_dir_t                                   */
+    KMEM_SMP_BARRIER      = 10,  /*! simple_barrier_t                               */
+    KMEM_DEVFS_CTX        = 11,  /*! fatfs_inode_t                                  */
+    KMEM_FATFS_CTX        = 12,  /*! fatfs_ctx_t                                    */
+    KMEM_VFS_CTX          = 13,  /*! vfs_context_t                                  */
+    KMEM_VFS_INODE        = 14,  /*! vfs_inode_t                                    */
+    KMEM_VFS_DENTRY       = 15,  /*! vfs_dentry_t                                   */
+    KMEM_VFS_FILE         = 16,  /*! vfs_file_t                                     */
+    KMEM_SEM              = 17,  /*! remote_sem_t                                   */
+    KMEM_CONDVAR          = 18,  /*! remote_condvar_t                               */
+    KMEM_MUTEX            = 19,  /*! remote_mutex_t                                 */
 
-    KMEM_512_BYTES        = 20,  /*! 512 bytes aligned                              */
+    KMEM_DIR              = 20,  /*! remote_dir_t                                   */
+    KMEM_512_BYTES        = 21,  /*! 512 bytes aligned                              */
 
-    KMEM_TYPES_NR         = 21,
+    KMEM_TYPES_NR         = 22,
 };
 
@@ -97 +98 @@
  *************************************************************************************
  * @ req   : local pointer to allocation request.
- * @ return a local pointer on page descriptor if PPM (i.e. type KMEM_PAGE).
+ * @ return a local pointer on page descriptor if KMEM_PAGE.
  *   return a local pointer to allocated buffer if KCM or KHM.
  *   return NULL if no physical memory available.

trunk/kernel/mm/vmm.c

@@ -800 +800 @@
     // scan the VSL to delete all registered vsegs
     // (don't use a FOREACH for item deletion in xlist)
-        while( !xlist_is_empty( root_xp ) )
+
+uint32_t count = 0;
+
+        while( !xlist_is_empty( root_xp ) && (count < 10 ) )
         {
         // get pointer on first vseg in VSL
@@ -814 +817 @@
 __FUNCTION__ , vseg_type_str( vseg->type ), vseg->vpn_base, vseg->vpn_size );
 #endif
+
+count++;
 
         }
@@ -1463 +1468 @@
 
 #if DEBUG_VMM_ALLOCATE_PAGE
-uint32_t   cycle = (uint32_t)hal_get_cycles();
-thread_t * this  = CURRENT_THREAD;
+uint32_t   cycle   = (uint32_t)hal_get_cycles();
+thread_t * this    = CURRENT_THREAD;
+xptr_t     this_xp = XPTR( local_cxy , this );
 if( DEBUG_VMM_ALLOCATE_PAGE < (uint32_t)hal_get_cycles() )
 printk("\n[%s] thread[%x,%x] enter for vpn %x / cycle %d\n",
@@ -1950 +1956 @@
 
 #if DEBUG_VMM_HANDLE_COW
-uint32_t   cycle = (uint32_t)hal_get_cycles();
-thread_t * this  = CURRENT_THREAD;
+uint32_t   cycle   = (uint32_t)hal_get_cycles();
+thread_t * this    = CURRENT_THREAD;
+xptr_t     this_xp = XPTR( local_cxy , this );
 if( DEBUG_VMM_HANDLE_COW < cycle )
 printk("\n[%s] thread[%x,%x] enter for vpn %x / core[%x,%d] / cycle %d\n",
-__FUNCTION__, process->pid, this->trdid, vpn, local_cxy, this->core->lid, cycle );
+__FUNCTION__, this->process->pid, this->trdid, vpn, local_cxy, this->core->lid, cycle );
 #endif
 
@@ -1974 +1981 @@
     }
 
+#if( DEBUG_VMM_HANDLE_COW & 1)
+if( DEBUG_VMM_HANDLE_COW < cycle )
+printk("\n[%s] thread[%x,%x] get vseg for vpn %x\n",
+__FUNCTION__, this->process->pid, this->trdid, vpn );
+#endif
+
     // get reference GPT cluster and local pointer
     ref_cxy = GET_CXY( process->ref_xp );
@@ -2001 +2014 @@
                      &old_ppn );
 
+#if( DEBUG_VMM_HANDLE_COW & 1)
+if( DEBUG_VMM_HANDLE_COW < cycle )
+printk("\n[%s] thread[%x,%x] get pte for vpn %x : ppn %x / attr %x\n",
+__FUNCTION__, this->process->pid, this->trdid, vpn, old_ppn, old_attr );
+#endif
+
     // the PTE must be mapped for a COW
     if( (old_attr & GPT_MAPPED) == 0 )
@@ -2008 +2027 @@
 
         // release GPT lock in write mode
-        remote_rwlock_wr_acquire( gpt_lock_xp );
+        remote_rwlock_wr_release( gpt_lock_xp );
 
         return EXCP_KERNEL_PANIC;
     }
 
-    // get extended pointer, cluster and local pointer on physical page descriptor
+    // get pointers on physical page descriptor
     xptr_t   page_xp  = ppm_ppn2page( old_ppn );
     cxy_t    page_cxy = GET_CXY( page_xp );
@@ -2028 +2047 @@
     uint32_t forks = hal_remote_l32( forks_xp );
 
+#if( DEBUG_VMM_HANDLE_COW & 1)
+if( DEBUG_VMM_HANDLE_COW < cycle )
+printk("\n[%s] thread[%x,%x] get forks = %d for vpn %x\n",
+__FUNCTION__, this->process->pid, this->trdid, forks, vpn );
+#endif
+
     if( forks )        // pending fork => allocate a new page, and copy old to new
     {
-        // allocate a new physical page
+        // decrement pending forks counter in page descriptor
+        hal_remote_atomic_add( forks_xp , -1 );
+
+        // release lock protecting "forks" counter
+        remote_busylock_release( forks_lock_xp );
+
+        // allocate a new page
         page_xp = vmm_page_allocate( vseg , vpn );
+
         if( page_xp == XPTR_NULL ) 
         {
@@ -2040 +2072 @@
             remote_rwlock_wr_acquire( gpt_lock_xp );
 
-            // release lock protecting "forks" counter
-            remote_busylock_release( forks_lock_xp );
-
             return EXCP_KERNEL_PANIC;
         }
@@ -2049 +2078 @@
         new_ppn = ppm_page2ppn( page_xp );
 
+#if( DEBUG_VMM_HANDLE_COW & 1)
+if( DEBUG_VMM_HANDLE_COW < cycle )
+printk("\n[%s] thread[%x,%x] get new ppn %x for vpn %x\n",
+__FUNCTION__, this->process->pid, this->trdid, new_ppn, vpn );
+#endif
+
         // copy old page content to new page
-        xptr_t  old_base_xp = ppm_ppn2base( old_ppn );
-        xptr_t  new_base_xp = ppm_ppn2base( new_ppn );
-        memcpy( GET_PTR( new_base_xp ),
-                GET_PTR( old_base_xp ),
-                CONFIG_PPM_PAGE_SIZE );
-
-        // decrement pending forks counter in page descriptor
-        hal_remote_atomic_add( forks_xp , -1 );
+        hal_remote_memcpy( ppm_ppn2base( new_ppn ),
+                           ppm_ppn2base( old_ppn ),
+                           CONFIG_PPM_PAGE_SIZE );
 
 #if(DEBUG_VMM_HANDLE_COW & 1)
 if( DEBUG_VMM_HANDLE_COW < cycle )
-printk("\n[%s] thread[%x,%x] : pending forks => allocate a new PPN %x\n",
-__FUNCTION__, process->pid, this->trdid, new_ppn );
+printk("\n[%s] thread[%x,%x] copied old page to new page\n",
+__FUNCTION__, this->process->pid, this->trdid );
 #endif
 
@@ -2068 +2098 @@
     else               // no pending fork => keep the existing page
     {
+        // release lock protecting "forks" counter
+        remote_busylock_release( forks_lock_xp );
 
 #if(DEBUG_VMM_HANDLE_COW & 1)
 if( DEBUG_VMM_HANDLE_COW < cycle )
-printk("\n[%s] thread[%x,%x]  no pending forks => keep existing PPN %x\n",
-__FUNCTION__, process->pid, this->trdid, new_ppn );
+printk("\n[%s] thread[%x,%x]  no pending forks / keep existing PPN %x\n",
+__FUNCTION__, this->process->pid, this->trdid, old_ppn );
 #endif
         new_ppn = old_ppn;
     }
-
-    // release lock protecting "forks" counter
-    remote_busylock_release( forks_lock_xp );
 
     // build new_attr : reset COW and set WRITABLE,
     new_attr = (old_attr | GPT_WRITABLE) & (~GPT_COW);
 
-    // update the relevan GPT
+    // update the relevant GPT
     // - private vseg => update local GPT 
     // - public vseg => update all GPT copies
@@ -2119 +2148 @@
 if( DEBUG_VMM_HANDLE_COW < cycle )
 printk("\n[%s] thread[%x,%x] exit for vpn %x / core[%x,%d] / cycle %d\n",
-__FUNCTION__, process->pid, this->trdid, vpn, local_cxy, this->core->lid, cycle );
+__FUNCTION__, this->process->pid, this->trdid, vpn, local_cxy, this->core->lid, cycle );
 #endif
 

trunk/kernel/syscalls/sys_barrier.c

@@ -24 +24 @@
 #include <hal_kernel_types.h>
 #include <hal_special.h>
+#include <hal_uspace.h>
 #include <errno.h>
 #include <thread.h>
@@ -43 +44 @@
 
 //////////////////////////////////
-int sys_barrier( void     * vaddr,
+int sys_barrier( intptr_t   vaddr,
                  uint32_t   operation,
-                 uint32_t   count )
+                 uint32_t   count,
+                 intptr_t   attr )   
 {
-        error_t      error;
-    vseg_t     * vseg;
-  
-    thread_t   * this    = CURRENT_THREAD;
-    process_t  * process = this->process;
+        error_t                 error;
+    vseg_t                * vseg;
+    pthread_barrierattr_t   k_attr;
+
+    thread_t  * this    = CURRENT_THREAD;
+    process_t * process = this->process;
 
 #if DEBUG_SYS_BARRIER
@@ -58 +61 @@
 tm_start = hal_get_cycles();
 if( DEBUG_SYS_BARRIER < tm_start )
-printk("\n[DBG] %s : thread %x in process %x enter for %s / count %d / cycle %d\n",
-__FUNCTION__, this->trdid, process->pid, sys_barrier_op_str(operation), count,
+printk("\n[%s] thread[%x,%x] enters for %s / count %d / cycle %d\n",
+__FUNCTION__, process->pid, this->trdid, sys_barrier_op_str(operation), count,
 (uint32_t)tm_start );
 #endif
 
     // check vaddr in user vspace
-        error = vmm_get_vseg( process , (intptr_t)vaddr , &vseg );
-
+        error = vmm_get_vseg( process , vaddr , &vseg );
         if( error )
     {
@@ -71 +73 @@
 #if DEBUG_SYSCALLS_ERROR
 printk("\n[ERROR] in %s : unmapped barrier %x / thread %x / process %x\n",
-__FUNCTION__ , (intptr_t)vaddr , this->trdid , process->pid );
+__FUNCTION__ , vaddr , this->trdid , process->pid );
 vmm_display( process , false );
 #endif
@@ -84 +86 @@
             case BARRIER_INIT:
         {
-            error = remote_barrier_create( (intptr_t)vaddr , count );
-    
+            if( attr != 0 )   // QDT barrier required
+            {
+                error = vmm_get_vseg( process , attr , &vseg );
+                if( error )
+                {
+
+#if DEBUG_SYSCALLS_ERROR
+printk("\n[ERROR] in %s : unmapped barrier attributes %x / thread %x / process %x\n",
+__FUNCTION__ , attr , this->trdid , process->pid );
+vmm_display( process , false );
+#endif
+                    this->errno = EINVAL;
+                    return -1;
+                }
+  
+                // copy barrier attributes into kernel space
+                hal_copy_from_uspace( &k_attr , (void*)attr , sizeof(pthread_barrierattr_t) );
+
+                if ( count != k_attr.x_size * k_attr.y_size *k_attr.nthreads )  
+                {
+
+#if DEBUG_SYSCALLS_ERROR
+printk("\n[ERROR] in %s : wrong arguments / count %d / x_size %d / y_size %d / nthreads %x\n",
+__FUNCTION__, count, k_attr.x_size, k_attr.y_size, k_attr.nthreads );
+#endif
+                    this->errno = EINVAL;
+                    return -1;
+                }
+  
+
+                // call relevant system function
+                error = generic_barrier_create( vaddr , count , &k_attr );
+            }
+            else               // simple barrier required
+            {
+                error = generic_barrier_create( vaddr , count , NULL );
+            }
+
                     if( error )
             {
@@ -91 +129 @@
 #if DEBUG_SYSCALLS_ERROR
 printk("\n[ERROR] in %s : cannot create barrier %x / thread %x / process %x\n",
-__FUNCTION__ , (intptr_t)vaddr , this->trdid , process->pid );
+__FUNCTION__ , vaddr , this->trdid , process->pid );
 #endif
-                this->errno = error;
+                this->errno = ENOMEM;
                 return -1;
             }
@@ -101 +139 @@
             case BARRIER_WAIT:
         {
-            xptr_t barrier_xp = remote_barrier_from_ident( (intptr_t)vaddr );
+            xptr_t barrier_xp = generic_barrier_from_ident( vaddr );
 
             if( barrier_xp == XPTR_NULL )     // user error
@@ -115 +153 @@
             else                          // success
             {
-                remote_barrier_wait( barrier_xp ); 
+                generic_barrier_wait( barrier_xp ); 
             }
             break;
@@ -122 +160 @@
             case BARRIER_DESTROY:
         {
-            xptr_t barrier_xp = remote_barrier_from_ident( (intptr_t)vaddr );
+            xptr_t barrier_xp = generic_barrier_from_ident( vaddr );
 
             if( barrier_xp == XPTR_NULL )     // user error
@@ -136 +174 @@
             else                          // success
             {
-                remote_barrier_destroy( barrier_xp ); 
+                generic_barrier_destroy( barrier_xp ); 
             }
             break;
@@ -149 +187 @@
 tm_end = hal_get_cycles();
 if( DEBUG_SYS_BARRIER < tm_end )
-printk("\n[DBG] %s : thread %x in process %x exit for %s / cost %d / cycle %d\n",
-__FUNCTION__, this->trdid, process->pid, sys_barrier_op_str(operation), 
+printk("\n[%s] thread[%x,%x] exit for %s / cost %d / cycle %d\n",
+__FUNCTION__, process->pid, this->trdid, sys_barrier_op_str(operation), 
 (uint32_t)(tm_end - tm_start), (uint32_t)tm_end );
 #endif

trunk/kernel/syscalls/sys_display.c

@@ -77 +77 @@
 tm_start = hal_get_cycles();
 if( DEBUG_SYS_DISPLAY < tm_start )
-printk("\n[DBG] %s : thread[%x,%x] enter / type  %s / cycle = %d\n",
+printk("\n[%s] thread[%x,%x] enter / type  %s / cycle = %d\n",
 __FUNCTION__, process->pid, this->trdid, display_type_str(type), (uint32_t)tm_start );
 #endif
@@ -84 +84 @@
     if( type == DISPLAY_STRING )
     {
-        char      kbuf[256];
+        char      kbuf[512];
         uint32_t  length;
 
@@ -106 +106 @@
         length = hal_strlen_from_uspace( string );
 
-        if( length >= 256 )
+        if( length >= 512 )
         {
 
@@ -118 +118 @@
 
         // copy string to kernel space
-        hal_strcpy_from_uspace( kbuf , string , 256 );
+        hal_strcpy_from_uspace( kbuf , string , 512 );
 
         // print message on TXT0 kernel terminal
@@ -281 +281 @@
         }
 
-        thread_display_busylocks( thread_xp );
+        thread_display_busylocks( thread_xp , __FUNCTION__ );
     }
     /////////////////////////////////
@@ -388 +388 @@
 #if DEBUG_SYS_DISPLAY
 if( DEBUG_SYS_DISPLAY < tm_end )
-printk("\n[DBG] %s : thread[%x,%x] exit / cycle %d\n",
+printk("\n[%s] thread[%x,%x] exit / cycle %d\n",
 __FUNCTION__, process->pid, this->trdid, (uint32_t)tm_end );
 #endif

trunk/kernel/syscalls/sys_exit.c

@@ -58 +58 @@
 tm_start = hal_get_cycles();
 if( DEBUG_SYS_EXIT < tm_start )
-printk("\n[DBG] %s : thread[%x,%x] enter / status %x / cycle %d\n",
+printk("\n[%s] thread[%x,%x] enter / status %x / cycle %d\n",
 __FUNCTION__, process->pid, this->trdid , status , (uint32_t)tm_start );
 #endif
@@ -69 +69 @@
 #if (DEBUG_SYS_EXIT & 1)
 if( DEBUG_SYS_EXIT < tm_start )
-printk("\n[DBG] %s : thread[%x,%x] get owner process in cluster %x\n",
+printk("\n[%s] thread[%x,%x] get owner process in cluster %x\n",
 __FUNCTION__, process->pid, this->trdid, owner_cxy );
 #endif
@@ -83 +83 @@
 #if (DEBUG_SYS_EXIT & 1)
 if( DEBUG_SYS_EXIT < tm_start )
-printk("\n[DBG] %s : thread[%x,%x] get parent process in cluster %x\n",
+printk("\n[%s] thread[%x,%x] get parent process in cluster %x\n",
 __FUNCTION__, process->pid, this->trdid, parent_cxy );
 #endif
@@ -96 +96 @@
 #if( DEBUG_SYS_EXIT & 1)
 if( DEBUG_SYS_EXIT < tm_start )
-printk("\n[DBG] %s : thread[%x,%x] detached process from TXT\n",
+printk("\n[%s] thread[%x,%x] detached process from TXT\n",
 __FUNCTION__, process->pid, this->trdid );
 #endif
@@ -106 +106 @@
 #if( DEBUG_SYS_EXIT & 1)
 if( DEBUG_SYS_EXIT < tm_start )
-printk("\n[DBG] %s : thread[%x,%x] deleted all threads but itself\n",
+printk("\n[%s] thread[%x,%x] deleted all threads but itself\n",
 __FUNCTION__, process->pid, this->trdid );
 #endif
@@ -116 +116 @@
 #if( DEBUG_SYS_EXIT & 1)
 if( tm_start > DEBUG_SYS_EXIT )
-printk("\n[DBG] %s : thread[%x,%x] marked iself for delete\n",
+printk("\n[%u] thread[%x,%x] marked iself for delete\n",
 __FUNCTION__, process->pid, this->trdid );
 #endif
@@ -127 +127 @@
 #if( DEBUG_SYS_EXIT & 1)
 if( tm_start > DEBUG_SYS_EXIT )
-printk("\n[DBG] %s : thread[%x,%x] blocked main thread\n",
+printk("\n[%s] thread[%x,%x] blocked main thread\n",
 __FUNCTION__, process->pid, this->trdid );
 #endif
@@ -138 +138 @@
 #if( DEBUG_SYS_EXIT & 1)
 if( tm_start > DEBUG_SYS_EXIT )
-printk("\n[DBG] %s : thread[%x,%x] set exit status %x in owner process\n",
+printk("\n[%s] thread[%x,%x] set exit status %x in owner process\n",
 __FUNCTION__, process->pid, this->trdid, term_state );
 #endif
@@ -147 +147 @@
 #if( DEBUG_SYS_EXIT & 1)
 if( tm_start > DEBUG_SYS_EXIT )
-printk("\n[DBG] %s : thread[%x,%x] unblocked parent main thread in process %x\n",
+printk("\n[%s] thread[%x,%x] unblocked parent main thread in process %x\n",
 __FUNCTION__ , process->pid, this->trdid,
 hal_remote_l32( XPTR( parent_cxy , &parent_ptr->pid) ) );
@@ -157 +157 @@
 tm_end = hal_get_cycles();
 if( DEBUG_SYS_EXIT < tm_end )
-printk("\n[DBG] %s : thread[%x,%x] exit / status %x / cost = %d / cycle %d\n",
+printk("\n[%s] thread[%x,%x] exit / status %x / cost = %d / cycle %d\n",
 __FUNCTION__, process->pid, this->trdid, status,
 (uint32_t)(tm_end - tm_start), (uint32_t)tm_end );

trunk/kernel/syscalls/sys_thread_create.c

@@ -70 +70 @@
 if( DEBUG_SYS_THREAD_CREATE < tm_start )
 printk("\n[%s] thread[%x,%x] enter / cycle %d\n",
-__FUNCTION__, process_pid, parent->trdid, (uint32_t)tm_start );
+__FUNCTION__, process->pid, parent->trdid, (uint32_t)tm_start );
 #endif
 

trunk/kernel/syscalls/sys_thread_exit.c

@@ -64 +64 @@
 uint64_t     tm_start = hal_get_cycles();
 if( DEBUG_SYS_THREAD_EXIT < tm_start )
-printk("\n[DBG] %s : thread[%x,%x] / main => delete process / cycle %d\n",
+printk("\n[%s] thread[%x,%x] / main => delete process / cycle %d\n",
 __FUNCTION__ , pid , trdid , (uint32_t)tm_start );
 #endif
@@ -76 +76 @@
 uint64_t     tm_start = hal_get_cycles();
 if( DEBUG_SYS_THREAD_EXIT < tm_start )
-printk("\n[DBG] %s : thread[%x,%x] / not main => delete thread / cycle %d\n",
+printk("\n[%s] thread[%x,%x] / not main => delete thread / cycle %d\n",
 __FUNCTION__ , pid , trdid , (uint32_t)tm_start );
 #endif

trunk/kernel/syscalls/syscalls.h

@@ -146 +146 @@
  * The code implementting the operations is defined in the remote_barrier.c file.
  ******************************************************************************************
- * @ vaddr     : barrier virtual address in user space == identifier.
+ * @ vaddr     : barrier address in user space == identifier.
  * @ operation : BARRIER_INIT / BARRIER_DESTROY / BARRIER_WAIT.
- * @ count     : number of expected threads (only used by BARRIER_INIT operation).
- * @ return 0 if success / return -1 if failure.
- *****************************************************************************************/
-int sys_barrier( void     * vaddr,
+ * @ count     : number of expected threads (only used by BARRIER_INIT).
+ * @ attr      : barrier attributes address in user space (only used by BARRIER_INIT).
+ * @ return 0 if success / return -1 if failure.
+ *****************************************************************************************/
+int sys_barrier( intptr_t   vaddr,
                  uint32_t   operation,
-                 uint32_t   count );
+                 uint32_t   count,
+                 intptr_t   attr );
 
 /****************************************************************************************** 

trunk/libs/libpthread/pthread.c

@@ -2 +2 @@
  * pthread.c - User level <pthread> library implementation.
  * 
- * Author     Alain Greiner (2016,2017,2018)
+ * Author     Alain Greiner (2016,2017,2018,2019)
  *
  * Copyright (c) UPMC Sorbonne Universites
@@ -202 +202 @@
                           unsigned int                  count )
 { 
-    if ( attr )
-    {
-        printf("[ERROR] in %s ; <attr> argument must be NULL\n", __FUNCTION__ );
-        return -1;
-    }
-
     return hal_user_syscall( SYS_BARRIER,
                              (reg_t)barrier,
                              BARRIER_INIT,
                              (reg_t)count,
-                             0 );
+                             (reg_t)attr );
 }
 
@@ -362 +356 @@
     }
 
-    // check attributes
+    // check attributes / count
     if( (x_size * y_size * nthreads) != count )
     {

trunk/libs/libsemaphore/semaphore.h

@@ -27 +27 @@
 //////////////////////////////////////////////////////////////////////////////////////////////
 //             POSIX unnamed semaphores related functions
+//
+// This synchonisation object allows several thread in a given process to share one
+// (or several) shared resource(s).
+// - The sem_wait() function allows a thread to take one resource and atomically
+//   decrement the semaphore count. If the count value is zero, the calling thread 
+//   blocks and deschedules. It is unblocked by another thread when it becomes possible
+//   to make the decrement.
+// - the sem_post() functions allows a thread to release a resource and atomicalli
+//   increment the semaphore count. 
 //////////////////////////////////////////////////////////////////////////////////////////////
 
@@ -37 +46 @@
  * @ sem         : [in]  pointer on semaphore.
  * @ pshared     : [in]  unsupported => must be zero. 
- * @ value       : [in]  initial semaphore value.
+ * @ count       : [in]  initial semaphore value.
  * @ return 0 if success / return -1 if failure.
  ********************************************************************************************/
 int sem_init( sem_t        * sem,
               int            pshared,
-              unsigned int   value );
+              unsigned int   count );
 
 /********************************************************************************************* 

trunk/libs/mini-libc/string.c

@@ -80 +80 @@
 
 
-///////////////////////////
-char * strcpy (char * dest,
+//////////////////////////
+char * strcpy (char * dst,
                char * src )
 {
-        char *src_ptr = src;
-        char *dst_ptr = dest;
-
-        while(*src_ptr) *(dst_ptr++) = *(src_ptr++);
-
-        *dst_ptr = 0;
-        return dest;
-}
-
-////////////////////////////////////
-char * strncpy( char         * dest,
+        while( *src )
+    {
+        *(dst) = *(src);
+        dst++;
+        src++;
+    }
+        
+    // set NUL terminating character
+        *dst = 0;
+
+        return dst;
+}
+
+///////////////////////////////////
+char * strncpy( char         * dst,
                 char         * src,
-                unsigned int   n )
+                unsigned int   count )
 {
         unsigned int i;
 
-        for (i = 0; (i < n) && (src[i] != '\0') ; i++) dest[i] = src[i];
-
-        for (; i < n; i++) dest[i] = '\0';
-
-        return dest;
+    // copy at most count characters
+        for (i = 0 ; (i < count) && (src[i] != '\0') ; i++) dst[i] = src[i];
+
+    // complete with NUL characters
+        for ( ; i < count ; i++) dst[i] = '\0';
+
+        return dst;
 }
 

trunk/libs/mini-libc/string.h

@@ -70 +70 @@
  * @ return 0 if s1 == s2 / return 1 if s1 > s2 / return -1 if s1 < s2
  *******************************************************************************************/
-int strncmp ( const char * s1,
-              const char * s2,
+int strncmp ( const char     * s1,
+              const char     * s2,
               unsigned int     n );
 
@@ -84 +84 @@
 
 /********************************************************************************************
- * This function copies <n> characters from the <sr> buffer to the <dst> buffer.
+ * This function copies <count> characters from the <src> buffer to the <dst> buffer.
  ********************************************************************************************
  * @ dst   : pointer on destination buffer.
  * @ src   : pointer on source buffer.
- * @ n     : number of characters to be copied.
+ * @ count : number of characters to be copied.
  *******************************************************************************************/
 char * strncpy ( char         * dst,
                  char         * src,
-                 unsigned int   n );
+                 unsigned int   count );
 
 /********************************************************************************************

trunk/params-hard.mk

@@ -3 +3 @@
 ARCH      = /users/alain/soc/tsar-trunk-svn-2013/platforms/tsar_generic_iob
 X_SIZE    = 1
-Y_SIZE    = 1
+Y_SIZE    = 2
 NB_PROCS  = 1
 NB_TTYS   = 2

trunk/user/ksh/ksh.c

@@ -21 +21 @@
 //   the TXT terminal ownership.
 //
-// We use a semaphore to synchronize the two KSH threads. At each iteration, 
-// the interactive thread check the semaphore (with a sem_wait). It blocks 
-// and deschedules, if the KSH process loosed the TXT ownership (after a load,
-// or for any other cause. It unblocks with the following policy:
+// We use a semaphore to synchronize the two KSH threads. After each command
+// completion, the interactive thread check the TXT ownership (with a sem_wait),
+// and blocks, if the KSH process loosed the TXT ownership (after a load,
+// or for any other cause). It is unblocked with the following policy:
 // . if the command is "not a load", the semaphore is incremented by the 
-//   cmd_***() function when the command is completed, to allow the KSH interactive()
-//   function to get the next command in the while loop.    
+//   cmd_***() function when the command is completed, to get the next command 
+//   in the while loop.    
 // . if the command is a "load without &", the TXT is given to the NEW process by the
 //   execve() syscall, and is released to the KSH process when NEW process terminates.
@@ -56 +56 @@
 
 #define DEBUG_MAIN          0
-
+#define DEBUG_INTER         0
+#define DEBUG_PARSE         0
 #define DEBUG_CMD_CAT       0
 #define DEBUG_CMD_CP        0
 #define DEBUG_CMD_LOAD      0
 #define DEBUG_CMD_LS        0
+#define DEBUG_CMD_PS        0
 
 //////////////////////////////////////////////////////////////////////////////////////////
@@ -88 +90 @@
 //////////////////////////////////////////////////////////////////////////////////////////
 
-ksh_cmd_t       cmd[];                    // array of supported commands
+ksh_cmd_t       command[];                // array of supported commands
 
 log_entry_t     log_entries[LOG_DEPTH];   // array of registered commands
@@ -99 +101 @@
 sem_t           semaphore;                // block interactive thread when zero
 
+pthread_t       trdid;                    // interactive thread identifier
+ 
 //////////////////////////////////////////////////////////////////////////////////////////
 //         Shell  Commands
@@ -112 +116 @@
     char         * buf;
 
+#if DEBUG_CMD_CAT
+char string[64];
+#endif
+
         if (argc != 2) 
     {
@@ -134 +142 @@
 
 #if DEBUG_CMD_CAT
-long long unsigned cycle;
-get_cycle( &cycle );
-printf("\n[%s] file %s open / cycle %d\n",
-__FUNCTION__ , path , (int)cycle );
+snprintf( string , 64 , "[KSH] %s : file %s open", __FUNCTION__, path );
+display_string( string );
 #endif
 
@@ -161 +167 @@
 
 #if DEBUG_CMD_CAT
-get_cycle( &cycle );
-printf("\n[%s] get size %d / cycle %d\n",
-__FUNCTION__ , size , (int)cycle );
+snprintf( string , 64 , "[KSH] %s : get size = %d", __FUNCTION__, size );
+display_string( string );
 #endif
 
@@ -176 +181 @@
 
 #if DEBUG_CMD_CAT
-get_cycle( &cycle );
-printf("\n[%s] map file %d to buffer %x / cycle %d\n",
-__FUNCTION__ , fd , buf , (int)cycle );
+snprintf( string , 64 , "[KSH] %s : map file %d to buffer %x", __FUNCTION__, fd , buf );
+display_string( string );
 display_vmm( 0 , getpid() );
 #endif
@@ -237 +241 @@
         struct stat  st;
 
+#if DEBUG_CMD_CP
+char string[64];
+#endif
+
         if (argc != 3) 
     {
@@ -259 +267 @@
 
 #if DEBUG_CMD_CP
-long long unsigned cycle;
-get_cycle( &cycle );
-printf("\n[%s] open file <%s> done / cycle %d\n",
-__FUNCTION__ , srcpath , (int)cycle );
+snprintf( string , 64 , "[KSH] %s : file %s open", __FUNCTION__, srcpath );
+display_string( string );
 #endif
 
@@ -274 +280 @@
 
 #if DEBUG_CMD_CP
-get_cycle( &cycle );
-printf("\n[%s] stats file <%s> done / cycle %d\n",
-__FUNCTION__ , srcpath , (int)cycle );
+snprintf( string , 64 , "[KSH] %s : got stats for %s", __FUNCTION__, srcpath );
+display_string( string );
 #endif
 
@@ -299 +304 @@
 
 #if DEBUG_CMD_CP
-get_cycle( &cycle );
-printf("\n[%s] open file <%s> done / cycle %d\n",
-__FUNCTION__ , dstpath , (int)cycle );
+snprintf( string , 64 , "[KSH] %s : file %s open", __FUNCTION__, dstpath );
+display_string( string );
 #endif
 
@@ -311 +315 @@
 
 #if DEBUG_CMD_CP
-get_cycle( &cycle );
-printf("\n[%s] stats file <%s> done / cycle %d\n",
-__FUNCTION__ , dstpath , (int)cycle );
+snprintf( string , 64 , "[KSH] %s : got stats for %s", __FUNCTION__, dstpath );
+display_string( string );
 #endif
 
@@ -336 +339 @@
 
 #if DEBUG_CMD_CP
-get_cycle( &cycle );
-printf("\n[%s] %d bytes read from <%s> / cycle %d\n",
-__FUNCTION__ , len, srcpath , (int)cycle );
+snprintf( string , 64 , "[KSH] %s : read %d bytes from %s", __FUNCTION__, len, srcpath );
+display_string( string );
 #endif
 
@@ -349 +351 @@
 
 #if DEBUG_CMD_CP
-get_cycle( &cycle );
-printf("\n[%s] %d bytes writen to <%s> / cycle %d\n",
-__FUNCTION__ , len, dstpath , (int)cycle );
+snprintf( string , 64 , "[KSH] %s : write %d bytes to %s", __FUNCTION__, len, dstpath );
+display_string( string );
 #endif
 
@@ -573 +574 @@
     else
     {
-            printf("available commands:\n");
-            for (i = 0 ; cmd[i].name ; i++) 
-        {
-                    printf("\t%s\t : %s\n", cmd[i].name , cmd[i].desc);
+        printf("available commands:\n");
+            for (i = 0 ; command[i].name ; i++) 
+        {
+                    printf("\t%s\t : %s\n", command[i].name , command[i].desc);
             }
     }
@@ -624 +625 @@
     unsigned int         placement;          // placement specified if non zero
     unsigned int         cxy;                // target cluster if placement specified
+
+#if DEBUG_CMD_LOAD
+char string[64];
+#endif
 
         if( (argc < 2) || (argc > 4) )  
@@ -661 +666 @@
         }
 
+/*
+        // take semaphore to block the interactive thread
+        if ( sem_wait( &semaphore ) )
+        {
+            printf("\n[ksh error] cannot found semafore\n" );
+            exit( 1 );
+        }
+*/
         // get KSH process PID
         ksh_pid = getpid();
 
 #if DEBUG_CMD_LOAD
-long long unsigned cycle;
-get_cycle( &cycle );
-printf("\n[ksh] %s : ksh_pid %x / path %s / bg %d / place %d (%x) / cycle %d\n",
-__FUNCTION__, ksh_pid, argv[1], background, placement, cxy, (int)cycle );
+snprintf( string , 64 , "[KSH] %s : ksh_pid %x / path %s / bg %d / place %d (%x)\n",
+__FUNCTION__, ksh_pid, argv[1], background, placement, cxy );
+display_string( string );
 #endif
 
@@ -685 +697 @@
 
 #if DEBUG_CMD_LOAD
-get_cycle( &cycle );
-printf("\n[ksh] %s : child_pid %x after fork, before exec / cycle %d\n",
-__FUNCTION__ , getpid(), (int)cycle );
+snprintf( string , 64 , "[KSH] %s : child_pid %x after fork, before exec\n",
+__FUNCTION__ , getpid() );
+display_string( string );
 #endif
 
@@ -694 +706 @@
 
 #if DEBUG_CMD_LOAD
-get_cycle( &cycle );
-printf("\n[ksh] %s : child_pid %x after exec / ret_exec %d / cycle %d\n",
-__FUNCTION__ , getpid(), ret_exec, (int)cycle );
+snprintf( string , 64 , "[KSH] %s : child_pid %x after exec / ret_exec %x\n",
+__FUNCTION__ , getpid(), ret_exec );
+display_string( string );
 #endif
 
@@ -710 +722 @@
 
 #if DEBUG_CMD_LOAD
-get_cycle( &cycle );
-printf("\n[ksh] %s : ksh_pid %x after fork / ret_fork %x / cycle %d\n",
-__FUNCTION__, getpid(), ret_fork, (int)cycle );
-#endif
-
-            if( background )    // child in background =>  KSH must keep TXT ownership
+snprintf( string , 64 , "[KSH] %s : ksh_pid %x after fork / ret_fork %x\n",
+__FUNCTION__, getpid(), ret_fork );
+display_string( string );
+#endif
+
+            if( background )    //  KSH must keep TXT ownership
             {
+                // get back the TXT ownership
                 fg( ksh_pid );
+
+                // release semaphore to get next command
+                sem_post( &semaphore );
             }
-        }
-    }
-
-    // release semaphore to get next command
-    sem_post( &semaphore );
-    
+            else                // KSH loosed TXT ownership
+            {
+                // semaphore will be released by the KSH main thread
+                // when the loaded process exit
+            }
+        }
+    }
 }   // end cmd_load
 
@@ -758 +775 @@
     DIR            * dir;
 
+#if DEBUG_CMD_LS
+char string[64];
+#endif
+
         if (argc > 2 )
     {
@@ -774 +795 @@
 
 #if DEBUG_CMD_LS
-printf("\n[ksh] %s : directory <%s> open / DIR %x\n",
+snprintf( string , 64 , "[KSH] %s : directory <%s> open / DIR %x\n",
 __FUNCTION__, pathname , dir );
+display_string( string );
 #endif
 
@@ -794 +816 @@
 
 #if DEBUG_CMD_LS
-printf("\n[ksh] %s : directory <%s> closed\n",
+snprintf( string , 64 , "[KSH] %s : directory <%s> closed\n",
 __FUNCTION__, pathname );
+display_string( string );
 #endif
 
@@ -865 +888 @@
     unsigned int y;
 
+#if DEBUG_CMD_PS
+char string[64];
+#endif
+
         if (argc != 1)
     {
@@ -879 +906 @@
             for( y = 0 ; y < y_size ; y++ )
             {
+
+#if DEBUG_CMD_PS
+snprintf( string , 64 , "\n[KSH] %s : call display_cluster_process()", __FUNCTION__ );
+display_string( string );
+#endif
+
                 // display only owned processes
                 display_cluster_processes( HAL_CXY_FROM_XY(x,y), 1 ); 
@@ -1003 +1036 @@
 ///////////////////////////////////////////////////////////////////////////////////
 
-ksh_cmd_t cmd[] =
+ksh_cmd_t command[] =
 {
         { "cat",     "display file content",                            cmd_cat     },
@@ -1031 +1064 @@
 static void __attribute__ ((noinline)) parse( char * buf )
 {
-        int argc = 0;
-        char *argv[MAX_ARGS];
-        int i;
-        int len = strlen(buf);
+        int    argc = 0;
+        char * argv[MAX_ARGS];
+        int    i;
+        int    len = strlen(buf);
+
+#if DEBUG_PARSE
+char string[64];
+snprintf( string , 64 , "\n[KSH] %s : <%s>", __FUNCTION__ , buf );
+display_string( string );
+#endif
 
         // build argc/argv
         for (i = 0; i < len; i++) 
     {
+        // convert SPACE to NUL
                 if (buf[i] == ' ') 
         {
@@ -1053 +1093 @@
         }
 
+#if DEBUG_PARSE
+snprintf( string , 64 , "\n[KSH] %s : argc = %d for <%s>", __FUNCTION__ , argc , argv[0] );
+display_string( string );
+#endif
+
     // analyse command type
         if (argc > 0)
@@ -1058 +1103 @@
                 int found = 0;
 
-                argv[argc] = NULL;
-
                 // try to match typed command 
-                for (i = 0 ; cmd[i].name ; i++)
-        {
-                        if (strcmp(argv[0], cmd[i].name) == 0)
+                for ( i = 0 ; command[i].name ; i++ )
+        {
+                        if (strcmp(argv[0], command[i].name) == 0)
             {
-                                cmd[i].fn(argc, argv);
+                                command[i].fn(argc, argv);
                                 found = 1;
                                 break;
@@ -1085 +1128 @@
 {
         char           c;                                               // read character
-        char           buf[CMD_MAX_SIZE];               // buffer for one command
     unsigned int   end_command;             // last character found in a command
         unsigned int   count;                   // pointer in command buffer
@@ -1091 +1133 @@
         unsigned int   state;                   // escape sequence state
 
+        char           cmd[CMD_MAX_SIZE];               // buffer for one command
+
+#if DEBUG_INTER
+char string[64];
+#endif
 
 /* To lauch one command without interactive mode 
-   
 if( sem_wait( &semaphore ) )
 {
@@ -1101 +1147 @@
 else
 {
-    printf("\n[ksh] ls bin/user\n");
+    printf("\n[ksh] load bin/user/sort.elf\n");
 }
 
-strcpy( buf , "ls bin/user" );
-parse( buf );
-
+strcpy( cmd , "load bin/user/sort.elf" );
+parse( cmd );
 */
 
@@ -1127 +1172 @@
         // - BRAKET : the wo characters (ESC,[) have been found
 
-    // external loop on the commands
-    // the in teractive thread should not exit this loop
+    // take the semaphore for the first command
+    if ( sem_wait( &semaphore ) )
+    {
+        printf("\n[ksh error] cannot found semafore\n" );
+        exit( 1 );
+    }
+
+    // display prompt for the first command
+    printf("\n[ksh] ");
+
+    // external loop on the commands / the interactive thread do not exit this loop
         while (1)
         {
             // initialize command buffer
-            memset( buf, 0x20 , sizeof(buf) );   // TODO useful ?
-            count = 0;
-            state = NORMAL;
-
-        // decrement semaphore, and block if the KSH process is not the TXT owner
-        if ( sem_wait( &semaphore ) )
-        {
-            printf("\n[ksh error] cannot found semafore\n" );
-            exit( 1 );
-        }
-
-        // display prompt on a new line
-        printf("\n[ksh] ");
- 
+            memset( cmd, 0x20 , sizeof(cmd) );   // TODO useful ?
+            count       = 0;
+            state       = NORMAL;
         end_command = 0;
+
+#if DEBUG_INTER 
+unsigned int pid = getpid();
+snprintf( string , 64 , "\n[KSH] %s : request a new command", __FUNCTION__ );
+display_string( string );
+#endif
 
         // internal loop on characters in one command
@@ -1171 +1220 @@
                                     {
                                             // complete command with NUL character
-                                            buf[count] = 0;
+                                            cmd[count] = 0;
                         count++;
 
-                                        // register command in log arrays
-                                            strcpy(log_entries[ptw].buf, buf);
+                        // register command in log
+                                            strncpy( log_entries[ptw].buf , cmd , count );
                                             log_entries[ptw].count = count;
                                             ptw = (ptw + 1) % LOG_DEPTH;
                                             ptr = ptw;
 
+#if DEBUG_INTER
+snprintf( string , 64 , "[KSH] %s : parse and execute <%s>", __FUNCTION__, cmd );
+display_string( string );
+#endif
                         // echo character
                         putchar( c );
 
                                             // call parser to analyse and execute command
-                                            parse( buf );
+                                            parse( cmd );
                                     }
                     else                         // no command registered
@@ -1204 +1257 @@
                             else                                               // normal character
                                 {
-                                    if (count < sizeof(buf) - 1)
+                                    if (count < (sizeof(cmd) - 1) )
                                     {
                         // register character in command buffer
-                                            buf[count] = c;
+                                            cmd[count] = c;
                                             count++;
 
@@ -1213 +1266 @@
                         putchar( c );
                                         }
+                    else
+                    {
+                                printf("\none command cannot exceed %d characters\n", sizeof(cmd) );
+                    }
                                 }
                         }
@@ -1228 +1285 @@
                         else if( state == BRAKET )
                         {
-                                if (c == 'D')   // valid  LEFT sequence => move buf pointer left
+                                if (c == 'D')   // valid  LEFT sequence => move cmd pointer left
                                 {
                                         if (count > 0)
@@ -1239 +1296 @@
                                         state = NORMAL;
                                 }
-                                else if (c == 'C')   // valid  RIGHT sequence => move buf pointer right
+                                else if (c == 'C')   // valid  RIGHT sequence => move cmd pointer right
                                 {
-                                        if (count < sizeof(buf) - 1)
+                                        if (count < sizeof(cmd) - 1)
                                         {
-                                                printf("%c", buf[count]);
+                                                printf("%c", cmd[count]);
                                                 count++;
                                         }
@@ -1256 +1313 @@
                                         count = 0;
 
-                                        // copy log command into buf
+                                        // copy log command into cmd
                                         ptr = (ptr - 1) % LOG_DEPTH;
-                                        strcpy(buf, log_entries[ptr].buf);
+                                        strcpy(cmd, log_entries[ptr].buf);
                                         count = log_entries[ptr].count - 1;
 
                                         // display log command
-                                        printf("%s", buf);
+                                        printf("%s", cmd);
 
                                         // get next user char
@@ -1273 +1330 @@
                                         count = 0;
 
-                                        // copy log command into buf
+                                        // copy log command into cmd
                                         ptr = (ptr + 1) % LOG_DEPTH;
-                                        strcpy(buf, log_entries[ptr].buf);
+                                        strcpy(cmd, log_entries[ptr].buf);
                                         count = log_entries[ptr].count;
 
                                         // display log command
-                                        printf("%s", buf);
+                                        printf("%s", cmd);
 
                                         // get next user char
@@ -1291 +1348 @@
                         }
                 }  // end internal while loop on characters
+
+#if DEBUG_INTER 
+snprintf( string , 64 , "\n[KSH] %s : complete <%s> command", __FUNCTION__, cmd );
+display_string( string );
+#endif
+
+        // block interactive thread if KSH loose TXT ownership
+        if ( sem_wait( &semaphore ) )
+        {
+            printf("\n[ksh error] cannot found semafore\n" );
+            exit( 1 );
+        }
+
+        // display prompt for next command
+        printf("\n[ksh] ");
+
         }  // end external while loop on commands
+
 }  // end interactive()
 
@@ -1302 +1376 @@
     int          child_pid;       // child process identifier
     int          parent_pid;      // parent process identifier (i.e. this process)
-    pthread_t    trdid;           // interactive thread identifier (unused)
     unsigned int is_owner;        // non-zero if KSH process is TXT owner
 
@@ -1315 +1388 @@
 
 #if DEBUG_MAIN
-printf("\n[ksh] main started on core[%x,%d]\n", cxy , lid ); 
+printf("\n[ksh] main thread started on core[%x,%d]\n", cxy , lid ); 
 #endif
     
@@ -1339 +1412 @@
                     NULL ); 
 #if DEBUG_MAIN
-printf("\n[ksh] main launched interactive thread => wait children termination\n" ); 
+printf("\n[ksh] main thread launched interactive thread %x\n", trdid ); 
 #endif
 
@@ -1360 +1433 @@
         is_fg( parent_pid , &is_owner );
         if( is_owner ) sem_post( &semaphore );
-
     }
 }  // end main()

trunk/user/sort/sort.c

@@ -29 +29 @@
 #include <hal_macros.h>
 
-#define ARRAY_LENGTH        0x1000    // 4096 values
-
+#define ARRAY_LENGTH        256        // number of values
 #define MAX_THREADS         1024       // 16 * 16 * 4
-
+#define USE_DQT_BARRIER     1
 #define DISPLAY_ARRAY       0
 #define INTERACTIVE_MODE    0
@@ -42 +41 @@
 typedef struct
 {
-    unsigned int threads;      // total number of threads
+    unsigned int threads;       // total number of threads
     unsigned int thread_uid;    // thread user index (0 to threads -1)
     unsigned int main_uid;      // main thread user index
@@ -206 +205 @@
 void main( void )
 {
+    int                    error;
     unsigned int           x_size;             // number of rows
     unsigned int           y_size;             // number of columns
     unsigned int           ncores;             // number of cores per cluster
-    unsigned int           threads;            // total number of threads
+    unsigned int           total_threads;      // total number of threads
     unsigned int           thread_uid;         // user defined thread index
     unsigned int           main_cxy;           // cluster identifier for main
@@ -226 +226 @@
     // compute number of threads (one thread per core)
     get_config( &x_size , &y_size , &ncores );
-    threads = x_size * y_size * ncores;
+    total_threads = x_size * y_size * ncores;
 
     // get core coordinates and user index for the main thread
@@ -235 +235 @@
 
     // checks number of threads
-    if ( (threads != 1)   && (threads != 2)   && (threads != 4)   && 
-         (threads != 8)   && (threads != 16 ) && (threads != 32)  && 
-         (threads != 64)  && (threads != 128) && (threads != 256) && 
-         (threads != 512) && (threads != 1024) )
+    if ( (total_threads != 1)   && (total_threads != 2)   && (total_threads != 4)   && 
+         (total_threads != 8)   && (total_threads != 16 ) && (total_threads != 32)  && 
+         (total_threads != 64)  && (total_threads != 128) && (total_threads != 256) && 
+         (total_threads != 512) && (total_threads != 1024) )
     {
         printf("\n[SORT ERROR] number of cores must be power of 2\n");
@@ -245 +245 @@
 
     // check array size
-    if ( ARRAY_LENGTH % threads) 
+    if ( ARRAY_LENGTH % total_threads) 
     {
         printf("\n[SORT ERROR] array size must be multiple of number of threads\n");
@@ -251 +251 @@
     }
 
-    printf("\n[SORT] main starts on core[%x,%d] / %d thread(s) / %d values / PID %x\n",
-    main_cxy, main_lid, threads, ARRAY_LENGTH, getpid() );
-
-    // Barrier initialization
-    barrier_attr.x_size   = x_size; 
-    barrier_attr.y_size   = y_size;
-    barrier_attr.nthreads = ncores;
-    if( pthread_barrier_init( &barrier, &barrier_attr , threads ) )
+    printf("\n\n[SORT] main starts on core[%x,%d] / %d threads / %d values / PID %x\n",
+    main_cxy, main_lid, total_threads, ARRAY_LENGTH, getpid() );
+
+    // initialize barrier
+    if( USE_DQT_BARRIER )
+    {
+        barrier_attr.x_size   = x_size; 
+        barrier_attr.y_size   = y_size;
+        barrier_attr.nthreads = ncores;
+        error = pthread_barrier_init( &barrier, &barrier_attr , total_threads );
+    }
+    else // use SIMPLE_BARRIER
+    {
+        error = pthread_barrier_init( &barrier, NULL , total_threads );
+    }
+
+    if( error )
     {
         printf("\n[SORT ERROR] cannot initialise barrier\n" );
@@ -290 +299 @@
 
                 // set sort arguments for all threads
-                arg[thread_uid].threads      = threads;
+                arg[thread_uid].threads      = total_threads;
                 arg[thread_uid].thread_uid   = thread_uid;
                 arg[thread_uid].main_uid     = main_uid;
@@ -330 +339 @@
     sort( &arg[main_uid] );
 
+#if INTERACTIVE_MODE
+idbg();
+#endif
+
+    // destroy barrier
+    pthread_barrier_destroy( &barrier );
+
+#if INTERACTIVE_MODE
+idbg();
+#endif
+
     // Check result
     int    success = 1;
-    int*   res_array = ( (threads==  2) ||
-                         (threads==  8) || 
-                         (threads== 32) || 
-                         (threads==128) || 
-                         (threads==512) ) ? array1 : array0;
+    int*   res_array = ( (total_threads ==   2) ||
+                         (total_threads ==   8) || 
+                         (total_threads ==  32) || 
+                         (total_threads == 128) || 
+                         (total_threads == 512) ) ? array1 : array0;
     
     for( n=0 ; n<(ARRAY_LENGTH-2) ; n++ )
@@ -359 +379 @@
     {
         printf("\n[SORT] success at cycle %d\n", (unsigned int)cycle );
-        exit( 0 );
     }
     else
     {
         printf("\n[SORT] failure at cycle %d\n", (unsigned int)cycle );
-        exit( 1 );
-    }
+    }
+
+#if INTERACTIVE_MODE
+idbg();
+#endif
+
+    exit( 0 );
 
 }  // end main()