Changeset 635 for trunk/kernel/libk

Timestamp:

Jun 26, 2019, 11:42:37 AM (5 years ago)

Author:

alain

Message:

This version is a major evolution: The physical memory allocators,
defined in the kmem.c, ppm.c, and kcm.c files have been modified
to support remote accesses. The RPCs that were previously user
to allocate physical memory in a remote cluster have been removed.
This has been done to cure a dead-lock in case of concurrent page-faults.

This version 2.2 has been tested on a (4 clusters / 2 cores per cluster)
TSAR architecture, for both the "sort" and the "fft" applications.

Location:

trunk/kernel/libk

Files:

• bits.c (modified) (1 diff)
• bits.h (modified) (3 diffs)
• elf.c (modified) (3 diffs)
• grdxt.c (modified) (8 diffs)
• grdxt.h (modified) (10 diffs)
• list.h (modified) (2 diffs)
• remote_barrier.c (modified) (22 diffs)
• remote_condvar.c (modified) (5 diffs)
• remote_condvar.h (modified) (2 diffs)
• remote_mutex.c (modified) (5 diffs)
• remote_sem.c (modified) (5 diffs)
• user_dir.c (modified) (11 diffs)
• user_dir.h (modified) (1 diff)
• xhtab.c (modified) (6 diffs)
• xhtab.h (modified) (4 diffs)

trunk/kernel/libk/bits.c

@@ -3 +3 @@
  *
  * Author  Ghassan Almaless (2008,2009,2010,2011,2012)
- *         Alain Greiner    (2016)
+ *         Alain Greiner    (2016,2017,2018,2019)
  *
  * Copyright (c) UPMC Sorbonne Universites

trunk/kernel/libk/bits.h

@@ -3 +3 @@
  *
  * Author   Ghassan Almaless (2008,2009,2010,2011,2012)
- *          Alain Greiner    (2016)
+ *          Alain Greiner    (2016,2017,2018,2019)
  *
  * Copyright (c) UPMC Sorbonne Universites
@@ -189 +189 @@
 
 /*********************************************************************************************
- * This function returns the number of bits to code a non-zero unsigned integer value.
- *********************************************************************************************
- * @ val   : value to analyse
- * @ returns number of bits
- ********************************************************************************************/
-static inline uint32_t bits_nr( uint32_t val )
-{
-        register uint32_t i;
-
-        for( i=0 ; val > 0 ; i++ ) 
-                val = val >> 1;
-
-        return i;
-}
-
-/*********************************************************************************************
- * This function takes an unsigned integer value as input argument, and returns another
- * unsigned integer, that is the (base 2) logarithm of the smallest power of 2 contained 
- * in the input value.
+ * This function takes a positive integer <val> as input argument, and returns the smallest
+ * integer <order> such as : 1<<order >= val. 
+ * In other words, <order> is the min number of bits to encode <val> values.
  *********************************************************************************************
  * @ val   : value to analyse
@@ -214 +198 @@
 static inline uint32_t bits_log2( uint32_t val )
 {
-        return (val == 0) ? 1 : bits_nr( val ) - 1;
+    uint32_t i;
+
+    if( val > 0 )
+    {
+        val--;
+        for( i=0 ; val > 0 ; i++ ) val = val >> 1;
+        return i;
+    }
+    return 0;
 }
 

trunk/kernel/libk/elf.c

@@ -2 +2 @@
  * elf.c - elf parser: find and map process CODE and DATA segments
  *
- * Authors   Alain Greiner    (2016)
+ * Authors   Alain Greiner    (2016,2017,2018,2019)
  *
  * Copyright (c) UPMC Sorbonne Universites
@@ -201 +201 @@
 printk("\n[%s] thread[%x,%x] found %s vseg / base %x / size %x\n"
 "  file_size %x / file_offset %x / mapper_xp %l / cycle %d\n",
-__FUNCTION__ , this->process_pid, this->trdid, 
+__FUNCTION__ , this->process->pid, this->trdid, 
 vseg_type_str(vseg->type) , vseg->min , vseg->max - vseg->min ,
-vseg->file_size , vseg->file_offset , vseg->mapper_xp );
+vseg->file_size , vseg->file_offset , vseg->mapper_xp, cycle );
 #endif
 
@@ -262 +262 @@
 
         // allocate memory for segment descriptors array
-        req.type  = KMEM_GENERIC;
-        req.size  = segs_size;
+        req.type  = KMEM_KCM;
+        req.order = bits_log2(segs_size);
         req.flags = AF_KERNEL;
         segs_base = kmem_alloc( &req );

trunk/kernel/libk/grdxt.c

@@ -30 +30 @@
 #include <grdxt.h>
 
+////////////////////////////////////////////////////////////////////////////////////////
+//               Local access functions
+////////////////////////////////////////////////////////////////////////////////////////
+
 /////////////////////////////////
 error_t grdxt_init( grdxt_t * rt,
@@ -44 +48 @@
 
     // allocates first level array
-        req.type  = KMEM_GENERIC;
-        req.size  = sizeof(void *) << ix1_width;
+        req.type  = KMEM_KCM;
+        req.order = ix1_width + ( (sizeof(void*) == 4) ? 2 : 3 );
         req.flags = AF_KERNEL | AF_ZERO;
         root = kmem_alloc( &req );
-        if( root == NULL ) return ENOMEM;
+
+        if( root == NULL )
+    {
+        printk("\n[ERROR] in %s : cannot allocate first level array\n", __FUNCTION__);
+        return -1;
+    }
   
         rt->root = root;
@@ -71 +80 @@
         uint32_t   ix1;
         uint32_t   ix2;
-
-// check rt
+        uint32_t   ix3;
+
 assert( (rt != NULL) , "pointer on radix tree is NULL\n" );
-
-        req.type = KMEM_GENERIC;
 
         for( ix1=0 ; ix1 < (uint32_t)(1 << w1) ; ix1++ )
@@ -89 +96 @@
                     if( ptr3 == NULL ) continue;
 
+            for( ix3=0 ; ix3 < (uint32_t)(1 << w3) ; ix3++ )
+            {
+                 if( ptr3[ix3] != NULL )
+                 {
+                     printk("\n[WARNING] in %s : ptr3[%d][%d][%d] non empty\n",
+                     __FUNCTION__, ix1, ix2, ix3 );
+                 }
+            }
+
             // release level 3 array 
+            req.type = KMEM_KCM;
                     req.ptr  = ptr3;
-            req.type = KMEM_GENERIC;
-            req.size = sizeof(void *) * (1 << w3);
                     kmem_free( &req );
         }
 
         // release level 2 array
+        req.type = KMEM_KCM;
                 req.ptr  = ptr2;
-        req.type = KMEM_GENERIC;
-        req.size = sizeof(void *) * (1 << w2);
                 kmem_free( &req );
     }
 
     // release level 1 array
+    req.type = KMEM_KCM;
         req.ptr  = ptr1;
-    req.type = KMEM_GENERIC;
-    req.size = sizeof(void *) * (1 << w1);
         kmem_free( &req );
 
 }  // end grdxt_destroy()
-
-////////////////////////////////////
-void grdxt_display( xptr_t    rt_xp,
-                    char    * name )
-{
-        uint32_t       ix1;  
-        uint32_t       ix2;
-        uint32_t       ix3;
-
-// check rt_xp
-assert( (rt_xp != XPTR_NULL) , "pointer on radix tree is NULL\n" );
-
-    // get cluster and local pointer on remote rt descriptor
-    grdxt_t      * rt_ptr = GET_PTR( rt_xp );
-    cxy_t          rt_cxy = GET_CXY( rt_xp );
-
-    // get widths
-    uint32_t       w1 = hal_remote_l32( XPTR( rt_cxy , &rt_ptr->ix1_width ) );
-    uint32_t       w2 = hal_remote_l32( XPTR( rt_cxy , &rt_ptr->ix2_width ) );
-    uint32_t       w3 = hal_remote_l32( XPTR( rt_cxy , &rt_ptr->ix3_width ) );
-
-    void ** ptr1 = hal_remote_lpt( XPTR( rt_cxy , &rt_ptr->root ) );
-
-        printk("\n***** Generic Radix Tree for <%s>\n", name );
-
-        for( ix1=0 ; ix1 < (uint32_t)(1<<w1) ; ix1++ )
-        {
-            void ** ptr2 = hal_remote_lpt( XPTR( rt_cxy , &ptr1[ix1] ) );
-        if( ptr2 == NULL )  continue;
-    
-        for( ix2=0 ; ix2 < (uint32_t)(1<<w2) ; ix2++ )
-        {
-                void ** ptr3 = hal_remote_lpt( XPTR( rt_cxy , &ptr2[ix2] ) );
-            if( ptr3 == NULL ) continue;
-
-            for( ix3=0 ; ix3 < (uint32_t)(1<<w3) ; ix3++ )
-            {
-                void * value = hal_remote_lpt( XPTR( rt_cxy , &ptr3[ix3] ) );
-                if( value == NULL )  continue;
-
-                uint32_t key = (ix1<<(w2+w3)) + (ix2<<w3) + ix3;
-                printk(" - key = %x / value = %x\n", key , (intptr_t)value );
-            }
-        }
-        }
-
-} // end grdxt_display()
 
 ////////////////////////////////////
@@ -177 +143 @@
         uint32_t        ix3 = key & ((1 << w3) - 1);         // index in level 3 array
 
-    void         ** ptr1 = rt->root;                     // pointer on level 1 array
-        void         ** ptr2;                                // pointer on level 2 array
-        void         ** ptr3;                                // pointer on level 3 array
-
-    // If required, we must allocate memory for the selected level 2 array,
-    // and update the level 1 array.
-        if( ptr1[ix1] == NULL )
+    // get ptr1
+    void ** ptr1 = rt->root;
+
+    if( ptr1 == NULL ) return -1;
+
+    // get ptr2
+        void ** ptr2 = ptr1[ix1];
+
+    // If required, allocate memory for the missing level 2 array
+        if( ptr2 == NULL )
         {
         // allocate memory for level 2 array
-        req.type = KMEM_GENERIC;
-        req.size = sizeof(void *) << w2;
+        req.type  = KMEM_KCM;
+        req.order = w2 + ( (sizeof(void*) == 4) ? 2 : 3 );
         req.flags = AF_KERNEL | AF_ZERO;
         ptr2 = kmem_alloc( &req );
-        if( ptr2 == NULL) return ENOMEM;
+
+        if( ptr2 == NULL) return -1;
 
         // update level 1 array
         ptr1[ix1] = ptr2;
         }
-    else    // get pointer on selected level 2 array.
-    {
-            ptr2 = ptr1[ix1];
-    }
-
-    // If required, we must allocate memory for the selected level 3 array,
-    // and update the level 2 array.
-        if( ptr2[ix2] == NULL )
+
+    // get ptr3
+        void ** ptr3 = ptr2[ix2];
+
+    // If required, allocate memory for the missing level 3 array
+        if( ptr3 == NULL )
         {
         // allocate memory for level 3 array
-        req.type = KMEM_GENERIC;
-        req.size = sizeof(void *) << w3;
+        req.type = KMEM_KCM;
+        req.order = w3 + ( (sizeof(void*) == 4) ? 2 : 3 );
         req.flags = AF_KERNEL | AF_ZERO;
         ptr3 = kmem_alloc( &req );
-        if( ptr3 == NULL) return ENOMEM;
+
+        if( ptr3 == NULL) return -1;
 
         //  update level 3 array
                 ptr2[ix2] = ptr3;
         }
-    else    // get pointer on selected level 3 array.
-    {
-            ptr3 = ptr2[ix2];
-    }
-
-    // selected slot in level 3 array must be empty
-        if( ptr3[ix3] != NULL ) return EEXIST;
 
     // register the value
         ptr3[ix3] = value;
+
         hal_fence();
 
@@ -246 +209 @@
         uint32_t        ix3 = key & ((1 << w3) - 1);         // index in level 3 array
 
-    void         ** ptr1 = rt->root;                     // pointer on level 1 array
-        void         ** ptr2;                                // pointer on level 2 array
-        void         ** ptr3;                                // pointer on level 3 array
+    // get ptr1
+    void ** ptr1 = rt->root;
+
+    if( ptr1 == NULL ) return NULL;
 
     // get ptr2
-        ptr2 = ptr1[ix1];
+        void ** ptr2 = ptr1[ix1];
+
         if( ptr2 == NULL ) return NULL;
 
     // get ptr3
-        ptr3 = ptr2[ix2];
+        void ** ptr3 = ptr2[ix2];
+
         if( ptr3 == NULL ) return NULL;
 
@@ -303 +269 @@
 
 }  // end grdxt_lookup()
-
-////////////////////////////////////////////
-xptr_t grdxt_remote_lookup( xptr_t    rt_xp,
-                            uint32_t  key )
-{
-    // get cluster and local pointer on remote rt descriptor
-    grdxt_t       * rt_ptr = GET_PTR( rt_xp );
-    cxy_t           rt_cxy = GET_CXY( rt_xp );
-
-    // get widths
-    uint32_t        w1 = hal_remote_l32( XPTR( rt_cxy , &rt_ptr->ix1_width ) );
-    uint32_t        w2 = hal_remote_l32( XPTR( rt_cxy , &rt_ptr->ix2_width ) );
-    uint32_t        w3 = hal_remote_l32( XPTR( rt_cxy , &rt_ptr->ix3_width ) );
-
-// Check key value
-assert( ((key >> (w1 + w2 + w3)) == 0 ), "illegal key value %x\n", key );
-
-    // compute indexes
-    uint32_t        ix1 = key >> (w2 + w3);              // index in level 1 array
-        uint32_t        ix2 = (key >> w3) & ((1 << w2) -1);  // index in level 2 array
-        uint32_t        ix3 = key & ((1 << w3) - 1);         // index in level 3 array
-
-    // get ptr1
-    void ** ptr1 = hal_remote_lpt( XPTR( rt_cxy , &rt_ptr->root ) );
-
-    // get ptr2
-        void ** ptr2 = hal_remote_lpt( XPTR( rt_cxy , &ptr1[ix1] ) );
-        if( ptr2 == NULL ) return XPTR_NULL;
-
-    // get ptr3
-        void ** ptr3 = hal_remote_lpt( XPTR( rt_cxy , &ptr2[ix2] ) );
-        if( ptr3 == NULL ) return XPTR_NULL;
-
-    // get pointer on registered item
-    void  * item_ptr = hal_remote_lpt( XPTR( rt_cxy , &ptr3[ix3] ) );
-
-    // return extended pointer on registered item 
-    if ( item_ptr == NULL )  return XPTR_NULL;
-        else                     return XPTR( rt_cxy , item_ptr );
-
-}  // end grdxt_remote_lookup()
 
 //////////////////////////////////////
@@ -400 +325 @@
 
 }  // end grdxt_get_first()
+
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+//               Remote access functions
+////////////////////////////////////////////////////////////////////////////////////////
+
+//////////////////////////////////////////////
+error_t grdxt_remote_insert( xptr_t     rt_xp,
+                             uint32_t   key,
+                             void     * value )
+{
+    kmem_req_t  req;
+
+    // get cluster and local pointer on remote rt descriptor
+        cxy_t     rt_cxy = GET_CXY( rt_xp );
+    grdxt_t * rt_ptr = GET_PTR( rt_xp );
+
+    // get widths
+    uint32_t        w1 = hal_remote_l32( XPTR( rt_cxy , &rt_ptr->ix1_width ) );
+    uint32_t        w2 = hal_remote_l32( XPTR( rt_cxy , &rt_ptr->ix2_width ) );
+    uint32_t        w3 = hal_remote_l32( XPTR( rt_cxy , &rt_ptr->ix3_width ) );
+
+// Check key value
+assert( ((key >> (w1 + w2 + w3)) == 0 ), "illegal key value %x\n", key );
+
+    // compute indexes
+    uint32_t        ix1 = key >> (w2 + w3);              // index in level 1 array
+        uint32_t        ix2 = (key >> w3) & ((1 << w2) -1);  // index in level 2 array
+        uint32_t        ix3 = key & ((1 << w3) - 1);         // index in level 3 array
+
+    // get ptr1
+    void ** ptr1 = hal_remote_lpt( XPTR( rt_cxy , &rt_ptr->root ) );
+
+    if( ptr1 == NULL ) return -1;
+
+    // get ptr2
+    void ** ptr2 = hal_remote_lpt( XPTR( rt_cxy , &ptr1[ix1] ) );
+
+    // allocate memory for the missing level_2 array if required
+    if( ptr2 == NULL )
+    {
+        // allocate memory in remote cluster 
+        req.type  = KMEM_KCM;
+        req.order = w2 + ((sizeof(void*) == 4) ? 2 : 3 );
+        req.flags = AF_ZERO | AF_KERNEL;
+        ptr2 = kmem_remote_alloc( rt_cxy , &req );
+
+        if( ptr2 == NULL ) return -1;
+
+        // update level_1 entry
+        hal_remote_spt( XPTR( rt_cxy , &ptr1[ix1] ) , ptr2 );
+    }
+
+    // get ptr3
+    void ** ptr3 = hal_remote_lpt( XPTR( rt_cxy , &ptr2[ix2] ) );
+
+    // allocate memory for the missing level_3 array if required
+    if( ptr3 == NULL )
+    {
+        // allocate memory in remote cluster
+        req.type  = KMEM_KCM;
+        req.order = w3 + ((sizeof(void*) == 4) ? 2 : 3 );
+        req.flags = AF_ZERO | AF_KERNEL;
+        ptr3 = kmem_remote_alloc( rt_cxy , &req );
+
+        if( ptr3 == NULL ) return -1;
+
+        // update level_2 entry
+        hal_remote_spt( XPTR( rt_cxy , &ptr2[ix2] ) , ptr3 );
+    }
+
+    // register value in level_3 array
+    hal_remote_spt( XPTR( rt_cxy , &ptr3[ix3] ) , value );
+
+    hal_fence();
+
+        return 0;
+
+}  // end grdxt_remote_insert()
+
+////////////////////////////////////////////
+void * grdxt_remote_remove( xptr_t    rt_xp,
+                            uint32_t  key )
+{
+    // get cluster and local pointer on remote rt descriptor
+        cxy_t     rt_cxy = GET_CXY( rt_xp );
+    grdxt_t * rt_ptr = GET_PTR( rt_xp );
+
+    // get widths
+    uint32_t        w1 = hal_remote_l32( XPTR( rt_cxy , &rt_ptr->ix1_width ) );
+    uint32_t        w2 = hal_remote_l32( XPTR( rt_cxy , &rt_ptr->ix2_width ) );
+    uint32_t        w3 = hal_remote_l32( XPTR( rt_cxy , &rt_ptr->ix3_width ) );
+
+// Check key value
+assert( ((key >> (w1 + w2 + w3)) == 0 ), "illegal key value %x\n", key );
+
+    // compute indexes
+    uint32_t        ix1 = key >> (w2 + w3);              // index in level 1 array
+        uint32_t        ix2 = (key >> w3) & ((1 << w2) -1);  // index in level 2 array
+        uint32_t        ix3 = key & ((1 << w3) - 1);         // index in level 3 array
+
+    // get ptr1
+    void ** ptr1 = hal_remote_lpt( XPTR( rt_cxy , &rt_ptr->root ) );
+
+    // get ptr2
+        void ** ptr2 = hal_remote_lpt( XPTR( rt_cxy , &ptr1[ix1] ) );
+        if( ptr2 == NULL ) return NULL;
+
+    // get ptr3
+        void ** ptr3 = hal_remote_lpt( XPTR( rt_cxy , &ptr2[ix2] ) );
+        if( ptr3 == NULL ) return NULL;
+
+    // get value
+        void * value = hal_remote_lpt( XPTR( rt_cxy , &ptr3[ix3] ) );
+
+    // reset selected slot
+        hal_remote_spt( XPTR( rt_cxy, &ptr3[ix3] ) , NULL );
+        hal_fence();
+
+        return value;
+
+}  // end grdxt_remote_remove()
+
+////////////////////////////////////////////
+xptr_t grdxt_remote_lookup( xptr_t    rt_xp,
+                            uint32_t  key )
+{
+    // get cluster and local pointer on remote rt descriptor
+    grdxt_t       * rt_ptr = GET_PTR( rt_xp );
+    cxy_t           rt_cxy = GET_CXY( rt_xp );
+
+    // get widths
+    uint32_t        w1 = hal_remote_l32( XPTR( rt_cxy , &rt_ptr->ix1_width ) );
+    uint32_t        w2 = hal_remote_l32( XPTR( rt_cxy , &rt_ptr->ix2_width ) );
+    uint32_t        w3 = hal_remote_l32( XPTR( rt_cxy , &rt_ptr->ix3_width ) );
+
+// Check key value
+assert( ((key >> (w1 + w2 + w3)) == 0 ), "illegal key value %x\n", key );
+
+    // compute indexes
+    uint32_t        ix1 = key >> (w2 + w3);              // index in level 1 array
+        uint32_t        ix2 = (key >> w3) & ((1 << w2) -1);  // index in level 2 array
+        uint32_t        ix3 = key & ((1 << w3) - 1);         // index in level 3 array
+
+    // get ptr1
+    void ** ptr1 = hal_remote_lpt( XPTR( rt_cxy , &rt_ptr->root ) );
+
+    // get ptr2
+        void ** ptr2 = hal_remote_lpt( XPTR( rt_cxy , &ptr1[ix1] ) );
+        if( ptr2 == NULL ) return XPTR_NULL;
+
+    // get ptr3
+        void ** ptr3 = hal_remote_lpt( XPTR( rt_cxy , &ptr2[ix2] ) );
+        if( ptr3 == NULL ) return XPTR_NULL;
+
+    // get pointer on registered item
+    void  * item_ptr = hal_remote_lpt( XPTR( rt_cxy , &ptr3[ix3] ) );
+
+    // return extended pointer on registered item 
+    if ( item_ptr == NULL )  return XPTR_NULL;
+        else                     return XPTR( rt_cxy , item_ptr );
+
+}  // end grdxt_remote_lookup()
+
+/////////////////////////i/////////////////
+void grdxt_remote_display( xptr_t    rt_xp,
+                           char    * name )
+{
+        uint32_t       ix1;  
+        uint32_t       ix2;
+        uint32_t       ix3;
+
+// check rt_xp
+assert( (rt_xp != XPTR_NULL) , "pointer on radix tree is NULL\n" );
+
+    // get cluster and local pointer on remote rt descriptor
+    grdxt_t      * rt_ptr = GET_PTR( rt_xp );
+    cxy_t          rt_cxy = GET_CXY( rt_xp );
+
+    // get widths
+    uint32_t       w1 = hal_remote_l32( XPTR( rt_cxy , &rt_ptr->ix1_width ) );
+    uint32_t       w2 = hal_remote_l32( XPTR( rt_cxy , &rt_ptr->ix2_width ) );
+    uint32_t       w3 = hal_remote_l32( XPTR( rt_cxy , &rt_ptr->ix3_width ) );
+
+    void ** ptr1 = hal_remote_lpt( XPTR( rt_cxy , &rt_ptr->root ) );
+
+        printk("\n***** Generic Radix Tree for <%s>\n", name );
+
+        for( ix1=0 ; ix1 < (uint32_t)(1<<w1) ; ix1++ )
+        {
+            void ** ptr2 = hal_remote_lpt( XPTR( rt_cxy , &ptr1[ix1] ) );
+        if( ptr2 == NULL )  continue;
+    
+        for( ix2=0 ; ix2 < (uint32_t)(1<<w2) ; ix2++ )
+        {
+                void ** ptr3 = hal_remote_lpt( XPTR( rt_cxy , &ptr2[ix2] ) );
+            if( ptr3 == NULL ) continue;
+
+            for( ix3=0 ; ix3 < (uint32_t)(1<<w3) ; ix3++ )
+            {
+                void * value = hal_remote_lpt( XPTR( rt_cxy , &ptr3[ix3] ) );
+                if( value == NULL )  continue;
+
+                uint32_t key = (ix1<<(w2+w3)) + (ix2<<w3) + ix3;
+                printk(" - key = %x / value = %x\n", key , (intptr_t)value );
+            }
+        }
+        }
+
+} // end grdxt_remote_display()
+
+

trunk/kernel/libk/grdxt.h

@@ -36 +36 @@
  * Memory for the second and third levels arrays is dynamically allocated by the
  * grdxt_insert() function and is only released by grdxt_destroy().
- * - This structure is entirely contained in one single cluster.
- * - All modifications (insert / remove) must be done by a thread running in local cluster.
- * - Lookup can be done by a thread running in any cluster (local or remote).
+ * This structure is entirely contained in one single cluster, but to allow any thread
+ * to access it, two sets of access functions are defined:
+ * - local threads can use access function using local pointers.
+ * - remote threads must use the access functions using extended pointers.
  ******************************************************************************************
  * When it is used by the mapper implementing the file cache:
@@ -54 +55 @@
 grdxt_t;
 
+////////////////////////////////////////////////////////////////////////////////////////////
+//                       Local access functions
+////////////////////////////////////////////////////////////////////////////////////////////
+
 /*******************************************************************************************
  * This function initialises the radix-tree descriptor,
+ * It must be called by a local thread.
  * and allocates memory for the first level array of pointers.
  *******************************************************************************************
@@ -71 +77 @@
 /*******************************************************************************************
  * This function releases all memory allocated to the radix-tree infrastructure.
- * The radix-tree is supposed to be empty, but this is NOT checked by this function.
+ * It must be called by a local thread.
+ * A warning message is printed on the kernel TXT0 if the radix tree is not empty.
  *******************************************************************************************
  * @ rt      : pointer on the radix-tree descriptor.
@@ -79 +86 @@
 /*******************************************************************************************
  * This function insert a new item in the radix-tree.
+ * It must be called by a local thread.
  * It dynamically allocates memory for new second and third level arrays if required.
  *******************************************************************************************
@@ -84 +92 @@
  * @ key     : key value.
  * @ value   : pointer on item to be registered in radix-tree.
- * @ returns 0 if success / returns ENOMEM if no memory, or EINVAL if illegal key.
+ * @ returns 0 if success / returns -1 if no memory, or illegal key.
  ******************************************************************************************/
 error_t grdxt_insert( grdxt_t  * rt,
@@ -91 +99 @@
 
 /*******************************************************************************************
- * This function removes an item identified by its key, and returns a pointer
- * on the removed item. No memory is released.
+ * This function removes an item identified by its key from the radix tree,
+ * It must be called by a local thread.
+ * and returns a pointer on the removed item. No memory is released.
  *******************************************************************************************
  * @ rt      : pointer on the radix-tree descriptor.
@@ -103 +112 @@
 /*******************************************************************************************
  * This function returns to a local client, a local pointer on the item identified 
+ * It must be called by a local thread.
  * by the <key> argument, from the radix tree identified by the <rt> local pointer.
  *******************************************************************************************
@@ -113 +123 @@
 
 /*******************************************************************************************
- * This function returns to a - possibly remote - remote client, an extended pointer
- * on the item identified by the <key> argument, from the radix tree identified by
- * the <rt_xp> remote pointer.
- *******************************************************************************************
- * @ rt_xp   : extended pointer on the radix-tree descriptor.
- * @ key     : key value.
- * @ returns an extended pointer on found item if success / returns XPTR_NULL if failure.
- ******************************************************************************************/
-xptr_t grdxt_remote_lookup( xptr_t     rt_xp, 
-                            uint32_t   key );
-
-/*******************************************************************************************
  * This function scan all radix-tree entries in increasing key order, starting from
+ * It must be called by a local thread.
  * the value defined by the <key> argument, and return a pointer on the first valid
  * registered item, and the found item key value.
@@ -138 +137 @@
                         uint32_t * found_key );
 
+////////////////////////////////////////////////////////////////////////////////////////////
+//                       Remote access functions
+////////////////////////////////////////////////////////////////////////////////////////////
+
+/*******************************************************************************************
+ * This function insert a new item in a - possibly remote - radix tree.
+ * It dynamically allocates memory for new second and third level arrays if required.
+ *******************************************************************************************
+ * @ rt_xp   : extended pointer on the radix-tree descriptor.
+ * @ key     : key value.
+ * @ value   : pointer on item to be registered in radix-tree.
+ * @ returns 0 if success / returns -1 if no memory, or illegal key.
+ ******************************************************************************************/
+error_t grdxt_remote_insert( xptr_t     rt_xp,
+                             uint32_t   key,
+                             void     * value );
+
+/*******************************************************************************************
+ * This function removes an item identified by its key from a - possibly remote - radix
+ * tree, and returns a local pointer on the removed item. No memory is released.
+ *******************************************************************************************
+ * @ rt_xp   : pointer on the radix-tree descriptor.
+ * @ key     : key value.
+ * @ returns local pointer on removed item if success / returns NULL if failure.
+ ******************************************************************************************/
+void * grdxt_remote_remove( xptr_t    rt_xp,
+                            uint32_t  key );
+
+/*******************************************************************************************
+ * This function returns to a - possibly remote - client, an extended pointer
+ * on the item identified by the <key> argument, from the radix tree identified by
+ * the <rt_xp> remote pointer.
+ *******************************************************************************************
+ * @ rt_xp   : extended pointer on the radix-tree descriptor.
+ * @ key     : key value.
+ * @ returns an extended pointer on found item if success / returns XPTR_NULL if failure.
+ ******************************************************************************************/
+xptr_t grdxt_remote_lookup( xptr_t     rt_xp, 
+                            uint32_t   key );
+
 /*******************************************************************************************
  * This function displays the current content of a possibly remote radix_tree.
@@ -144 +183 @@
  * @ string  : radix tree identifier. 
  ******************************************************************************************/
-void grdxt_display( xptr_t    rt_xp,
-                    char    * string );
-
+void grdxt_remote_display( xptr_t    rt_xp,
+                           char    * string );
 
 #endif  /* _GRDXT_H_ */

trunk/kernel/libk/list.h

@@ -304 +304 @@
  **************************************************************************/
 
-#define LIST_REMOTE_FIRST( cxy , root , type , member )                       \
-    ({ list_entry_t * __first = hal_remote_lpt( XPTR( cxy , &root->next ) );  \
-           LIST_ELEMENT( __first , type , member ); })
+#define LIST_REMOTE_FIRST( cxy , root , type , member )                \
+        LIST_ELEMENT( hal_remote_lpt( XPTR( (cxy) , &(root)->next ) ), \
+                  type , member )
 
 /***************************************************************************
@@ -314 +314 @@
  * item(s) from the traversed list.     
  ***************************************************************************
- * @ cxy     : remote list cluster identifier
+ * @ cxy     : remote cluster identifier
  * @ root    : pointer on the root list_entry
  * @ iter    : pointer on the current list_entry

trunk/kernel/libk/remote_barrier.c

@@ -83 +83 @@
                                 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      
@@ -97 +96 @@
 
     // 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 );
-    }
+    req.type   = KMEM_KCM;
+    req.order  = bits_log2( sizeof(generic_barrier_t) );
+    req.flags  = AF_ZERO | AF_KERNEL;
+    gen_barrier_ptr = kmem_remote_alloc( ref_cxy , &req );
 
     if( gen_barrier_ptr == NULL )
@@ -124 +113 @@
          barrier = simple_barrier_create( count );
 
-        if( barrier == NULL )
-        {
-            printk("\n[ERROR] in %s : cannot create simple barrier\n", __FUNCTION__);
-            return -1;
-        }
+        if( barrier == NULL ) return -1;
     }
     else                                                  // QDT barrier implementation
@@ -147 +132 @@
         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;
-        }
+        if( barrier == NULL ) return -1;
     }
 
@@ -211 +192 @@
 
     // 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 );
-    }
+    req.type          = KMEM_KCM;
+    req.ptr           = gen_barrier_ptr;
+    kmem_remote_free( ref_cxy , &req );
+
 }  // end generic_barrier_destroy()
 
@@ -273 +246 @@
 simple_barrier_t * simple_barrier_create( uint32_t  count )
 {
-    xptr_t             barrier_xp;
+    kmem_req_t         req;
     simple_barrier_t * barrier;
 
@@ -285 +258 @@
 
     // 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;
+    req.type   = KMEM_KCM;
+    req.order  = bits_log2( sizeof(simple_barrier_t) );
+    req.flags  = AF_ZERO | AF_KERNEL;
+    barrier    = kmem_remote_alloc( ref_cxy , &req );
+
+    if( barrier == NULL )
+    {
+        printk("\n[ERROR] in %s : cannot create simple barrier\n", __FUNCTION__ );
+        return NULL;
+    }
 
     // initialise simple barrier descriptor
@@ -325 +291 @@
 void simple_barrier_destroy( xptr_t barrier_xp )
 {
+    kmem_req_t  req;
+
     // get barrier cluster and local pointer
     cxy_t              barrier_cxy = GET_CXY( barrier_xp );
@@ -330 +298 @@
 
     // release memory allocated for barrier descriptor
-    if( barrier_cxy == local_cxy ) 
-    {
-        kmem_req_t  req;
-        req.type = KMEM_SMP_BARRIER;
-        req.ptr  = barrier_ptr;
-        kmem_free( &req );
-    }
-    else  
-    {
-        rpc_kcm_free_client( barrier_cxy,
-                             barrier_ptr,
-                             KMEM_SMP_BARRIER );
-    }
+    req.type = KMEM_KCM;
+    req.ptr  = barrier_ptr;
+    kmem_remote_free( barrier_cxy , &req );
 
 #if DEBUG_BARRIER_DESTROY
@@ -498 +456 @@
 
 #if DEBUG_BARRIER_CREATE
-static void dqt_barrier_display( xptr_t  barrier_xp );
+void dqt_barrier_display( xptr_t  barrier_xp );
 #endif
 
@@ -506 +464 @@
                                     uint32_t    nthreads )
 {
-    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
-    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
@@ -522 +473 @@
     kmem_req_t      req;           // kmem request
 
-    // compute size and number of DQT levels
+    // compute number of DQT levels, depending on the mesh size
     z      = (x_size > y_size) ? x_size : y_size;
     levels = (z < 2) ? 1 : (z < 3) ? 2 : (z < 5) ? 3 : (z < 9) ? 4 : 5;
@@ -529 +480 @@
 assert( (z <= 16) , "DQT mesh size 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");
@@ -538 +486 @@
 assert( (sizeof(dqt_barrier_t) <= 0x4000 ), "DQT barrier descriptor larger than 4 pages\n");
 
-    // get pointer on local client process descriptor
+    // get pointer on client thread and process descriptors
     thread_t  * this    = CURRENT_THREAD;
     process_t * process = this->process;
@@ -553 +501 @@
     cxy_t          ref_cxy = GET_CXY( ref_xp );
 
-    // 1. allocate 4 4 Kbytes pages for DQT barrier descriptor in reference cluster
-    dqt_page_xp = ppm_remote_alloc_pages( ref_cxy , 2 );
-
-    if( dqt_page_xp == XPTR_NULL ) return NULL;
-
-    // get pointers on DQT barrier descriptor
-    barrier_xp = ppm_page2base( dqt_page_xp );
-    barrier    = GET_PTR( barrier_xp );
+    // 1. allocate 4 small pages for the DQT barrier descriptor in reference cluster
+    req.type   = KMEM_PPM;
+    req.order  = 2;                     // 4 small pages == 16 Kbytes                     
+    req.flags  = AF_ZERO | AF_KERNEL;
+    barrier    = kmem_remote_alloc( ref_cxy , &req );
+
+    if( barrier == NULL )
+    {
+        printk("\n[ERROR] in %s : cannot create DQT barrier\n", __FUNCTION__ );
+        return NULL;
+    }
+
+    // get pointers on DQT barrier descriptor in reference cluster
+    barrier_xp = XPTR( ref_cxy , barrier );
 
     // initialize global parameters in DQT barrier descriptor
@@ -569 +523 @@
 #if DEBUG_BARRIER_CREATE
 if( cycle > DEBUG_BARRIER_CREATE ) 
-printk("\n[%s] thread[%x,%x] created DQT barrier descriptor at (%x,%x)\n",
+printk("\n[%s] thread[%x,%x] created DQT barrier descriptor(%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
+    // 2. allocate memory for an array of 5 DQT nodes  
+    //    in all existing clusters covered by the DQDT
     //    (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 );
-
+    //    and complete barrier descriptor initialisation. 
     for ( x = 0 ; x < x_size ; x++ )
     {
         for ( y = 0 ; y < y_size ; y++ )
         {
-            // send RPC to existing clusters only
+            cxy_t  cxy = HAL_CXY_FROM_XY( x , y );   // target cluster identifier
+            xptr_t local_array_xp;                   // xptr of nodes array in cluster cxy
+
+            // allocate memory in 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
+                req.type  = KMEM_KCM;
+                req.order = 9;                    // 512 bytes
+                req.flags = AF_ZERO | AF_KERNEL;
+
+                void * ptr = kmem_remote_alloc( cxy , &req );
+
+                if( ptr == NULL )
+                {
+                    printk("\n[ERROR] in %s : cannot allocate DQT in cluster %x\n",
+                    __FUNCTION__, cxy );
+                    return NULL;
+                }
+       
+                // build extended pointer on local node array in cluster cxy         
+                            local_array_xp = XPTR( cxy , ptr );
+
+                // initialize the node_xp[x][y][l] array in barrier descriptor
+                for ( l = 0 ; l < levels ; l++ )
+                {
+                    xptr_t  node_xp = local_array_xp + ( l * sizeof(dqt_node_t) );
+                    hal_remote_s64( XPTR( ref_cxy , &barrier->node_xp[x][y][l] ), node_xp );
+
+#if (DEBUG_BARRIER_CREATE & 1)
 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 );
+            else   // register XPTR_NULL for all non-existing entries
+            {
+                for ( l = 0 ; l < levels ; l++ )
+                {
+                    hal_remote_s64( XPTR( ref_cxy , &barrier->node_xp[x][y][l] ), XPTR_NULL );
+                }
+            }
+        }  // end for y 
+    }  // end for x
 
 #if DEBUG_BARRIER_CREATE
 if( cycle > DEBUG_BARRIER_CREATE ) 
-printk("\n[%s] thread[%x,%x] released memory for RPC descriptors array\n",
+printk("\n[%s] thread[%x,%x] initialized array of pointers in DQT barrier\n",
 __FUNCTION__, process->pid, this->trdid );
 #endif
 
-    // 6. initialise all distributed DQT nodes using remote accesses
+    // 3. 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++ )
@@ -827 +729 @@
 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;
+    uint32_t     x;
+    uint32_t     y;
+
 
     // get DQT barrier descriptor cluster and local pointer
@@ -841 +739 @@
 
 #if DEBUG_BARRIER_DESTROY
+thread_t * this  = CURRENT_THREAD;
 uint32_t   cycle = (uint32_t)hal_get_cycles();
 if( cycle > DEBUG_BARRIER_DESTROY ) 
@@ -851 +750 @@
     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
-
+    // 1. release memory allocated for the DQT nodes
+    //    in all clusters covered by the QDT mesh
     for ( x = 0 ; x < x_size ; x++ )
     {
         for ( y = 0 ; y < y_size ; y++ )
         {
-            // send RPC to existing cluster only
+            // compute target cluster identifier
+            cxy_t   cxy = HAL_CXY_FROM_XY( x , y ); 
+
+            // 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] );
@@ -899 +769 @@
 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 );
-            
+                req.type  = KMEM_KCM;
+                req.ptr   = buf;
+                kmem_remote_free( cxy , &req );
+
 #if DEBUG_BARRIER_DESTROY
+thread_t * this  = CURRENT_THREAD;
+uint32_t   cycle = (uint32_t)hal_get_cycles();
 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] ); 
+printk("\n[%s] thread[%x,%x] released node array %x in cluster %x / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, buf, cxy, cycle );
+#endif
             }
         }
     }
 
-    // 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 );
-    cxy_t    page_cxy = GET_CXY( page_xp );
-    page_t * page_ptr = GET_PTR( page_xp );
-
-    ppm_remote_free_pages( page_cxy , page_ptr );
+    // 2. release memory allocated for barrier descriptor in ref cluster
+    req.type = KMEM_PPM;
+    req.ptr  = barrier_ptr;
+    kmem_remote_free( barrier_cxy , &req );
 
 #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",
+printk("\n[%s] thread[%x,%x] release barrier descriptor (%x,%x) / cycle %d\n",
 __FUNCTION__, this->process->pid, this->trdid, barrier_cxy, barrier_ptr, cycle );
 #endif
@@ -1022 +872 @@
                 {
                      uint32_t level = hal_remote_l32( XPTR( node_cxy , &node_ptr->level       ));
-                     uint32_t arity = hal_remote_l32( XPTR( node_cxy , &node_ptr->arity       ));
-                     uint32_t count = hal_remote_l32( XPTR( node_cxy , &node_ptr->current     ));
                      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] ));
@@ -1030 +878 @@
                      xptr_t   c3_xp = hal_remote_l32( XPTR( node_cxy , &node_ptr->child_xp[3] ));
 
-                     printk("   . level %d : (%x,%x) / %d on %d / P(%x,%x) / C0(%x,%x)"
+                     printk("   . level %d : (%x,%x) / P(%x,%x) / C0(%x,%x)"
                             " C1(%x,%x) / C2(%x,%x) / C3(%x,%x)\n",
-                     level, node_cxy, node_ptr, count, arity, 
+                     level, node_cxy, node_ptr, 
                      GET_CXY(pa_xp), GET_PTR(pa_xp),
                      GET_CXY(c0_xp), GET_PTR(c0_xp),

trunk/kernel/libk/remote_condvar.c

@@ -2 +2 @@
  * remote_condvar.c - remote kernel condition variable implementation.
  *
- * Authors     Alain Greiner (2016,2017,2018)
+ * Authors     Alain Greiner (2016,2017,2018,2019)
  *
  * Copyright (c) UPMC Sorbonne Universites
@@ -86 +86 @@
 {
     remote_condvar_t * condvar_ptr;
-    xptr_t             condvar_xp;
+    kmem_req_t         req;   
 
     // get pointer on local process descriptor
@@ -98 +98 @@
     process_t * ref_ptr = (process_t *)GET_PTR( ref_xp );
 
-    // allocate memory for new condvar in reference cluster
-    if( ref_cxy == local_cxy )                              // local cluster is the reference 
-    {
-        kmem_req_t req;   
-        req.type    = KMEM_CONDVAR;
-        req.flags   = AF_ZERO;
-        condvar_ptr = kmem_alloc( &req );
-        condvar_xp  = XPTR( local_cxy , condvar_ptr );
-    }
-    else                                                   // reference cluster is remote
-    {
-        rpc_kcm_alloc_client( ref_cxy , KMEM_CONDVAR , &condvar_xp );
-        condvar_ptr = GET_PTR( condvar_xp );
-    }
-
-    if( condvar_xp == XPTR_NULL ) return 0xFFFFFFFF;
+    req.type    = KMEM_KCM;
+    req.order   = bits_log2( sizeof(remote_condvar_t) );
+    req.flags   = AF_ZERO | AF_KERNEL;
+    condvar_ptr = kmem_alloc( &req );
+
+    if( condvar_ptr == NULL )
+    {
+        printk("\n[ERROR] in %s : cannot create condvar\n", __FUNCTION__ );
+        return -1;
+    }
 
     // initialise condvar 
@@ -136 +130 @@
 void remote_condvar_destroy( xptr_t condvar_xp )
 {
+    kmem_req_t  req;
+
     // get pointer on local process descriptor
     process_t * process = CURRENT_THREAD->process;
@@ -166 +162 @@
 
     // release memory allocated for condvar descriptor
-    if( condvar_cxy == local_cxy )                            // reference is local
-    {
-        kmem_req_t  req;
-        req.type = KMEM_SEM;
-        req.ptr  = condvar_ptr;
-        kmem_free( &req );
-    }
-    else                                                  // reference is remote
-    {
-        rpc_kcm_free_client( condvar_cxy , condvar_ptr , KMEM_CONDVAR );
-    }
+    req.type = KMEM_KCM;
+    req.ptr  = condvar_ptr;
+    kmem_remote_free( ref_cxy , &req );
 
 }  // end remote_convar_destroy()

trunk/kernel/libk/remote_condvar.h

@@ -2 +2 @@
  * remote_condvar.h: POSIX condition variable definition.     
  * 
- * Authors  Alain Greiner (2016,2017,2018)
+ * Authors  Alain Greiner (2016,2017,2018,2019)
  *
  * Copyright (c) UPMC Sorbonne Universites
@@ -78 +78 @@
  * This function implements the CONVAR_INIT operation.
  * This function creates and initializes a remote_condvar, identified by its virtual
- * address <vaddr> in the client process reference cluster, using RPC if required.
+ * address <vaddr> in the client process reference cluster, using remote access.
  * It registers this user condvar in the reference process descriptor.
  *******************************************************************************************

trunk/kernel/libk/remote_mutex.c

@@ -2 +2 @@
  * remote_mutex.c - POSIX mutex implementation.
  * 
- * Authors   Alain   Greiner (2016,2017,2018)
+ * Authors   Alain   Greiner (2016,2017,2018,2019)
  *
  * Copyright (c) UPMC Sorbonne Universites
@@ -84 +84 @@
 error_t remote_mutex_create( intptr_t ident )
 { 
-    xptr_t           mutex_xp;
     remote_mutex_t * mutex_ptr;
+    kmem_req_t       req;   
 
     // get pointer on local process descriptor
@@ -97 +97 @@
     process_t * ref_ptr = (process_t *)GET_PTR( ref_xp );
 
-    // allocate memory for mutex descriptor
-    if( ref_cxy == local_cxy )                  // local cluster is the reference 
-    {
-        kmem_req_t req;   
-        req.type    = KMEM_MUTEX;
-        req.flags   = AF_ZERO;
-        mutex_ptr   = kmem_alloc( &req );
-        mutex_xp    = XPTR( local_cxy , mutex_ptr );
-    }
-    else                                       // reference is remote
-    {
-        rpc_kcm_alloc_client( ref_cxy , KMEM_MUTEX , &mutex_xp );
-        mutex_ptr = GET_PTR( mutex_xp );
-    }
-
-    if( mutex_ptr == NULL ) return 0xFFFFFFFF;
+    // allocate memory for mutex descriptor in reference cluster
+    req.type    = KMEM_KCM;
+    req.order   = bits_log2( sizeof(remote_mutex_t) );
+    req.flags   = AF_ZERO | AF_KERNEL;
+    mutex_ptr   = kmem_remote_alloc( ref_cxy , &req );
+
+    if( mutex_ptr == NULL )
+    {
+       printk("\n[ERROR] in %s : cannot create mutex\n", __FUNCTION__);
+       return -1;
+    }
 
     // initialise mutex
@@ -150 +145 @@
 void remote_mutex_destroy( xptr_t mutex_xp )
 {
+    kmem_req_t  req;
+
     // get pointer on local process descriptor
     process_t * process = CURRENT_THREAD->process;
@@ -174 +171 @@
 
     // release memory allocated for mutex descriptor
-    if( mutex_cxy == local_cxy )                            // reference is local
-    {
-        kmem_req_t  req;
-        req.type = KMEM_MUTEX;
-        req.ptr  = mutex_ptr;
-        kmem_free( &req );
-    }
-    else                                                  // reference is remote
-    {
-        rpc_kcm_free_client( mutex_cxy , mutex_ptr , KMEM_MUTEX );
-    }
+    req.type = KMEM_KCM;
+    req.ptr  = mutex_ptr;
+    kmem_remote_free( mutex_cxy , &req );
 
 }  // end remote_mutex_destroy()

trunk/kernel/libk/remote_sem.c

@@ -2 +2 @@
  * remote_sem.c - POSIX unnamed semaphore implementation.
  * 
- * Author   Alain Greiner  (2016,2017,2018)
+ * Author   Alain Greiner  (2016,2017,2018,2019)
  *
  * Copyright (c) UPMC Sorbonne Universites
@@ -86 +86 @@
                            uint32_t   value )
 {
+    kmem_req_t     req;   
     remote_sem_t * sem_ptr;
-    xptr_t         sem_xp;
 
     // get pointer on local process descriptor
@@ -100 +100 @@
 
     // allocate memory for new semaphore in reference cluster
-    if( ref_cxy == local_cxy )  // local cluster is the reference 
-    {
-        kmem_req_t req;   
-        req.type  = KMEM_SEM;
-        req.flags = AF_ZERO;
-        sem_ptr   = kmem_alloc( &req );
-        sem_xp    = XPTR( local_cxy , sem_ptr );
+    req.type  = KMEM_KCM;
+    req.order = bits_log2( sizeof(remote_sem_t) );
+    req.flags = AF_ZERO | AF_KERNEL;
+    sem_ptr   = kmem_remote_alloc( ref_cxy, &req );
+
+    if( sem_ptr == NULL )
+    {
+        printk("\n[ERROR] in %s : cannot create semaphore\n", __FUNCTION__ );
+        return -1;
     }
-    else                         // reference is remote
-    {
-        rpc_kcm_alloc_client( ref_cxy , KMEM_SEM , &sem_xp );
-        sem_ptr = GET_PTR( sem_xp );
-    }
-
-    if( sem_xp == XPTR_NULL ) return 0xFFFFFFFF;
 
     // initialise semaphore 
@@ -149 +144 @@
 void remote_sem_destroy( xptr_t sem_xp )
 {
+    kmem_req_t  req;
+
     // get pointer on local process descriptor
     process_t * process = CURRENT_THREAD->process;
@@ -179 +176 @@
 
     // release memory allocated for semaphore descriptor
-    if( sem_cxy == local_cxy )                            // reference is local
-    {
-        kmem_req_t  req;
-        req.type = KMEM_SEM;
-        req.ptr  = sem_ptr;
-        kmem_free( &req );
-    }
-    else                                                  // reference is remote
-    {
-        rpc_kcm_free_client( sem_cxy , sem_ptr , KMEM_SEM );
-    }
+    req.type = KMEM_KCM;
+    req.ptr  = sem_ptr;
+    kmem_remote_free( sem_cxy , &req );
 
 }  // end remote_sem_destroy()

trunk/kernel/libk/user_dir.c

@@ -93 +93 @@
     uint32_t        attr;              // attributes for all GPT entries
     uint32_t        dirents_per_page;  // number of dirent descriptors per page
-    xptr_t          page_xp;           // extended pointer on page descriptor  
     page_t        * page;              // local pointer on page descriptor
-    xptr_t          base_xp;           // extended pointer on physical page base 
     struct dirent * base;              // local pointer on physical page base
     uint32_t        total_dirents;     // total number of dirents in dirent array
@@ -126 +124 @@
 
 // check dirent size 
-assert( ( sizeof(struct dirent) == 64), "sizeof(dirent) != 64\n");
+assert( ( sizeof(struct dirent) == 64), "sizeof(dirent) must be 64\n");
 
     // compute number of dirent per page
@@ -135 +133 @@
 
     // allocate memory for a local user_dir descriptor
-    req.type  = KMEM_DIR;
-    req.flags = AF_ZERO;
+    req.type  = KMEM_KCM;
+    req.order = bits_log2( sizeof(user_dir_t) );
+    req.flags = AF_ZERO | AF_KERNEL;
     dir       = kmem_alloc( &req );
 
@@ -146 +145 @@
     }
 
-    // Build an initialize the dirent array as a list of physical pages.
+    // Build an initialize the dirent array as a list of pages.
     // For each iteration in this while loop:
     // - allocate one physical 4 Kbytes (64 dirent slots)
@@ -163 +162 @@
     {
         // allocate one physical page
-        req.type  = KMEM_PAGE;
-        req.size  = 0;
+        req.type  = KMEM_PPM;
+        req.order = 0;
         req.flags = AF_ZERO;
-        page      = kmem_alloc( &req );
-
-        if( page == NULL )
+        base      = kmem_alloc( &req );
+
+        if( base == NULL )
         {
             printk("\n[ERROR] in %s : cannot allocate page in cluster %x\n",
@@ -174 +173 @@
             goto user_dir_create_failure;
         }
-
-        // get pointer on page base (array of dirents)
-        page_xp  = XPTR( local_cxy , page );
-        base_xp  = ppm_page2base( page_xp );
-        base     = GET_PTR( base_xp );
 
         // call the relevant FS specific function to copy up to 64 dirents in page
@@ -198 +192 @@
         total_dirents += entries;
 
+        // get page descriptor pointer from base
+        page = GET_PTR( ppm_base2page( XPTR( local_cxy , base ) ) );
+
         // register page in temporary list
         list_add_last( &root , &page->list ); 
@@ -303 +300 @@
 
             // release the user_dir descriptor
-            req.type = KMEM_DIR;
+            req.type = KMEM_KCM;
             req.ptr  = dir;
             kmem_free( &req );
@@ -364 +361 @@
 
     // release local user_dir_t structure
-    req.type = KMEM_DIR;
+    req.type = KMEM_KCM;
     req.ptr  = dir;
     kmem_free( &req );
@@ -372 +369 @@
     {
         page = LIST_FIRST( &root , page_t , list );
-        req.type  = KMEM_PAGE;
-        req.ptr   = page;
+
+        // get base from page descriptor pointer 
+        base = GET_PTR( ppm_page2base( XPTR( local_cxy , page ) ) );
+ 
+        req.type  = KMEM_PPM;
+        req.ptr   = base;
         kmem_free( &req );
     }
@@ -492 +493 @@
     // release local user_dir_t structure
     kmem_req_t  req;
-    req.type = KMEM_DIR;
+    req.type = KMEM_KCM;
     req.ptr  = dir;
     kmem_free( &req );

trunk/kernel/libk/user_dir.h

@@ -78 +78 @@
  * This function allocates memory and initializes a user_dir_t structure in the cluster
  * containing the directory inode identified by the <inode> argument and map the
- * user accessible dirent array in the reference user process VMM, identified by the
+ * user accessible dirent array in the reference user process VSL, identified by the
  * <ref_xp> argument. 
  * It must be executed by a thread running in the cluster containing the target inode.

trunk/kernel/libk/xhtab.c

@@ -2 +2 @@
  * xhtab.c - Remote access embedded hash table implementation.
  * 
- * Author     Alain Greiner          (2016,2017)
+ * Author     Alain Greiner   (2016,2017,2018,2019)
  *
  * Copyright (c) UPMC Sorbonne Universites
@@ -134 +134 @@
         uint32_t i;
 
-    // initialize readlock
+    // initialize lock
     remote_busylock_init( XPTR( local_cxy , &xhtab->lock), LOCK_XHTAB_STATE );
 
@@ -153 +153 @@
     }
 
-        for( i=0 ; i < XHASHTAB_SIZE ; i++ )
-    {
-                xlist_root_init( XPTR( local_cxy , &xhtab->roots[i] ) );
-    }  
-
-#if DEBUG_XHTAB
-printk("\n@@@ %s for xhtab (%x,%x)\n"
+#if DEBUG_XHTAB
+printk("\n[%s] for xhtab (%x,%x)\n"
 " - index_from_key  = %x (@ %x)\n"
 " - item_match_key  = %x (@ %x)\n"
@@ -169 +164 @@
 #endif
 
+        for( i=0 ; i < XHASHTAB_SIZE ; i++ )
+    {
+                xlist_root_init( XPTR( local_cxy , &xhtab->roots[i] ) );
+
+#if (DEBUG_XHTAB & 1)
+printk("\n - initialize root[%d] / %x\n", i , &xhtab->roots[i] ); 
+#endif
+
+    }  
+
 }  // end xhtab_init()
 
-//////////////////////////////////////
-xptr_t xhtab_scan( xptr_t    xhtab_xp,
-                   uint32_t  index,
-                   void    * key )
+/////////////////////////////////////////////////////////////////////////////////////////////
+// This static function traverse the subset identified by the <index> argument
+// to find an item identified by the <key> argument.
+/////////////////////////////////////////////////////////////////////////////////////////////
+// @ xhtab_xp  : extended pointer on the xhtab descriptor.
+// @ index     : subset index.
+// @ key       : searched key value.
+// @ return  extended pointer on the found item if success / return XPTR_NULL if not found.
+/////////////////////////////////////////////////////////////////////////////////////////////
+static xptr_t xhtab_scan( xptr_t    xhtab_xp,
+                          uint32_t  index,
+                          void    * key )
 {
     xptr_t              xlist_xp;           // xlist_entry_t (iterator)
@@ -220 +233 @@
     index_from_key_t * index_from_key;     // function pointer
     
-#if DEBUG_XHTAB
-printk("\n[%s] enter / key %s\n", __FUNCTION__, key );
-#endif
-
-    // get xhtab cluster and local pointer 
-    xhtab_cxy = GET_CXY( xhtab_xp );
-    xhtab_ptr = GET_PTR( xhtab_xp );
+    // get xhtab cluster and local pointer 
+    xhtab_cxy = GET_CXY( xhtab_xp );
+    xhtab_ptr = GET_PTR( xhtab_xp );
+
+#if DEBUG_XHTAB
+printk("\n[%s] enter / xhtab (%x,%x) / key = <%s> / cycle %d\n",
+__FUNCTION__, xhtab_cxy, xhtab_ptr, key, (uint32_t)hal_get_cycles() );
+#endif
+
+    // build extended pointer on xhtab lock
+    xptr_t lock_xp = XPTR( xhtab_cxy , &xhtab_ptr->lock );
 
     // get pointer on "index_from_key" function
     index_from_key = (index_from_key_t *)hal_remote_lpt( XPTR( xhtab_cxy , 
                                                          &xhtab_ptr->index_from_key ) );
+#if DEBUG_XHTAB
+printk("\n[%s] remote = %x / direct = %x / @ = %x\n",
+__FUNCTION__, index_from_key, xhtab_ptr->index_from_key, &xhtab_ptr->index_from_key );
+#endif
+
     // compute index from key
         index = index_from_key( key );
 
+#if DEBUG_XHTAB
+printk("\n[%s] index = %x\n", __FUNCTION__, index );
+#endif
+
     // take the lock protecting hash table
-    remote_busylock_acquire( XPTR( xhtab_cxy , &xhtab_ptr->lock ) );
-
-    // search a matching item 
+    remote_busylock_acquire( lock_xp );
+
+    // search a matching item in subset
     item_xp = xhtab_scan( xhtab_xp , index , key );
 
-    if( item_xp != XPTR_NULL )    // error if found
+    if( item_xp != XPTR_NULL )    // error if item already registered
     {
         // release the lock protecting hash table
-        remote_busylock_release( XPTR( xhtab_cxy , &xhtab_ptr->lock ) );
+        remote_busylock_release( lock_xp );
 
         return -1;
@@ -256 +282 @@
 
         // release the lock protecting hash table
-        remote_busylock_release( XPTR( xhtab_cxy , &xhtab_ptr->lock ) );
+        remote_busylock_release( lock_xp );
     
 #if DEBUG_XHTAB
-printk("\n[%s] success / %s\n", __FUNCTION__, key );
+printk("\n[%s] success / <%s>\n", __FUNCTION__, key );
 #endif
 

trunk/kernel/libk/xhtab.h

@@ -2 +2 @@
  * xhtab.h - Remote access embedded hash table definition.
  * 
- * Author     Alain Greiner  (2016,2017,2018)
+ * Author     Alain Greiner  (2016,2017,2018,2019)
  *
  * Copyright (c) UPMC Sorbonne Universites
@@ -38 +38 @@
 // The main goal is to speedup search by key in a large number of items of same type.
 // For this purpose the set of all registered items is split in several subsets.
-// Each subset is organised as an embedded double linked xlists.
+// Each subset is organised as an embedded double linked xlist.
 // - an item is uniquely identified by a <key>, that is a item specific pointer,
 //   that can be a - for example - a char* defining the item "name".
@@ -64 +64 @@
 
 /******************************************************************************************
- * This define the four item_type_specific function prototypes that must be defined
+ * Here are the four item_type_specific function prototypes that must be defined
  * for each item type.
  *****************************************************************************************/
@@ -74 +74 @@
 
 /******************************************************************************************
- * This define the supported item types.
+ * This define the currently supported item types.
  * - The XHTAB_DENTRY_TYPE is used to implement the set of directory entries for a
  *   directory inode : the "children" inode field is an embedded xhtab.