Changeset 635 for trunk/kernel/mm

trunk/kernel/mm/kcm.c

-                      r619
+                      r635
 /*
  * kcm.c - Per cluster Kernel Cache Manager implementation.
+ * kcm.c -  Kernel Cache Manager implementation.
+ *
+ * Author  Ghassan Almaless (2008,2009,2010,2011,2012)
+ *         Alain Greiner    (2016,2017,2018,2019)
+ * Author  Alain Greiner    (2016,2017,2018,2019)
+ *
  * Copyright (c) UPMC Sorbonne Universites
 …
+/////////////////////////////////////////////////////////////////////////////////////
+//        Local access functions
+/////////////////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////////////
+// This static function returns pointer on an allocated block from an active page.
+// It returns NULL if no block available in selected page.
+// It changes the page status if required.
+// This static function must be called by a local thread.
+// It returns a pointer on a block allocated from a non-full kcm_page.
+// It makes a panic if no block is available in selected page.
+// It changes the page status as required.
 //////////////////////////////////////////////////////////////////////////////////////
+// @ kcm      : pointer on kcm allocator.
+// @ kcm_page : pointer on active kcm page to use.
+/////////////////////////////////////////////////////////////////////////////////////
+static void * kcm_get_block( kcm_t      * kcm,
+                             kcm_page_t * kcm_page )
+{
+#if DEBUG_KCM
+thread_t * this = CURRENT_THREAD;
+uint32_t cycle = (uint32_t)hal_get_cycles();
+// @ kcm      : pointer on KCM allocator.
+// @ kcm_page : pointer on a non-full kcm_page.
+// @ return pointer on allocated block.
+/////////////////////////////////////////////////////////////////////////////////////
+static void * __attribute__((noinline)) kcm_get_block( kcm_t      * kcm,
+                                                       kcm_page_t * kcm_page )
+{
+    // initialise variables
+    uint32_t size   = 1 << kcm->order;
+    uint32_t max    = kcm->max_blocks;
+    uint32_t count  = kcm_page->count;
+    uint64_t status = kcm_page->status;
+assert( (count < max) , "kcm_page should not be full" );
+    uint32_t index  = 1;
+    uint64_t mask   = (uint64_t)0x2;
+    uint32_t found  = 0;
+        // allocate first free block in kcm_page, update status,
+    // and count , compute index of allocated block in kcm_page
+    while( index <= max )
+    {
+        if( (status & mask) == 0 )   // block non allocated
+        {
+            kcm_page->status = status | mask;
+            kcm_page->count  = count + 1;
+            found  = 1;
+            break;
+        }
+        index++;
+        mask <<= 1;
+    }
+    // change the page list if almost full
+    if( count == max-1 )
+    {
+                list_unlink( &kcm_page->list);
+                kcm->active_pages_nr--;
+        list_add_first( &kcm->full_root , &kcm_page->list );
+                kcm->full_pages_nr ++;
+    }
+        // compute return pointer
+        void * ptr = (void *)((intptr_t)kcm_page + (index * size) );
+#if (DEBUG_KCM & 1)
+thread_t * this  = CURRENT_THREAD;
+uint32_t   cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_KCM < cycle )
+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" );
+        // get first block available
+        int32_t index = bitmap_ffs( kcm_page->bitmap , kcm->blocks_nr );
+assert( (index != -1) , "kcm_page should not be full" );
+        // allocate block
+        bitmap_clear( kcm_page->bitmap , index );
+        // increase kcm_page count
+        kcm_page->count ++;
+        // change the kcm_page to busy if no more free block in page
+        if( kcm_page->count >= kcm->blocks_nr )
+        {
+                kcm_page->active = 0;
+                list_unlink( &kcm_page->list);
+                kcm->active_pages_nr --;
+                list_add_first( &kcm->busy_root , &kcm_page->list);
+                kcm->busy_pages_nr ++;
+                kcm_page->busy = 1;
+        }
+        // compute return pointer
+        void * ptr = (void *)((intptr_t)kcm_page + CONFIG_KCM_SLOT_SIZE
+                     + (index * kcm->block_size) );
+#if DEBUG_KCM
+cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_KCM < cycle )
+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 );
+printk("\n[%s] thread[%x,%x] allocated block %x in page %x / size %d / count %d / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, ptr, kcm_page, size, count + 1, cycle );
 #endif
         return ptr;
+}
+/////////////////////////////////////////////////////////////////////////////////////
+// This static function releases a previously allocated block.
+// It changes the kcm_page status if required.
+/////////////////////////////////////////////////////////////////////////////////////
+// @ kcm      : pointer on kcm allocator.
+// @ kcm_page : pointer on kcm_page.
+// @ ptr      : pointer on block to be released.
+/////////////////////////////////////////////////////////////////////////////////////
+static void kcm_put_block ( kcm_t      * kcm,
+                            kcm_page_t * kcm_page,
+                            void       * ptr )
+{
+        uint32_t     index;
+}  // end kcm_get_block()
+/////////////////////////////////////////////////////////////////////////////////////
+// This private static function must be called by a local thread.
+// It releases a previously allocated block to the relevant kcm_page.
+// It makes a panic if the released block is not allocated in this page.
+// It changes the kcm_page status as required.
+/////////////////////////////////////////////////////////////////////////////////////
+// @ kcm        : pointer on kcm allocator.
+// @ kcm_page   : pointer on kcm_page.
+// @ block_ptr  : pointer on block to be released.
+/////////////////////////////////////////////////////////////////////////////////////
+static void __attribute__((noinline)) kcm_put_block ( kcm_t      * kcm,
+                                                      kcm_page_t * kcm_page,
+                                                      void       * block_ptr )
+{
+    // initialise variables
+    uint32_t max    = kcm->max_blocks;
+    uint32_t size   = 1 << kcm->order;
+    uint32_t count  = kcm_page->count;
+    uint64_t status = kcm_page->status;
         // compute block index from block pointer
+        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" );
+        bitmap_set( kcm_page->bitmap , index );
+        kcm_page->count --;
+        // change the page to active if it was busy
+        if( kcm_page->busy )
+        {
+                kcm_page->busy = 0;
+        uint32_t index = ((intptr_t)block_ptr - (intptr_t)kcm_page) / size;
+    // compute mask in bit vector
+    uint64_t mask = ((uint64_t)0x1) << index;
+assert( (status & mask) , "released block not allocated : status (%x,%x) / mask(%x,%x)",
+GET_CXY(status), GET_PTR(status), GET_CXY(mask  ), GET_PTR(mask  ) );
+    // update status & count in kcm_page
+        kcm_page->status = status & ~mask;
+        kcm_page->count  = count - 1;
+        // change the page mode if page was full
+        if( count == max )
+        {
                 list_unlink( &kcm_page->list );
                 kcm->busy_pages_nr --;
+                kcm->full_pages_nr --;
                 list_add_last( &kcm->active_root, &kcm_page->list );
                 kcm->active_pages_nr ++;
+                kcm_page->active = 1;
+        }
+        // change the kcm_page to free if last block in active page
+        if( (kcm_page->active) && (kcm_page->count == 0) )
+        {
+                kcm_page->active = 0;
+                list_unlink( &kcm_page->list);
+                kcm->active_pages_nr --;
+                list_add_first( &kcm->free_root , &kcm_page->list);
+                kcm->free_pages_nr ++;
+        }
+}
+/////////////////////////////////////////////////////////////////////////////////////
+// This static function allocates one page from PPM. It initializes
+// the kcm_page descriptor, and introduces the new kcm_page into freelist.
+/////////////////////////////////////////////////////////////////////////////////////
+static error_t freelist_populate( kcm_t * kcm )
+{
+        page_t     * page;
+        kcm_page_t * kcm_page;
+        kmem_req_t   req;
+        // get one page from local PPM
+        req.type  = KMEM_PAGE;
+        req.size  = 0;
+        req.flags = AF_KERNEL;
+        page = kmem_alloc( &req );
+        if( page == NULL )
+        {
+                printk("\n[ERROR] in %s : failed to allocate page in cluster %x\n",
+            __FUNCTION__ , local_cxy );
+                return ENOMEM;
+        }
+        // get page base address
+        xptr_t base_xp = ppm_page2base( XPTR( local_cxy , page ) );
+        kcm_page = (kcm_page_t *)GET_PTR( base_xp );
+        // initialize KCM-page descriptor
+        bitmap_set_range( kcm_page->bitmap , 0 , kcm->blocks_nr );
+        kcm_page->busy          = 0;
+        kcm_page->active        = 0;
+        kcm_page->count      = 0;
+        kcm_page->kcm           = kcm;
+        kcm_page->page          = page;
+        // introduce new page in free-list
+        list_add_first( &kcm->free_root , &kcm_page->list );
+        kcm->free_pages_nr ++;
+        return 0;
+}
+/////////////////////////////////////////////////////////////////////////////////////
+// This private function gets one KCM page from the KCM freelist.
+// It populates the freelist if required.
+/////////////////////////////////////////////////////////////////////////////////////
+static kcm_page_t * freelist_get( kcm_t * kcm )
+{
+        error_t      error;
+        kcm_page_t * kcm_page;
+        // get a new page from PPM if freelist empty
+        if( kcm->free_pages_nr == 0 )
+        {
+                error = freelist_populate( kcm );
+                if( error ) return NULL;
+        }
+        // get first KCM page from freelist and unlink it
+        kcm_page = LIST_FIRST( &kcm->free_root, kcm_page_t , list );
+        list_unlink( &kcm_page->list );
+        kcm->free_pages_nr --;
+        }
+#if (DEBUG_KCM & 1)
+thread_t * this  = CURRENT_THREAD;
+uint32_t   cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_KCM < cycle )
+printk("\n[%s] thread[%x,%x] released block %x in page %x / size %d / count %d / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, block_ptr, kcm_page, size, count - 1, cycle );
+#endif
+}  // kcm_put_block()
+/////////////////////////////////////////////////////////////////////////////////////
+// This private static function must be called by a local thread.
+// It returns one non-full kcm_page with te following policy :
+// - if the "active_list" is non empty, it returns the first "active" page,
+//   without modifying the KCM state.
+// - if the "active_list" is empty, it allocates a new page fromm PPM, inserts
+//   this page in the active_list, and returns it.
+/////////////////////////////////////////////////////////////////////////////////////
+// @ kcm      : local pointer on local KCM allocator.
+// @ return pointer on a non-full kcm page if success / returns NULL if no memory.
+/////////////////////////////////////////////////////////////////////////////////////
+static kcm_page_t * __attribute__((noinline)) kcm_get_page( kcm_t * kcm )
+{
+    kcm_page_t * kcm_page;
+    uint32_t active_pages_nr = kcm->active_pages_nr;
+    if( active_pages_nr > 0 )       // return first active page
+    {
+        kcm_page = LIST_FIRST( &kcm->active_root , kcm_page_t , list );
+    }
+    else                            // allocate a new page from PPM
+        {
+        // get one 4 Kbytes page from local PPM
+        page_t * page = ppm_alloc_pages( 0 );
+            if( page == NULL )
+            {
+                    printk("\n[ERROR] in %s : failed to allocate page in cluster %x\n",
+                __FUNCTION__ , local_cxy );
+                    return NULL;
+        }
+            // get page base address
+            xptr_t base_xp = ppm_page2base( XPTR( local_cxy , page ) );
+        // get local pointer on kcm_page
+            kcm_page = GET_PTR( base_xp );
+            // initialize kcm_page descriptor
+            kcm_page->status = 0;
+            kcm_page->count  = 0;
+            kcm_page->kcm    = kcm;
+            kcm_page->page   = page;
+            // introduce new page in KCM active_list
+            list_add_first( &kcm->active_root , &kcm_page->list );
+            kcm->active_pages_nr ++;
+        }
         return kcm_page;
+}
+}  // end kcm_get_page()
 //////////////////////////////
 void kcm_init( kcm_t    * kcm,
+                   uint32_t   type )
+{
+// 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" );
+                   uint32_t   order)
+{
+assert( ((order > 5) && (order < 12)) , "order must be in [6,11]" );
         // initialize lock
+        busylock_init( &kcm->lock , LOCK_KCM_STATE );
+        // initialize KCM type
+        kcm->type = type;
+        remote_busylock_init( XPTR( local_cxy , &kcm->lock ) , LOCK_KCM_STATE );
         // initialize KCM page lists
+        kcm->free_pages_nr   = 0;
+        kcm->busy_pages_nr   = 0;
+        kcm->full_pages_nr   = 0;
         kcm->active_pages_nr = 0;
+        list_root_init( &kcm->free_root );
+        list_root_init( &kcm->busy_root );
+        list_root_init( &kcm->full_root );
         list_root_init( &kcm->active_root );
+        // initialize block size
+        uint32_t block_size = ARROUND_UP( kmem_type_size( type ) , CONFIG_KCM_SLOT_SIZE );
+        kcm->block_size = block_size;
+        // initialize number of blocks per page
+        uint32_t  blocks_nr = (CONFIG_PPM_PAGE_SIZE - CONFIG_KCM_SLOT_SIZE) / block_size;
+        kcm->blocks_nr = blocks_nr;
+        // initialize order and max_blocks
+        kcm->order      = order;
+    kcm->max_blocks = ( CONFIG_PPM_PAGE_SIZE >> order ) - 1;
 #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
+}
+printk("\n[%s] thread[%x,%x] initialised KCM / order %d / max_blocks %d\n",
+__FUNCTION__, this->process->pid, this->trdid, order, kcm->max_blocks );
+#endif
+}  // end kcm_init()
 ///////////////////////////////
 …
+{
         kcm_page_t   * kcm_page;
+        list_entry_t * iter;
+    // build extended pointer on  KCM lock
+    xptr_t lock_xp = XPTR( local_cxy , &kcm->lock );
         // get KCM lock
+        busylock_acquire( &kcm->lock );
+        // release all free pages
+        LIST_FOREACH( &kcm->free_root , iter )
+        {
+                kcm_page = (kcm_page_t *)LIST_ELEMENT( iter , kcm_page_t , list );
+                list_unlink( iter );
+                kcm->free_pages_nr --;
+        remote_busylock_acquire( lock_xp );
+        // release all full pages
+        while( list_is_empty( &kcm->full_root ) == false )
+        {
+                kcm_page = LIST_FIRST( &kcm->full_root , kcm_page_t , list );
+                list_unlink( &kcm_page->list );
                 ppm_free_pages( kcm_page->page );
+        }
+        // release all active pages
+        LIST_FOREACH( &kcm->active_root , iter )
+        {
+                kcm_page = (kcm_page_t *)LIST_ELEMENT( iter , kcm_page_t , list );
+                list_unlink( iter );
+                kcm->free_pages_nr --;
+    // release all empty pages
+    while( list_is_empty( &kcm->active_root ) == false )
+        {
+                kcm_page = LIST_FIRST( &kcm->active_root , kcm_page_t , list );
+                list_unlink( &kcm_page->list );
                 ppm_free_pages( kcm_page->page );
+        }
-        // release all busy pages
-        LIST_FOREACH( &kcm->busy_root , iter )
+        {
-                kcm_page = (kcm_page_t *)LIST_ELEMENT( iter , kcm_page_t , list );
-                list_unlink( iter );
-                kcm->free_pages_nr --;
-                ppm_free_pages( kcm_page->page );
+        }
         // release KCM lock
         busylock_release( &kcm->lock );
+        remote_busylock_release( lock_xp );
+}
+///////////////////////////////
+void * kcm_alloc( kcm_t * kcm )
+{
+//////////////////////////////////
+void * kcm_alloc( uint32_t order )
+{
+    kcm_t      * kcm_ptr;
         kcm_page_t * kcm_page;
+        void       * ptr = NULL;   // pointer on block
+        void       * block_ptr;
+    // min block size is 64 bytes
+    if( order < 6 ) order = 6;
+assert( (order < 12) , "order = %d / must be less than 12" , order );
+    // get local pointer on relevant KCM allocator
+    kcm_ptr = &LOCAL_CLUSTER->kcm[order - 6];
+    // build extended pointer on local KCM lock
+    xptr_t lock_xp = XPTR( local_cxy , &kcm_ptr->lock );
+        // get KCM lock
+        remote_busylock_acquire( lock_xp );
+    // get a non-full kcm_page
+    kcm_page = kcm_get_page( kcm_ptr );
+    if( kcm_page == NULL )
+        {
+                remote_busylock_release( lock_xp );
+                return NULL;
+        }
+        // get a block from selected active page
+        block_ptr = kcm_get_block( kcm_ptr , kcm_page );
+        // release lock
+        remote_busylock_release( lock_xp );
+#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] allocated block %x / order %d / kcm %x / status[%x,%x] / count %d\n",
+__FUNCTION__, this->process->pid, this->trdid, block_ptr, order, kcm_ptr,
+GET_CXY(kcm_page->status), GET_PTR(kcm_page->status), kcm_page->count );
+#endif
+        return block_ptr;
+}  // end kcm_alloc()
+/////////////////////////////////
+void kcm_free( void * block_ptr )
+{
+    kcm_t      * kcm_ptr;
+        kcm_page_t * kcm_page;
+// check argument
+assert( (block_ptr != NULL) , "block pointer cannot be NULL" );
+    // get local pointer on KCM page
+        kcm_page = (kcm_page_t *)((intptr_t)block_ptr & ~CONFIG_PPM_PAGE_MASK);
+    // get local pointer on KCM descriptor
+        kcm_ptr = kcm_page->kcm;
+#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] release block %x / order %d / kcm %x / status [%x,%x] / count %d\n",
+__FUNCTION__, this->process->pid, this->trdid, block_ptr, kcm_ptr->order, kcm_ptr,
+GET_CXY(kcm_page->status), GET_PTR(kcm_page->status), kcm_page->count );
+#endif
+    // build extended pointer on local KCM lock
+    xptr_t lock_xp = XPTR( local_cxy , &kcm_ptr->lock );
         // get lock
+        busylock_acquire( &kcm->lock );
+        // get an active page
+        if( list_is_empty( &kcm->active_root ) )  // no active page => get one
+        {
+                // get a page from free list
+                kcm_page = freelist_get( kcm );
+                if( kcm_page == NULL )
+                {
+                        busylock_release( &kcm->lock );
+                        return NULL;
+                }
+                // insert page in active list
+                list_add_first( &kcm->active_root , &kcm_page->list );
+                kcm->active_pages_nr ++;
+                kcm_page->active = 1;
+        }
+        else                                    // get first page from active list
+        {
+                // get page pointer from active list
+                kcm_page = (kcm_page_t *)LIST_FIRST( &kcm->active_root , kcm_page_t , list );
+        remote_busylock_acquire( lock_xp );
+        // release block
+        kcm_put_block( kcm_ptr , kcm_page , block_ptr );
+        // release lock
+        remote_busylock_release( lock_xp );
+}
+/////////////////////////////////////////////////////////////////////////////////////
+//        Remote access functions
+/////////////////////////////////////////////////////////////////////////////////////
+/////////////////////////////////////////////////////////////////////////////////////
+// This static function can be called by any thread running in any cluster.
+// It returns a local pointer on a block allocated from an non-full kcm_page.
+// It makes a panic if no block available in selected page.
+// It changes the page status as required.
+/////////////////////////////////////////////////////////////////////////////////////
+// @ kcm_cxy  : remote KCM cluster identidfier.
+// @ kcm_ptr  : local pointer on remote KCM allocator.
+// @ kcm_page : pointer on active kcm page to use.
+// @ return a local pointer on the allocated block.
+/////////////////////////////////////////////////////////////////////////////////////
+static void * __attribute__((noinline)) kcm_remote_get_block( cxy_t        kcm_cxy,
+                                                              kcm_t      * kcm_ptr,
+                                                              kcm_page_t * kcm_page )
+{
+    uint32_t order  = hal_remote_l32( XPTR( kcm_cxy , &kcm_ptr->order ) );
+    uint32_t max    = hal_remote_l32( XPTR( kcm_cxy , &kcm_ptr->max_blocks ) );
+    uint32_t count  = hal_remote_l32( XPTR( kcm_cxy , &kcm_page->count ) );
+    uint64_t status = hal_remote_l64( XPTR( kcm_cxy , &kcm_page->status ) );
+    uint32_t size   = 1 << order;
+assert( (count < max) , "kcm_page should not be full" );
+    uint32_t index  = 1;
+    uint64_t mask   = (uint64_t)0x2;
+    uint32_t found  = 0;
+        // allocate first free block in kcm_page, update status,
+    // and count , compute index of allocated block in kcm_page
+    while( index <= max )
+    {
+        if( (status & mask) == 0 )   // block non allocated
+        {
+            hal_remote_s64( XPTR( kcm_cxy , &kcm_page->status ) , status | mask );
+            hal_remote_s64( XPTR( kcm_cxy , &kcm_page->count  ) , count + 1 );
+            found  = 1;
+            break;
+        }
+        index++;
+        mask <<= 1;
+    }
+        // change the page list if almost full
+        if( count == max-1 )
+        {
+                list_remote_unlink( kcm_cxy , &kcm_page->list );
+                hal_remote_atomic_add( XPTR( kcm_cxy , &kcm_ptr->active_pages_nr ) , -1 );
+                list_remote_add_first( kcm_cxy , &kcm_ptr->full_root , &kcm_page->list );
+                hal_remote_atomic_add( XPTR( kcm_cxy , &kcm_ptr->full_pages_nr ) , 1 );
+        }
+        // compute return pointer
+        void * ptr = (void *)((intptr_t)kcm_page + (index * size) );
+#if DEBUG_KCM_REMOTE
+thread_t * this  = CURRENT_THREAD;
+uint32_t   cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_KCM_REMOTE < cycle )
+printk("\n[%s] thread[%x,%x] get block %x in page %x / cluster %x / size %x / count %d\n",
+__FUNCTION__, this->process->pid, this->trdid,
+ptr, kcm_page, kcm_cxy, size, count + 1 );
+#endif
+        return ptr;
+}  // end kcm_remote_get_block()
+/////////////////////////////////////////////////////////////////////////////////////
+// This private static function can be called by any thread running in any cluster.
+// It releases a previously allocated block to the relevant kcm_page.
+// It changes the kcm_page status as required.
+/////////////////////////////////////////////////////////////////////////////////////
+// @ kcm_cxy   : remote KCM cluster identifier
+// @ kcm_ptr   : local pointer on remote KCM.
+// @ kcm_page  : local pointer on kcm_page.
+// @ block_ptr : pointer on block to be released.
+/////////////////////////////////////////////////////////////////////////////////////
+static void __attribute__((noinline)) kcm_remote_put_block ( cxy_t        kcm_cxy,
+                                                             kcm_t      * kcm_ptr,
+                                                             kcm_page_t * kcm_page,
+                                                             void       * block_ptr )
+{
+    uint32_t max    = hal_remote_l32( XPTR( kcm_cxy , &kcm_ptr->max_blocks ) );
+    uint32_t order  = hal_remote_l32( XPTR( kcm_cxy , &kcm_ptr->order ) );
+    uint32_t count  = hal_remote_l32( XPTR( kcm_cxy , &kcm_page->count ) );
+    uint64_t status = hal_remote_l64( XPTR( kcm_cxy , &kcm_page->status ) );
+    uint32_t size   = 1 << order;
+        // compute block index from block pointer
+        uint32_t index = ((intptr_t)block_ptr - (intptr_t)kcm_page) / size;
+    // compute mask in bit vector
+    uint64_t mask = 1 << index;
+assert( (status & mask) , "released page not allocated" );
+    // update status & count in kcm_page
+        hal_remote_s64( XPTR( kcm_cxy , &kcm_page->status ) , status & ~mask );
+        hal_remote_s32( XPTR( kcm_cxy , &kcm_page->count  ) , count - 1 );
+        // change the page list if page was full
+        if( count == max )
+        {
+                list_remote_unlink( kcm_cxy , &kcm_page->list );
+                hal_remote_atomic_add( XPTR( kcm_cxy , &kcm_ptr->full_pages_nr ) , -1 );
+                list_remote_add_last( kcm_cxy , &kcm_ptr->active_root, &kcm_page->list );
+                hal_remote_atomic_add( XPTR( kcm_cxy , &kcm_ptr->active_pages_nr ) , 1 );
+        }
+#if (DEBUG_KCM_REMOTE & 1)
+thread_t * this  = CURRENT_THREAD;
+uint32_t   cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_KCM_REMOTE < cycle )
+printk("\n[%s] thread[%x,%x] released block %x in page %x / cluster %x / size %x / count %d\n",
+__FUNCTION__, this->process->pid, this->trdid, block_ptr, kcm_page, size, count - 1 )
+#endif
+}  // end kcm_remote_put_block()
+/////////////////////////////////////////////////////////////////////////////////////
+// This private static function can be called by any thread running in any cluster.
+// It gets one non-full KCM page from the remote KCM.
+// It allocates a page from remote PPM to populate the freelist, and initialises
+// the kcm_page descriptor when required.
+/////////////////////////////////////////////////////////////////////////////////////
+static kcm_page_t * __attribute__((noinline)) kcm_remote_get_page( cxy_t    kcm_cxy,
+                                                                   kcm_t  * kcm_ptr )
+{
+    kcm_page_t * kcm_page;    // local pointer on remote KCM page
+    uint32_t active_pages_nr = hal_remote_l32( XPTR( kcm_cxy , &kcm_ptr->active_pages_nr ) );
+    if( active_pages_nr > 0 )       // return first active page
+    {
+        kcm_page = LIST_REMOTE_FIRST( kcm_cxy , &kcm_ptr->active_root , kcm_page_t , list );
+    }
+    else                            // allocate a new page from PPM
+        {
+        // get one 4 Kbytes page from remote PPM
+        page_t * page = ppm_remote_alloc_pages( kcm_cxy , 0 );
+            if( page == NULL )
+            {
+                    printk("\n[ERROR] in %s : failed to allocate page in cluster %x\n",
+                __FUNCTION__ , kcm_cxy );
+                    return NULL;
+        }
+            // get remote page base address
+            xptr_t base_xp = ppm_page2base( XPTR( kcm_cxy , page ) );
+        // get local pointer on kcm_page
+            kcm_page = GET_PTR( base_xp );
+            // initialize kcm_page descriptor
+            hal_remote_s32( XPTR( kcm_cxy , &kcm_page->count )  , 0 );
+            hal_remote_s64( XPTR( kcm_cxy , &kcm_page->status ) , 0 );
+            hal_remote_spt( XPTR( kcm_cxy , &kcm_page->kcm )    , kcm_ptr );
+            hal_remote_spt( XPTR( kcm_cxy , &kcm_page->page )   , page );
+            // introduce new page in remote KCM active_list
+            list_remote_add_first( kcm_cxy , &kcm_ptr->active_root , &kcm_page->list );
+            hal_remote_atomic_add( XPTR( kcm_cxy , &kcm_ptr->active_pages_nr ) , 1 );
+        }
+        return kcm_page;
+}  // end kcm_remote_get_page()
+/////////////////////////////////////////
+void * kcm_remote_alloc( cxy_t    kcm_cxy,
+                         uint32_t order )
+{
+    kcm_t      * kcm_ptr;
+    kcm_page_t * kcm_page;
+    void       * block_ptr;
+    if( order < 6 ) order = 6;
+assert( (order < 12) , "order = %d / must be less than 12" , order );
+    // get local pointer on relevant KCM allocator
+    kcm_ptr = &LOCAL_CLUSTER->kcm[order - 6];
+    // build extended pointer on remote KCM lock
+    xptr_t lock_xp = XPTR( kcm_cxy , &kcm_ptr->lock );
+        // get lock
+        remote_busylock_acquire( lock_xp );
+    // get a non-full kcm_page
+    kcm_page = kcm_remote_get_page( kcm_cxy , kcm_ptr );
+    if( kcm_page == NULL )
+        {
+                remote_busylock_release( lock_xp );
+                return NULL;
+        }
         // get a block from selected active page
+        // cannot fail, as an active page cannot be full...
+        ptr  = kcm_get_block( kcm , kcm_page );
+        block_ptr = kcm_remote_get_block( kcm_cxy , kcm_ptr , kcm_page );
         // release lock
+        busylock_release( &kcm->lock );
+        return ptr;
+        remote_busylock_release( lock_xp );
+#if DEBUG_KCM_REMOTE
+thread_t * this  = CURRENT_THREAD;
+uint32_t   cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_KCM_REMOTE < cycle )
+printk("\n[%s] thread[%x,%x] allocated block %x / order %d / kcm[%x,%x]\n",
+__FUNCTION__, this->process->pid, this->trdid, block_ptr, order, kcm_cxy, kcm_ptr );
+#endif
+        return block_ptr;
+}  // end kcm_remote_alloc()
+/////////////////////////////////////
+void kcm_remote_free( cxy_t  kcm_cxy,
+                      void * block_ptr )
+{
+        kcm_t      * kcm_ptr;
+        kcm_page_t * kcm_page;
+// check argument
+assert( (block_ptr != NULL) , "block pointer cannot be NULL" );
+    // get local pointer on remote KCM page
+        kcm_page = (kcm_page_t *)((intptr_t)block_ptr & ~CONFIG_PPM_PAGE_MASK);
+    // get local pointer on remote KCM
+        kcm_ptr = hal_remote_lpt( XPTR( kcm_cxy , &kcm_page->kcm ) );
+    // build extended pointer on remote KCM lock
+    xptr_t lock_xp = XPTR( kcm_cxy , &kcm_ptr->lock );
+        // get lock
+        remote_busylock_acquire( lock_xp );
+        // release block
+        kcm_remote_put_block( kcm_cxy , kcm_ptr , kcm_page , block_ptr );
+        // release lock
+        remote_busylock_release( lock_xp );
+#if DEBUG_KCM_REMOTE
+thread_t * this  = CURRENT_THREAD;
+uint32_t   cycle = (uint32_t)hal_get_cycles();
+uint32_t   order = hal_remote_l32( XPTR( kcm_cxy , &kcm_ptr->order ) );
+if( DEBUG_KCM_REMOTE < cycle )
+printk("\n[%s] thread[%x,%x] released block %x / order %d / kcm[%x,%x]\n",
+__FUNCTION__, this->process->pid, this->trdid, block_ptr, order, kcm_cxy, kcm_ptr );
+#endif
+}  // end kcm_remote_free
+/////////////////////////////////////////
+void kcm_remote_display( cxy_t   kcm_cxy,
+                         kcm_t * kcm_ptr )
+{
+    uint32_t order           = hal_remote_l32( XPTR( kcm_cxy , &kcm_ptr->order) );
+    uint32_t full_pages_nr   = hal_remote_l32( XPTR( kcm_cxy , &kcm_ptr->full_pages_nr ) );
+    uint32_t active_pages_nr = hal_remote_l32( XPTR( kcm_cxy , &kcm_ptr->active_pages_nr ) );
+        printk("*** KCM / cxy %x / order %d / full_pages %d / empty_pages %d / active_pages %d\n",
+        kcm_cxy, order, full_pages_nr, active_pages_nr );
+}
-///////////////////////////
-void kcm_free( void * ptr )
+{
-        kcm_page_t * kcm_page;
-        kcm_t      * kcm;
-// check argument
-assert( (ptr != NULL) , "pointer cannot be NULL" );
-        kcm_page = (kcm_page_t *)((intptr_t)ptr & ~CONFIG_PPM_PAGE_MASK);
-        kcm      = kcm_page->kcm;
-        // get lock
-        busylock_acquire( &kcm->lock );
-        // release block
-        kcm_put_block( kcm , kcm_page , ptr );
-        // release lock
-        busylock_release( &kcm->lock );
+}
-////////////////////////////
-void kcm_print (kcm_t * kcm)
+{
-        printk("*** KCM type = %s / free_pages = %d / busy_pages = %d / active_pages = %d\n",
-               kmem_type_str( kcm->type ) ,
-               kcm->free_pages_nr ,
-               kcm->busy_pages_nr ,
-               kcm->active_pages_nr );
+}

trunk/kernel/mm/kcm.h

-                      r619
+                      r635
 /*
  * kcm.h - Per-cluster Kernel Cache Manager definition.
+ * kcm.h - Kernel Cache Manager definition.
+ *
+ * Authors  Ghassan Almaless (2008,2009,2010,2011,2012)
+ *          Alain Greiner    (2016,2017,2018)
+ * Authors    Alain Greiner (2016,2017,2018,2019)
+ *
  * Copyright (c) UPMC Sorbonne Universites
 …
 #include <kmem.h>
+#define KCM_PAGE_FULL     0
+#define KCM_PAGE_EMPTY    1
+#define KCM_PAGE_ACTIVE   2
 /****************************************************************************************
  * This structure defines a generic Kernel Cache Manager, that is a block allocator,
+ * 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 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
+ * allocator defined in the cluster manager, to allocate the other ones...
+ * for fixed size objects. It exists in each cluster a specific KCM allocator for
+ * the following block sizes: 64, 128, 256, 512, 1024, 2048 bytes.
+ * These six KCM allocators are initialized by the cluster_init() function.
+ *
+ * Each KCM cache is implemented as a set o 4 Kbytes pages. A kcm_page is split in slots,
+ * where each slot can contain one block. in each kcm_page, the first slot (that cannot
+ * be smaller than 64 bytes) contains the kcm page descriptor, defined below
+ *
+ * To allow any thread running in any cluster to directly access the KCM of any cluster,
+ * ALMOS-MKH defines two sets of access functions, for local or remote access.
  ***************************************************************************************/
 typedef struct kcm_s
+{
+        busylock_t           lock;             /*! protect KCM ammocator                   */
+        uint32_t             block_size;       /*! rounded block size (bytes)              */
+        uint32_t             blocks_nr;        /*! max number of blocks per page           */
+        remote_busylock_t    lock;             /*! protect KCM allocator                   */
+        list_entry_t         full_root;        /*! root of full pages list                 */
         list_entry_t         active_root;      /*! root of active pages list               */
-        list_entry_t         busy_root;        /*! root of busy pages list                 */
-        list_entry_t         free_root;        /*! root of free pages list                 */
+        uint32_t             free_pages_nr;    /*! number of free pages                    */
+        uint32_t             busy_pages_nr;    /*! number of busy pages                    */
+        uint32_t             full_pages_nr;    /*! number of busy pages                    */
         uint32_t             active_pages_nr;  /*! number of active pages                  */
+        uint32_t             type;             /*! KCM type                                */
+        uint32_t             order;            /*! ln( block_size )                        */
+        uint32_t             max_blocks;       /*! max number of blocks per page           */
+}
 kcm_t;
 …
 /****************************************************************************************
  * This structure defines a KCM-page descriptor.
+ * A KCM-page contains at most (CONFIG_PPM_PAGE_SIZE / CONFIG_KCM_SLOT_SIZE) blocks.
+ * This kcm page descriptor is stored in the first slot of the page.
+ * A KCM-page contains at most (CONFIG_PPM_PAGE_SIZE / CONFIG_KCM_SLOT_SIZE) slots,
+ * and each slot contains one block. The kcm page descriptor is stored in first slot.
+ * The current allocation status is defined by the 64 bits "status" bit vector: each
+ * non zero bit defines an allocated block / "counts is the number of allocated blocks.
+ * Each kcm_page is registered in one of the two following page_list:
+ * - full   : when count == max
+ * - active : count < max
  ***************************************************************************************/
 typedef struct kcm_page_s
+{
+        uint32_t        bitmap[2];             /*! at most 64 blocks in a single page      */
+        list_entry_t    list;                  /*! [active / busy / free] list member      */
+        kcm_t         * kcm;                   /*! pointer on kcm allocator                */
+        page_t        * page;                  /*! pointer on the physical page descriptor */
+        uint32_t        count;                 /*! number of allocated blocks              */
+        uint32_t        busy;                  /*! page busy if non zero                   */
+        uint32_t        active;                /*! page active if non zero                 */
+        uint64_t            status;            /*! bit vector: non-zero == allocated       */
+        uint32_t            count;             /*! number of allocated blocks in page      */
+        list_entry_t        list;              /*! [active / busy / free] list member      */
+        kcm_t             * kcm;               /*! pointer on kcm allocator                */
+        page_t            * page;              /*! pointer on the physical page descriptor */
+}
 kcm_page_t;
 /****************************************************************************************
+ * This function initializes a generic Kernel Cache Manager.
+ * This function must be called by a local thread.
+ * It initializes a Kernel Cache Manager, depending on block size.
  ****************************************************************************************
  * @ kcm      : pointer on KCM manager to initialize.
  * @ type     : KCM allocator type.
+ * @ order    : ln(block_size).
  ***************************************************************************************/
 void kcm_init( kcm_t    * kcm,
                uint32_t   type );
+               uint32_t   order );
 /****************************************************************************************
+ * This function releases all memory allocated to a generic Kernel Cache Manager.
+ * This function must be called by a local thread.
+ * It releases all memory allocated to a Kernel Cache Manager.
  ****************************************************************************************
  * @ kcm      : pointer on KCM manager to destroy.
 …
 /****************************************************************************************
  * This function allocates one single object from a Kernel Cache Manager
  * The object size must be smaller than one page size.
+ * This function must be called by a local thread.
+ * It allocates one block from the local Kernel Cache Manager.
  ****************************************************************************************
  * @ kcm      :  pointer on the selected KCM allocator
+ * @ order     :  ln( block-size ) == KCM allocator identifier.
  * @ return pointer on allocated block if success / return NULL if failure
  ***************************************************************************************/
 void * kcm_alloc( kcm_t * kcm );
+void * kcm_alloc( uint32_t order );
 /****************************************************************************************
+ * This function releases a previouly allocated block containing one object.
+ * This function must be called by a local thread.
+ * It releases a previouly allocated block to the local Kernel Cache Manager.
  ****************************************************************************************
  * @ ptr   : local pointer on the allocated buffer.
+ * @ block_ptr   : local pointer on the released block.
  ***************************************************************************************/
 void kcm_free( void * ptr );
+void kcm_free( void    * block_ptr );
 /****************************************************************************************
+ * This function prints KCM allocator state (for debug only).
+ * This function can be called by any thread running in any cluster.
+ * It allocates one fixed size block from a remote Kernel Cache Manager.
  ****************************************************************************************
+ * @ kcm   : local pointer on the selected KCM allocator.
+ * @ kcm_cxy   : remote KCM cluster identifier.
+ * @ order     :  ln( block-size ) == KCM allocator identifier.
+ * @ return a local pointer on allocated block if success / return NULL if failure
  ***************************************************************************************/
+void kcm_print( kcm_t * kcm );
+void * kcm_remote_alloc( cxy_t    kcm_cxy,
+                         uint32_t order );
+/****************************************************************************************
+ * This function can be called by any thread running in any cluster.
+ * It releases a previouly allocated block to a remote Kernel Cache Manager.
+ ****************************************************************************************
+ * @ kcm_cxy     : remote KCM cluster identifier.
+ * @ block_ptr   : local pointer on the released buffer in remote cluster.
+ ***************************************************************************************/
+void kcm_remote_free( cxy_t     kcm_cxy,
+                      void    * block_ptr );
+/****************************************************************************************
+ * This debug function can be called by any thread running in any cluster.
+ * It diplays on TXT0 the current state of a local KCM allocator.
+ ****************************************************************************************
+ * @ kcm_cxy : remote KCM cluster identifier.
+ * @ kcm_ptr : local pointer on remote KCM.
+ ***************************************************************************************/
+void kcm_remote_display( cxy_t   kcm_cxy,
+                         kcm_t * kcm_ptr );
 #endif  /* _KCM_H_ */

trunk/kernel/mm/khm.h

-                      r619
+                      r635
 /*******************************************************************************************
  * This structure defines a Kernel Heap Manager (KHM) in a given cluster.
  * It is used to allocate memory objects, that too large, or not enough replicated
+ * It is used to allocate memory objects, that are too large, or not enough replicated
  * to use a dedicated KCM allocator.
  ******************************************************************************************/
 …
+{
         uint32_t   busy;           /*! free block if zero                                     */
         uint32_t   size;           /*! block size                                                   */
+        uint32_t   size;           /*! block size                                             */
+}
 khm_block_t;

trunk/kernel/mm/kmem.c

-                      r619
+                      r635
  * kmem.c - kernel memory allocator implementation.
+ *
+ * Authors  Ghassan Almaless (2008,2009,2010,2011,2012)
+ *          Alain Greiner (2016,2017,2018)
+ * Authors  Alain Greiner (2016,2017,2018,2019)
+ *
  * Copyright (c) UPMC Sorbonne Universites
 …
 #include <hal_special.h>
 #include <printk.h>
 #include <busylock.h>
+#include <cluster.h>
 #include <memcpy.h>
 #include <khm.h>
 #include <ppm.h>
+#include <kcm.h>
 #include <page.h>
-#include <cluster.h>
-#include <thread.h>
-#include <process.h>
-#include <chdev.h>
-#include <mapper.h>
-#include <vfs.h>
-#include <fatfs.h>
-#include <ramfs.h>
-#include <user_dir.h>
-#include <remote_sem.h>
-#include <remote_barrier.h>
-#include <remote_mutex.h>
-#include <remote_condvar.h>
-#include <mapper.h>
-#include <grdxt.h>
-#include <vseg.h>
 #include <kmem.h>
-/////////////////////////////////
-void kmem_print_kcm_table( void )
+{
-        uint32_t    index;
-        kcm_t     * kcm;
-        cluster_t * cluster = LOCAL_CLUSTER;
-        printk("\n    *** KCM Pointers Table ***\n");
-        for( index = 0 ; index < KMEM_TYPES_NR ; index++ )
+        {
-                kcm = cluster->kcm_tbl[index];
-                if( kcm != NULL )
+                {
-                        if( index == kcm->type )
+                        {
-                                printk("     - KCM[%s] (at address %x) is OK\n",
-                                       kmem_type_str( index ) , (intptr_t)kcm );
+                        }
-                        else
+                        {
-                                printk("     - KCM[%s] (at address %x) is KO : has type %s\n",
-                                       kmem_type_str( index ) , (intptr_t)kcm , kmem_type_str( kcm->type ) );
+                        }
+                }
+        }
+}
-/////////////////////////////////////////
-uint32_t  kmem_type_size( uint32_t type )
+{
-    if     ( type == KMEM_PAGE )          return CONFIG_PPM_PAGE_SIZE;
-    else if( type == KMEM_GENERIC )       return 0;
-    else if( type == KMEM_KCM )           return sizeof( kcm_t );
-    else if( type == KMEM_VSEG )          return sizeof( vseg_t );
-    else if( type == KMEM_DEVICE )        return sizeof( chdev_t );
-    else if( type == KMEM_MAPPER )        return sizeof( mapper_t );
-    else if( type == KMEM_PROCESS )       return sizeof( process_t );
-    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_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 );
-    else if( type == KMEM_VFS_CTX )       return sizeof( vfs_ctx_t );
-    else if( type == KMEM_VFS_INODE )     return sizeof( vfs_inode_t );
-    else if( type == KMEM_VFS_DENTRY )    return sizeof( vfs_dentry_t );
-    else if( type == KMEM_VFS_FILE )      return sizeof( vfs_file_t );
-    else if( type == KMEM_SEM )           return sizeof( remote_sem_t );
-    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;
-        else                                  return 0;
+}
-/////////////////////////////////////
-char * kmem_type_str( uint32_t type )
+{
-        if     ( type == KMEM_PAGE )          return "KMEM_PAGE";
-        else if( type == KMEM_GENERIC )       return "KMEM_GENERIC";
-        else if( type == KMEM_KCM )           return "KMEM_KCM";
-        else if( type == KMEM_VSEG )          return "KMEM_VSEG";
-        else if( type == KMEM_DEVICE )        return "KMEM_DEVICE";
-        else if( type == KMEM_MAPPER )        return "KMEM_MAPPER";
-        else if( type == KMEM_PROCESS )       return "KMEM_PROCESS";
-        else if( type == KMEM_CPU_CTX )       return "KMEM_CPU_CTX";
-        else if( type == KMEM_FPU_CTX )       return "KMEM_FPU_CTX";
-        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";
-    else if( type == KMEM_VFS_CTX )       return "KMEM_VFS_CTX";
-    else if( type == KMEM_VFS_INODE )     return "KMEM_VFS_INODE";
-    else if( type == KMEM_VFS_DENTRY )    return "KMEM_VFS_DENTRY";
-    else if( type == KMEM_VFS_FILE )      return "KMEM_VFS_FILE";
-    else if( type == KMEM_SEM )           return "KMEM_SEM";
-    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";
-        else                                  return "undefined";
+}
-/////////////////////////////////////////////////////////////////////////////////////////////
-// This static function dynamically allocates and initializes a specific KCM allocator.
-// It uses the KCM allocator embedded in cluster manager, initialized by cluster_init().
-/////////////////////////////////////////////////////////////////////////////////////////////
-static error_t kmem_create_kcm( uint32_t type )
+{
-        kcm_t    * kcm;
-        assert( ((type > 1) && (type < KMEM_TYPES_NR) ) , "illegal KCM type" );
-#if DEBUG_KMEM
-thread_t * this = CURRENT_THREAD;
-uint32_t cycle = (uint32_t)hal_get_cycles();
-if( DEBUG_KMEM < cycle )
-printk("\n[%s] thread[%x,%x] enter / KCM type %s missing in cluster %x / cycle %d\n",
-__FUNCTION__, this->process->pid, this->trdid, kmem_type_str( type ), local_cxy, cycle );
-#endif
-        cluster_t * cluster = LOCAL_CLUSTER;
-        // allocate memory for the requested KCM allocator
-        // from the KCM allocator embedded in cluster descriptor
-        kcm = kcm_alloc( &cluster->kcm );
-        if( kcm == NULL )
+        {
-                printk("\n[ERROR] in %s : failed to create KCM type %d in cluster %x\n",
-                       __FUNCTION__ , type , local_cxy );
-                return ENOMEM;
+        }
-        // initialize the new KCM allocator
-        kcm_init( kcm , type );
-        // register it in the KCM pointers Table
-        cluster->kcm_tbl[type] = kcm;
-        hal_fence();
-#if DEBUG_KMEM
-cycle = (uint32_t)hal_get_cycles();
-if( DEBUG_KMEM < cycle )
-printk("\n[%s] thread[%x,%x] exit / cycle %d\n",
-__FUNCTION__, this->process->pid, this->trdid, cycle );
-#endif
-        return 0;
+}
 /////////////////////////////////////
 void * kmem_alloc( kmem_req_t * req )
+{
+        cluster_t * cluster = LOCAL_CLUSTER;
+        uint32_t    type;
+        uint32_t    flags;
+        uint32_t    size;    // ln( pages ) if PPM / bytes if KHM / unused if KCM
+        void      * ptr;     // memory buffer if KHM or KCM / page descriptor if PPM
+        uint32_t    type;    // KMEM_PPM / KMEM_KCM / KMEM_KHM
+        uint32_t    flags;   // AF_NONE / AF_ZERO / AF_KERNEL
+        uint32_t    order;   // PPM: ln(pages) / KCM: ln(bytes) / KHM: bytes
         type  = req->type;
         size  = req->size;
+        order = req->order;
         flags = req->flags;
+        assert( (type < KMEM_TYPES_NR) , "illegal KMEM request type" );
+    ////////////////////////////////// PPM
+        if( type == KMEM_PPM )
+        {
+                // allocate the number of requested pages
+                page_t * page_ptr = (void *)ppm_alloc_pages( order );
+                if( page_ptr == NULL )
+                {
+                        printk("\n[ERROR] in %s : PPM failed / order %d / cluster %x\n",
+                        __FUNCTION__ , order , local_cxy );
+                        return NULL;
+                }
+        xptr_t page_xp = XPTR( local_cxy , page_ptr );
+                // reset page if requested
+                if( flags & AF_ZERO ) page_zero( page_ptr );
+        // get pointer on buffer from the page descriptor
+        void * ptr = GET_PTR( ppm_page2base( page_xp ) );
 #if DEBUG_KMEM
 thread_t * this = CURRENT_THREAD;
 uint32_t cycle = (uint32_t)hal_get_cycles();
+thread_t * this  = CURRENT_THREAD;
+uint32_t   cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_KMEM < cycle )
+printk("\n[%s] thread [%x,%x] enter / %s / size %d / cluster %x / cycle %d\n",
+printk("\n[%s] thread[%x,%x] from PPM / %d page(s) / ppn %x / cxy %x / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid,
+<<order, ppm_page2ppn(XPTR(local_cxy,ptr)), local_cxy, cycle );
+#endif
+        return ptr;
+        }
+    ///////////////////////////////////// KCM
+        else if( type == KMEM_KCM )
+        {
+                // allocate memory from KCM
+                void * ptr = kcm_alloc( order );
+                if( ptr == NULL )
+                {
+                        printk("\n[ERROR] in %s : KCM failed / order %d / cluster %x\n",
+                    __FUNCTION__ , order , local_cxy );
+                        return NULL;
+                }
+                // reset memory if requested
+                if( flags & AF_ZERO ) memset( ptr , 0 , 1<<order );
+#if DEBUG_KMEM
+thread_t * this  = CURRENT_THREAD;
+uint32_t   cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_KMEM < cycle )
+printk("\n[%s] thread [%x,%x] from KCM / %d bytes / base %x / cxy %x / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid,
+<<order, ptr, local_cxy, cycle );
+#endif
+        return ptr;
+        }
+    //////////////////////////////////// KHM
+        else if( type == KMEM_KHM )
+        {
+                // allocate memory from KHM
+                void * ptr = khm_alloc( &LOCAL_CLUSTER->khm , order );
+                if( ptr == NULL )
+                {
+                        printk("\n[ERROR] in %s : KHM failed / order %d / cluster %x\n",
+                        __FUNCTION__ , order , local_cxy );
+                        return NULL;
+                }
+                // reset memory if requested
+                if( flags & AF_ZERO ) memset( ptr , 0 , order );
+#if DEBUG_KMEM
+thread_t * this  = CURRENT_THREAD;
+uint32_t   cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_KMEM < cycle )
+printk("\n[%s] thread[%x,%x] from KHM / %d bytes / base %x / cxy %x / cycle %d\n",
 __FUNCTION__, this->process->pid, this->trdid,
+kmem_type_str( type ), size, local_cxy, cycle );
+#endif
+        // analyse request type
+        if( type == KMEM_PAGE )                        // PPM allocator
+        {
+                // allocate the number of requested pages
+                ptr = (void *)ppm_alloc_pages( size );
+                if( ptr == NULL )
+                {
+                        printk("\n[ERROR] in %s : failed for type %d / size %d in cluster %x\n",
+                            __FUNCTION__ , type , size , local_cxy );
+                        return NULL;
+                }
+                // reset page if requested
+                if( flags & AF_ZERO ) page_zero( (page_t *)ptr );
+#if DEBUG_KMEM
+cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_KMEM < cycle )
+printk("\n[%s] thread[%x,%x] exit / %d page(s) allocated / ppn %x / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid,
+<<size, ppm_page2ppn(XPTR(local_cxy,ptr)), cycle );
+#endif
+        }
+        else if( type == KMEM_GENERIC )                // KHM allocator
+        {
+                // allocate memory from KHM
+                ptr = khm_alloc( &cluster->khm , size );
+                if( ptr == NULL )
+                {
+                        printk("\n[ERROR] in %s : failed for type %d / size %d in cluster %x\n",
+                            __FUNCTION__ , type , size , local_cxy );
+                        return NULL;
+                }
+                // reset memory if requested
+                if( flags & AF_ZERO ) memset( ptr , 0 , size );
+#if DEBUG_KMEM
+cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_KMEM < cycle )
+printk("\n[%s] thread[%x,%x] exit / type %s allocated / base %x / size %d / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid,
+kmem_type_str( type ), (intptr_t)ptr, size, cycle );
+#endif
+        }
+        else                                           // KCM allocator
+        {
+                // initialize the KCM allocator if not already done
+                if( cluster->kcm_tbl[type] == NULL )
+                {
+            // get lock protecting local kcm_tbl[] array
+                        busylock_acquire( &cluster->kcm_lock );
+            // create missing KCM
+                        error_t error = kmem_create_kcm( type );
+            // release lock protecting local kcm_tbl[] array
+                        busylock_release( &cluster->kcm_lock );
+                        if ( error )
+            {
+                 printk("\n[ERROR] in %s : cannot create KCM type %d in cluster %x\n",
+                 __FUNCTION__, type, local_cxy );
+                 return NULL;
+            }
+                }
+                // allocate memory from KCM
+                ptr = kcm_alloc( cluster->kcm_tbl[type] );
+                if( ptr == NULL )
+                {
+                        printk("\n[ERROR] in %s : failed for type %d / size %d in cluster %x\n",
+                    __FUNCTION__ , type , size , local_cxy );
+                        return NULL;
+                }
+                // reset memory if requested
+                if( flags & AF_ZERO ) memset( ptr , 0 , kmem_type_size( type ) );
+#if DEBUG_KMEM
+cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_KMEM < cycle )
+printk("\n[%s] thread [%x,%x] exit / type %s allocated / base %x / size %d / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, kmem_type_str(type), (intptr_t)ptr,
+kmem_type_size(type), cycle );
+#endif
+        }
+        return ptr;
+}
+order, ptr, local_cxy, cycle );
+#endif
+        return ptr;
+        }
+    else
+    {
+        printk("\n[ERROR] in %s : illegal allocator type\n", __FUNCTION__);
+        return NULL;
+    }
+}  // end kmem_alloc()
 //////////////////////////////////
 void kmem_free( kmem_req_t * req )
+{
+        if( req->type >= KMEM_TYPES_NR )
+        {
+                assert( false , "illegal request type\n" );
+        }
+        switch(req->type)
+        {
+                case KMEM_PAGE:
+                        ppm_free_pages( (page_t*)req->ptr );
+                        return;
+                case KMEM_GENERIC:
+                        khm_free( req->ptr );
+                        return;
+                default:
+                        kcm_free( req->ptr );
+                        return;
+        }
+}
+    uint32_t type = req->type;
+        if( type == KMEM_PPM )
+        {
+        page_t * page = GET_PTR( ppm_base2page( XPTR( local_cxy , req->ptr ) ) );
+        ppm_free_pages( page );
+    }
+    else if( type == KMEM_KCM )
+    {
+        kcm_free( req->ptr );
+        }
+    else if( type == KMEM_KHM )
+    {
+        khm_free( req->ptr );
+    }
+    else
+    {
+        printk("\n[ERROR] in %s : illegal allocator type\n", __FUNCTION__);
+    }
+}  // end kmem_free()
+///////////////////////////////////////////
+void * kmem_remote_alloc( cxy_t        cxy,
+                          kmem_req_t * req )
+{
+        uint32_t    type;    // KMEM_PPM / KMEM_KCM / KMEM_KHM
+        uint32_t    flags;   // AF_ZERO / AF_KERNEL / AF_NONE
+        uint32_t    order;   // PPM: ln(pages) / KCM: ln(bytes) / KHM: bytes
+        type  = req->type;
+        order = req->order;
+        flags = req->flags;
+        ///////////////////////////////// PPM
+        if( type == KMEM_PPM )
+        {
+                // allocate the number of requested pages
+                page_t * page_ptr = ppm_remote_alloc_pages( cxy , order );
+                if( page_ptr == NULL )
+                {
+                        printk("\n[ERROR] in %s : failed for PPM / order %d in cluster %x\n",
+                        __FUNCTION__ , order , cxy );
+                        return NULL;
+                }
+        xptr_t page_xp = XPTR( cxy , page_ptr );
+        // get pointer on buffer from the page descriptor
+        xptr_t base_xp = ppm_page2base( page_xp );
+                // reset page if requested
+                if( flags & AF_ZERO ) hal_remote_memset( base_xp , 0 , CONFIG_PPM_PAGE_SIZE );
+        void * ptr = GET_PTR( base_xp );
+#if DEBUG_KMEM_REMOTE
+thread_t * this = CURRENT_THREAD;
+uint32_t   cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_KMEM_REMOTE < cycle )
+printk("\n[%s] thread[%x,%x] from PPM / %d page(s) / ppn %x / cxy %x / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid,
+<<order, ppm_page2ppn(XPTR(local_cxy,ptr)), cxy, cycle );
+#endif
+        return ptr;
+        }
+    /////////////////////////////////// KCM
+        else if( type == KMEM_KCM )
+        {
+                // allocate memory from KCM
+                void * ptr = kcm_remote_alloc( cxy , order );
+                if( ptr == NULL )
+                {
+                        printk("\n[ERROR] in %s : failed for KCM / order %d in cluster %x\n",
+                    __FUNCTION__ , order , cxy );
+                        return NULL;
+                }
+                // reset memory if requested
+                if( flags & AF_ZERO )  hal_remote_memset( XPTR( cxy , ptr ) , 0 , 1<<order );
+#if DEBUG_KMEM_REMOTE
+thread_t * this = CURRENT_THREAD;
+uint32_t   cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_KMEM_REMOTE < cycle )
+printk("\n[%s] thread [%x,%x] from KCM / %d bytes / base %x / cxy %x / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid,
+<<order, ptr, cxy, cycle );
+#endif
+        return ptr;
+        }
+        /////////////////////////////////// KHM
+        else if( type == KMEM_KHM )
+        {
+        printk("\n[ERROR] in %s : remote access not supported for KHM\n", __FUNCTION__  );
+                return NULL;
+        }
+    else
+    {
+        printk("\n[ERROR] in %s : illegal allocator type\n", __FUNCTION__);
+        return NULL;
+    }
+}  // kmem_remote_malloc()
+////////////////////////////////////////
+void kmem_remote_free( cxy_t        cxy,
+                       kmem_req_t * req )
+{
+    uint32_t type = req->type;
+        if( type == KMEM_PPM )
+        {
+        page_t * page = GET_PTR( ppm_base2page( XPTR( cxy , req->ptr ) ) );
+        ppm_remote_free_pages( cxy , page );
+    }
+    else if( type == KMEM_KCM )
+    {
+        kcm_remote_free( cxy , req->ptr );
+        }
+    else if( type == KMEM_KHM )
+    {
+        printk("\n[ERROR] in %s : remote access not supported for KHM\n", __FUNCTION__ );
+    }
+    else
+    {
+        printk("\n[ERROR] in %s : illegal allocator type\n", __FUNCTION__);
+    }
+}  // end kmem_remote_free()

trunk/kernel/mm/kmem.h

-                      r619
+                      r635
  * kmem.h - kernel unified memory allocator interface
+ *
+ * Authors  Ghassan Almaless (2008,2009,2010,2011,2012)
+ *          Alain Greiner (2016,2017,2018)
+ * Authors  Alain Greiner (2016,2017,2018,2019)
+ *
  * Copyright (c) UPMC Sorbonne Universites
 …
 /*************************************************************************************
+ * This enum defines the Kernel Memory Types for dynamically allocated objects.
+ * WARNING : this enum must be kepts consistent with use in kmem.c file.
+ * This enum defines the three Kernel Memory Allocaror types:
  ************************************************************************************/
 enum
+{
+    KMEM_PAGE             = 0,   /*! reserved for PPM allocator                     */
+    KMEM_GENERIC          = 1,   /*! reserved for KHM allocator                     */
+    KMEM_KCM              = 2,   /*! kcm_t                                          */
+    KMEM_VSEG             = 3,   /*! vseg_t                                         */
+    KMEM_DEVICE           = 4,   /*! device_t                                       */
+    KMEM_MAPPER           = 5,   /*! mapper_t                                       */
+    KMEM_PROCESS          = 6,   /*! process_t                                      */
+    KMEM_CPU_CTX          = 7,   /*! hal_cpu_context_t                              */
+    KMEM_FPU_CTX          = 8,   /*! hal_fpu_context_t                              */
+    KMEM_GEN_BARRIER      = 9,   /*! generi_cbarrier_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_DIR              = 20,  /*! remote_dir_t                                   */
+    KMEM_512_BYTES        = 21,  /*! 512 bytes aligned                              */
+    KMEM_TYPES_NR         = 22,
+    KMEM_PPM              = 0,   /*! PPM allocator                                  */
+    KMEM_KCM              = 1,   /*! KCM allocator                                  */
+    KMEM_KHM              = 2,   /*! KHM allocator                                  */
 };
 …
 typedef struct kmem_req_s
+{
     uint32_t      type;   /*! request type                                          */
     uint32_t      size;   /*! ln2(nb_pages) if PPM / bytes if KHM / unused by KCM   */
+    uint32_t      type;   /*! KMEM_PPM / KMEM_KCM / KMEM_KHM                        */
+    uint32_t      order;  /*! PPM: ln2(pages) / KCM: ln2(bytes) / KHM: bytes        */
     uint32_t      flags;  /*! request attributes                                    */
     void        * ptr;    /*! local pointer on allocated buffer (only used by free) */
 …
 /*************************************************************************************
  * This generic function allocates physical memory in the local cluster
  * as specified by the request descriptor.
  * It uses three specialised physical memory allocators, depending on request type:
  * - PPM (Physical Pages Manager) allocates N contiguous physical pages,
  *       N must be a power of 2.
  * - KHM (Kernel Heap Manager) allocates a physical memory buffer,
  *       that can have any size.
  * - KCM (Kernel Cache Manager) allocates various fixed size objects,
  *       handling a dedicated cache for each object type.
+ * These two functions allocate physical memory in a local or remote cluster
+ * as specified by the kmem_req_t request descriptor, and return a local pointer
+ * on the allocated buffer. It uses three specialised physical memory allocators:
+ * - PPM (Physical Pages Manager) allocates N contiguous small physical pages.
+ *       N is a power of 2, and req.order = ln(N). Implement the buddy algorithm.
+ * - KCM (Kernel Cache Manager) allocates aligned blocks of M bytes from a cache.
+ *       M is a power of 2, and req.order = ln( M ). One cache per block size.
+ * - KHM (Kernel Heap Manager) allocates physical memory buffers of M bytes,
+ *       M can have any value, and req.order = M.
  *************************************************************************************
+ * @ req   : local pointer to allocation request.
+ * @ 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.
+ * @ cxy   : target cluster identifier for a remote access.
+ * @ req   : local pointer on allocation request.
+ * @ return local pointer on allocated buffer if success / return NULL if no memory.
  ************************************************************************************/
 void * kmem_alloc( kmem_req_t * req );
+void * kmem_remote_alloc( cxy_t        cxy,
+                          kmem_req_t * req );
 /*************************************************************************************
  * This function releases previously allocated physical memory, as specified
  * by the "type" and "ptr" fiels of the kmem-req_t request.
+ * These two functions release previously allocated physical memory, as specified
+ * by the <type> and <ptr> fields of the kmem_req_t request descriptor.
  *************************************************************************************
+ * @ cxy   : target cluster identifier for a remote access.
  * @ req : local pointer to request descriptor.
  ************************************************************************************/
 void  kmem_free ( kmem_req_t * req );
+/*************************************************************************************
+ * This function returns a printable string for a kmem object type.
+ *************************************************************************************
+ * @ type   : kmem object type.
+ ************************************************************************************/
+char * kmem_type_str( uint32_t type );
+/*************************************************************************************
+ * This function returns the size (bytes) for a kmem object type.
+ *************************************************************************************
+ * @ type   : kmem object type.
+ ************************************************************************************/
+uint32_t kmem_type_size( uint32_t type );
+/*************************************************************************************
+ * This function displays the content of the KCM pointers Table
+ ************************************************************************************/
+void kmem_print_kcm_table( void );
+void  kmem_remote_free( cxy_t        cxy,
+                        kmem_req_t * req );

trunk/kernel/mm/mapper.c

-                      r628
+                      r635
     error_t    error;
     // allocate memory for mapper
     req.type  = KMEM_MAPPER;
     req.size  = sizeof(mapper_t);
+    // allocate memory for mapper descriptor
+    req.type  = KMEM_KCM;
+    req.order = bits_log2( sizeof(mapper_t) );
     req.flags = AF_KERNEL | AF_ZERO;
     mapper    = (mapper_t *)kmem_alloc( &req );
+    mapper    = kmem_alloc( &req );
     if( mapper == NULL )
 …
                         CONFIG_MAPPER_GRDXT_W2,
                         CONFIG_MAPPER_GRDXT_W3 );
     if( error )
+    {
         printk("\n[ERROR] in %s : cannot initialize radix tree\n", __FUNCTION__ );
         req.type  = KMEM_MAPPER;
+        req.type  = KMEM_KCM;
         req.ptr   = mapper;
         kmem_free( &req );
 …
+        {
             // remove page from mapper and release to PPM
             mapper_release_page( mapper , page );
+            mapper_remote_release_page( XPTR( local_cxy , mapper ) , page );
             // update start_key value for next page
 …
     // release memory for mapper descriptor
     req.type = KMEM_MAPPER;
+    req.type = KMEM_KCM;
     req.ptr  = mapper;
     kmem_free( &req );
 }  // end mapper_destroy()
+////////////////////////////////////////////////////////
+error_t mapper_remote_handle_miss( xptr_t     mapper_xp,
+                                   uint32_t   page_id,
+                                   xptr_t   * page_xp_ptr )
+{
+    error_t    error;
+    thread_t * this = CURRENT_THREAD;
+    // get target mapper cluster and local pointer
+    cxy_t      mapper_cxy = GET_CXY( mapper_xp );
+    mapper_t * mapper_ptr = GET_PTR( mapper_xp );
+#if DEBUG_MAPPER_HANDLE_MISS
+uint32_t      cycle = (uint32_t)hal_get_cycles();
+char          name[CONFIG_VFS_MAX_NAME_LENGTH];
+vfs_inode_t * inode = mapper->inode;
+if( (DEBUG_MAPPER_HANDLE_MISS < cycle) && (inode != NULL) )
+{
+    vfs_inode_get_name( XPTR( local_cxy , inode ) , name );
+    printk("\n[%s] thread[%x,%x] enter for page %d in <%s> / cluster %x / cycle %d",
+    __FUNCTION__, this->process->pid, this->trdid, page_id, name, mapper_cxy, cycle );
+    if( DEBUG_MAPPER_HANDLE_MISS & 1 ) grdxt_display( XPTR(local_cxy,&mapper->rt), name );
+}
+if( (DEBUG_MAPPER_HANDLE_MISS < cycle) && (inode == NULL) )
+{
+    printk("\n[%s] thread[%x,%x] enter for page %d in FAT / cluster %x / cycle %d",
+    __FUNCTION__, this->process->pid, this->trdid, page_id, mapper_cxy, cycle );
+    if( DEBUG_MAPPER_HANDLE_MISS & 1 ) grdxt_display( XPTR(local_cxy,&mapper->rt), "FAT" );
+}
+#endif
+    // allocate one 4 Kbytes page from the remote mapper cluster
+    page_t * page_ptr = ppm_remote_alloc_pages( mapper_cxy , 0 );
+    if( page_ptr == NULL )
+    {
+        printk("\n[ERROR] in %s : thread [%x,%x] cannot allocate page in cluster %x\n",
+        __FUNCTION__ , this->process->pid, this->trdid , mapper_cxy );
+        return -1;
+    }
+    // build extended pointer on new page descriptor
+    xptr_t page_xp = XPTR( mapper_cxy , page_ptr );
+    // initialize the page descriptor
+    page_remote_init( page_xp );
+    hal_remote_s32( XPTR( mapper_cxy , &page_ptr->refcount ) , 1          );
+    hal_remote_s32( XPTR( mapper_cxy , &page_ptr->index )    , page_id    );
+    hal_remote_spt( XPTR( mapper_cxy , &page_ptr->mapper )   , mapper_ptr );
+    hal_remote_s32( XPTR( mapper_cxy , &page_ptr->flags )    , PG_INIT    );
+    // insert page in mapper radix tree
+    error = grdxt_remote_insert( XPTR( mapper_cxy , &mapper_ptr->rt),
+                                 page_id,
+                                 page_ptr );
+    if( error )
+    {
+        printk("\n[ERROR] in %s : thread[%x,%x] cannot insert page in mapper\n",
+        __FUNCTION__ , this->process->pid, this->trdid );
+        ppm_remote_free_pages( mapper_cxy , page_ptr );
+        return -1;
+    }
+    // launch I/O operation to load page from IOC device to mapper
+    error = vfs_fs_move_page( page_xp , IOC_SYNC_READ );
+    if( error )
+    {
+        printk("\n[ERROR] in %s : thread[%x,%x] cannot load page from device\n",
+        __FUNCTION__ , this->process->pid, this->trdid );
+        mapper_remote_release_page( mapper_xp , page_ptr );
+        return -1;
+    }
+    // return extended pointer on allocated page
+    *page_xp_ptr = page_xp;
+#if DEBUG_MAPPER_HANDLE_MISS
+cycle = (uint32_t)hal_get_cycles();
+if( (DEBUG_MAPPER_HANDLE_MISS < cycle) && (inode != NULL) )
+{
+    printk("\n[%s] thread[%x,%x] exit for page %d in <%s> / ppn %x / cycle %d",
+    __FUNCTION__, this->process->pid, this->trdid,
+    page_id, name, ppm_page2ppn( page_xp ), cycle );
+    if( DEBUG_MAPPER_HANDLE_MISS & 1 ) grdxt_display( XPTR(local_cxy,&mapper->rt) , name );
+}
+if( (DEBUG_MAPPER_HANDLE_MISS < cycle) && (inode == NULL) )
+{
+    printk("\n[%s] thread[%x,%x] exit for page %d in FAT / ppn %x / cycle %d",
+    __FUNCTION__, this->process->pid, this->trdid,
+    page_id, ppm_page2ppn( page_xp ), cycle );
+    if( DEBUG_MAPPER_HANDLE_MISS & 1 ) grdxt_display( XPTR(local_cxy,&mapper->rt ), "FAT" );
+}
+#endif
+    return 0;
+}  // end mapper_remote_handle_miss()
 ////////////////////////////////////////////////////
 …
     // test mapper miss
     if( page_xp == XPTR_NULL )                  // miss => try to handle it
+    if( page_xp == XPTR_NULL )                  // miss => handle it
+    {
         // release the lock in READ_MODE and take it in WRITE_MODE
 …
         if ( page_xp == XPTR_NULL )  // miss confirmed => handle it
+        {
+            if( mapper_cxy == local_cxy )   // mapper is local
+            {
+#if (DEBUG_MAPPER_GET_PAGE & 1)
+if( DEBUG_MAPPER_GET_PAGE < cycle )
+printk("\n[%s] missing page => load it from FS / local access \n", __FUNCTION__ );
+#endif
+                 error = mapper_handle_miss( mapper_ptr,
+                                             page_id,
+                                             &page_xp );
+            }
+            else
+            {
+#if (DEBUG_MAPPER_GET_PAGE & 1)
+if( DEBUG_MAPPER_GET_PAGE < cycle )
+printk("\n[%s] missing page => load it from FS / RPC access \n", __FUNCTION__ );
+#endif
+                 rpc_mapper_handle_miss_client( mapper_cxy,
+                                                mapper_ptr,
+                                                page_id,
+                                                &page_xp,
+                                                &error );
+            }
+            if ( error )
+            error = mapper_remote_handle_miss( mapper_xp,
+                                               page_id,
+                                               &page_xp );
+            if( error )
+            {
                 printk("\n[ERROR] in %s : thread[%x,%x] cannot handle mapper miss\n",
 …
+            }
+        }
+#if (DEBUG_MAPPER_GET_PAGE & 1)
+if( DEBUG_MAPPER_GET_PAGE < cycle )
+printk("\n[%s] thread[%x,%x] load missing page from FS : ppn %x\n",
+__FUNCTION__, this->process->pid, this->trdid, ppm_page2ppn(page_xp) );
+#endif
         // release mapper lock from WRITE_MODE
 …
 }  // end mapper_remote_get_page()
+//////////////////////////////////////////////
+error_t mapper_handle_miss( mapper_t * mapper,
+                            uint32_t   page_id,
+                            xptr_t   * page_xp )
+{
+    kmem_req_t   req;
+    page_t     * page;
+    error_t      error;
+    thread_t * this = CURRENT_THREAD;
+#if DEBUG_MAPPER_HANDLE_MISS
+uint32_t      cycle = (uint32_t)hal_get_cycles();
+char          name[CONFIG_VFS_MAX_NAME_LENGTH];
+vfs_inode_t * inode = mapper->inode;
+if( (DEBUG_MAPPER_HANDLE_MISS < cycle) && (inode != NULL) )
+{
+    vfs_inode_get_name( XPTR( local_cxy , inode ) , name );
+    printk("\n[%s] thread[%x,%x] enter for page %d in <%s> / cycle %d",
+    __FUNCTION__, this->process->pid, this->trdid, page_id, name, cycle );
+    if( DEBUG_MAPPER_HANDLE_MISS & 1 ) grdxt_display( XPTR(local_cxy,&mapper->rt), name );
+}
+if( (DEBUG_MAPPER_HANDLE_MISS < cycle) && (inode == NULL) )
+{
+    printk("\n[%s] thread[%x,%x] enter for page %d in FAT / cycle %d",
+    __FUNCTION__, this->process->pid, this->trdid, page_id, cycle );
+    if( DEBUG_MAPPER_HANDLE_MISS & 1 ) grdxt_display( XPTR(local_cxy,&mapper->rt), "FAT" );
+}
+#endif
+    // allocate one page from the local cluster
+    req.type  = KMEM_PAGE;
+    req.size  = 0;
+    req.flags = AF_NONE;
+    page = kmem_alloc( &req );
+    if( page == NULL )
+    {
+        printk("\n[ERROR] in %s : thread [%x,%x] cannot allocate page in cluster %x\n",
+        __FUNCTION__ , this->process->pid, this->trdid , local_cxy );
+        return -1;
+    }
+    // initialize the page descriptor
+    page_init( page );
+    page_set_flag( page , PG_INIT );
+    page_refcount_up( page );
+    page->mapper = mapper;
+    page->index  = page_id;
+    // insert page in mapper radix tree
+    error = grdxt_insert( &mapper->rt , page_id , page );
+    if( error )
+    {
+        printk("\n[ERROR] in %s : thread[%x,%x] cannot insert page in mapper\n",
+        __FUNCTION__ , this->process->pid, this->trdid );
+        mapper_release_page( mapper , page );
+        req.ptr  = page;
+        req.type = KMEM_PAGE;
+        kmem_free(&req);
+        return -1;
+    }
+    // launch I/O operation to load page from IOC device to mapper
+    error = vfs_fs_move_page( XPTR( local_cxy , page ) , IOC_SYNC_READ );
+    if( error )
+    {
+        printk("\n[ERROR] in %s : thread[%x,%x] cannot load page from device\n",
+        __FUNCTION__ , this->process->pid, this->trdid );
+        mapper_release_page( mapper , page );
+        req.ptr  = page;
+        req.type = KMEM_PAGE;
+        kmem_free( &req );
+        return -1;
+    }
+    // set extended pointer on allocated page
+    *page_xp = XPTR( local_cxy , page );
+#if DEBUG_MAPPER_HANDLE_MISS
+cycle = (uint32_t)hal_get_cycles();
+if( (DEBUG_MAPPER_HANDLE_MISS < cycle) && (inode != NULL) )
+{
+    printk("\n[%s] thread[%x,%x] exit for page %d in <%s> / ppn %x / cycle %d",
+    __FUNCTION__, this->process->pid, this->trdid,
+    page_id, name, ppm_page2ppn( *page_xp ), cycle );
+    if( DEBUG_MAPPER_HANDLE_MISS & 1 ) grdxt_display( XPTR(local_cxy,&mapper->rt) , name );
+}
+if( (DEBUG_MAPPER_HANDLE_MISS < cycle) && (inode == NULL) )
+{
+    printk("\n[%s] thread[%x,%x] exit for page %d in FAT / ppn %x / cycle %d",
+    __FUNCTION__, this->process->pid, this->trdid,
+    page_id, ppm_page2ppn( *page_xp ), cycle );
+    if( DEBUG_MAPPER_HANDLE_MISS & 1 ) grdxt_display( XPTR(local_cxy,&mapper->rt ), "FAT" );
+}
+#endif
+    return 0;
+}  // end mapper_handle_miss()
+////////////////////////////////////////////
+void mapper_release_page( mapper_t * mapper,
+                          page_t   * page )
+{
+////////////////////////////////////////////////////
+void mapper_remote_release_page( xptr_t   mapper_xp,
+                                 page_t * page )
+{
+    // get mapper cluster an local pointer
+    cxy_t      mapper_cxy = GET_CXY( mapper_xp );
+    mapper_t * mapper_ptr = GET_PTR( mapper_xp );
     // build extended pointer on mapper lock
     xptr_t mapper_lock_xp = XPTR( local_cxy , &mapper->lock );
+    xptr_t lock_xp = XPTR( mapper_cxy , &mapper_ptr->lock );
     // take mapper lock in WRITE_MODE
     remote_rwlock_wr_acquire( mapper_lock_xp );
+    remote_rwlock_wr_acquire( lock_xp );
     // remove physical page from radix tree
     grdxt_remove( &mapper->rt , page->index );
+    grdxt_remote_remove( XPTR( mapper_cxy , &mapper_ptr->rt ) , page->index );
     // release mapper lock from WRITE_MODE
     remote_rwlock_wr_release( mapper_lock_xp );
+    remote_rwlock_wr_release( lock_xp );
     // release page to PPM
+    kmem_req_t   req;
+    req.type  = KMEM_PAGE;
+    req.ptr   = page;
+    kmem_free( &req );
+    ppm_remote_free_pages( mapper_cxy , page );
 }  // end mapper_release_page()

trunk/kernel/mm/mapper.h

-                      r628
+                      r635
  * TODO (1) the mapper being only used to implement the VFS cache(s), the mapper.c
  *          and mapper.h file should be trandfered to the fs directory.
  * TODO (2) the "type" field is probably unused...
+ * TODO (2) the "type" field in mapper descriptor is redundant and probably unused.
  ******************************************************************************************/
 …
 /*******************************************************************************************
  * This function load from device a missing page identified by the <page_id> argument
  * into the mapper identified by the <mapper> local pointer.
  * It allocates a physical page from the local cluster, initialise by accessing device,
  * and register the page in the mapper radix tree.
  * It must be executed by a thread running in the cluster containing the mapper.
+ * This function load from the IOC device a missing page identified by the <page_id>
+ * argument into a - possibly remote - mapper identified by the <mapper_xp> argument.
+ * It can be executed by a thread running in any cluster.
+ * It allocates a physical page from the remote cluster PPM, initialises it by accessing
+ * the IOC device, and registers the page in the remote mapper radix tree.
  * WARNING : the calling function mapper_remote_get_page() is supposed to take and release
  * the lock protecting the mapper in WRITE_MODE.
  *******************************************************************************************
+ * @ mapper      : [in]  target mapper.
+ * @ page_id : [in]  missing page index in file.
+ * @ page_xp : [out] buffer for extended pointer on missing page descriptor.
+ * @ return 0 if success / return -1 if a dirty page cannot be updated on device.
+ ******************************************************************************************/
+error_t mapper_handle_miss( mapper_t * mapper,
+                            uint32_t   page_id,
+                            xptr_t   * page_xp );
+ * @ mapper_xp   : [in]  extended pointer on remote mapper.
+ * @ page_id     : [in]  missing page index in file.
+ * @ page_xp     : [out] buffer for extended pointer on missing page descriptor.
+ * @ return 0 if success / return -1 if IOC cannot be accessed.
+ ******************************************************************************************/
+error_t mapper_remote_handle_miss( xptr_t     mapper_xp,
+                                   uint32_t   page_id,
+                                   xptr_t   * page_xp );
+/*******************************************************************************************
+ * This function removes a physical page from a - possibly remote - mapper,
+ * and releases the page to the remote PPM.
+ * It can be executed by any thread running in any cluster.
+ * It takes the mapper lock in WRITE_MODE to update the mapper.
+ *******************************************************************************************
+ * @ mapper     : extended pointer on the remote mapper.
+ * @ page       : local pointer on the page in remote mapper.
+ ******************************************************************************************/
+void mapper_remote_release_page( xptr_t          mapper_xp,
+                                 struct page_s * page );
 /*******************************************************************************************
 …
 /*******************************************************************************************
- * This function removes a physical page from the mapper, and releases
- * the page to the local PPM. It is called by the mapper_destroy() function.
- * It must be executed by a thread running in the cluster containing the mapper.
- * It takes the mapper lock in WRITE_MODE to update the mapper.
- *******************************************************************************************
- * @ mapper     : local pointer on the mapper.
- * @ page       : pointer on page to remove.
- ******************************************************************************************/
-void mapper_release_page( mapper_t      * mapper,
-                          struct page_s * page );
-/*******************************************************************************************
  * This function returns an extended pointer on a page descriptor.
  * The - possibly remote - mapper is identified by the <mapper_xp> argument.
 …
 /*******************************************************************************************
  * This function scan all pages present in the mapper identified by the <mapper> argument,
  * and synchronize all pages maked as dirty" on disk.
+ * and synchronize all pages marked as "dirty" on disk.
  * These pages are unmarked and removed from the local PPM dirty_list.
  * This function must be called by a local thread running in same cluster as the mapper.

trunk/kernel/mm/page.c

-                      r634
+                      r635
         remote_busylock_init( XPTR( local_cxy , &page->lock ), LOCK_PAGE_STATE );
-        list_entry_init( &page->list );
+}
 …
+}
+///////////////////////////////////////////////
+inline void page_remote_init( xptr_t  page_xp )
+{
+        hal_remote_memset( page_xp , 0 , sizeof(page_t) );
+    cxy_t    page_cxy = GET_CXY( page_xp );
+    page_t * page_ptr = GET_PTR( page_xp );
+        remote_busylock_init( XPTR( page_cxy , &page_ptr->lock ), LOCK_PAGE_STATE );
+}
 ////////////////////////////////////////////////////

trunk/kernel/mm/page.h

-                      r632
+                      r635
  * This structure defines a physical page descriptor.
  * - The remote_busylock is used to allows any remote thread to atomically
  *   test/modify the forks counter or the page flags.
+ *   test/modify the forks counter or the flags.
  * - The list entry is used to register the page in a free list or in dirty list.
  *   The refcount is used for page release to KMEM.
 …
+/*************************************************************************************
+ * This function must be called by a thread running in the local cluster.
+ * It initializes the page descriptor.
+ *************************************************************************************
+ * @ page_xp    : extended pointer to page descriptor.
+ ************************************************************************************/
+inline void page_remote_init( xptr_t  page_xp );
 /*************************************************************************************
  * This function can be called by any thread running in any cluster.

trunk/kernel/mm/ppm.c

-                      r634
+                      r635
         page_t   * found_block;
+    thread_t * this = CURRENT_THREAD;
 #if DEBUG_PPM_ALLOC_PAGES
-thread_t * this = CURRENT_THREAD;
 uint32_t cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_PPM_ALLOC_PAGES < cycle )
 …
         current_block = NULL;
+        // find a free block equal or larger to requested size
+        for( current_order = order ; current_order < CONFIG_PPM_MAX_ORDER ; current_order ++ )
+        {
+                if( !list_is_empty( &ppm->free_pages_root[current_order] ) )
+    current_order = order;
+        // search a free block equal or larger than requested size
+        while( current_order < CONFIG_PPM_MAX_ORDER )
+        {
+        // get local pointer on the root of relevant free_list (same in all clusters)
+        list_entry_t * root = &ppm->free_pages_root[current_order];
+                if( !list_is_empty( root ) )
+                {
             // get first free block in this free_list
                         current_block = LIST_FIRST( &ppm->free_pages_root[current_order] , page_t , list );
+                        current_block = LIST_FIRST( root , page_t , list );
             // remove this block from this free_list
                         list_unlink( &current_block->list );
+                ppm->free_pages_nr[current_order] --;
             // register pointer on found block
             found_block = current_block;
-            // update this free-list number of blocks
-                ppm->free_pages_nr[current_order] --;
             // compute found block size
                 current_size = (1 << current_order);
 …
                         break;
+                }
+        // increment loop index
+        current_order++;
+        }
 …
                 remote_busylock_release( lock_xp );
+#if DEBUG_PPM_ALLOC_PAGES
+cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_PPM_ALLOC_PAGES < cycle )
+printk("\n[%s] thread[%x,%x] cannot allocate %d page(s) in cluster %x / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, 1<<order, local_cxy, cycle );
+#endif
+        printk("\n[%s] thread[%x,%x] cannot allocate %d page(s) in cluster %x\n",
+        __FUNCTION__, this->process->pid, this->trdid, 1<<order, local_cxy );
                 return NULL;
 …
         while( current_order > order )
+        {
+        // update size and order
                 current_order --;
-        // update pointer, size, and order fiels for new free block
                 current_size >>= 1;
+        // update order fiels in new free block
                 current_block = found_block + current_size;
                 current_block->order = current_order;
 …
         // insert new free block in relevant free_list
                 list_add_first( &ppm->free_pages_root[current_order] , &current_block->list );
-        // update number of blocks in free list
                 ppm->free_pages_nr[current_order] ++;
+        }
 …
 printk("\n[%s] thread[%x,%x] exit for %d page(s) in cluster %x / ppn = %x / cycle %d\n",
 __FUNCTION__, this->process->pid, this->trdid,
 <<order, ppm_page2ppn(XPTR( local_cxy , found_block )), local_cxy, cycle );
+<<order, local_cxy, ppm_page2ppn(XPTR( local_cxy , found_block )), cycle );
 #endif
 …
 /////////////////////////////////////////////
 xptr_t ppm_remote_alloc_pages( cxy_t     cxy,
+void * ppm_remote_alloc_pages( cxy_t     cxy,
                                uint32_t  order )
+{
 …
     page_t   * found_block;
+    thread_t * this  = CURRENT_THREAD;
 #if DEBUG_PPM_REMOTE_ALLOC_PAGES
-thread_t * this  = CURRENT_THREAD;
 uint32_t   cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_PPM_REMOTE_ALLOC_PAGES < cycle )
 …
     current_block = NULL;
+        // find in remote cluster a free block equal or larger to requested size
+        for( current_order = order ; current_order < CONFIG_PPM_MAX_ORDER ; current_order ++ )
+        {
+        // get local pointer on the root of relevant free_list in remote cluster
+    current_order = order;
+    // search a free block equal or larger than requested size
+    while( current_order < CONFIG_PPM_MAX_ORDER )
+    {
+        // get local pointer on the root of relevant free_list (same in all clusters)
         list_entry_t * root = &ppm->free_pages_root[current_order];
                 if( !list_remote_is_empty( cxy , root ) )
+                if( !list_remote_is_empty( cxy , root ) )  // list non empty => success
+                {
             // get local pointer on first free page descriptor in remote cluster
 …
             // remove first free page from the free-list in remote cluster
                         list_remote_unlink( cxy , &current_block->list );
+                hal_remote_atomic_add( XPTR( cxy , &ppm->free_pages_nr[current_order] ), -1 );
             // register found block
             found_block = current_block;
-                // decrement relevant free-list number of items in remote cluster
-                hal_remote_atomic_add( XPTR( cxy , &ppm->free_pages_nr[current_order] ), -1 );
             // compute found block size
                 current_size = (1 << current_order);
 …
                         break;
+                }
+        // increment loop index
+        current_order++;
+        }
 …
                 remote_busylock_release( lock_xp );
+#if DEBUG_REMOTE_PPM_ALLOC_PAGES
+cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_PPM_REMOTE_ALLOC_PAGES < cycle )
+printk("\n[%s] thread[%x,%x] cannot allocate %d page(s) in cluster %x / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, 1<<order, cxy, cycle );
+#endif
+        printk("\n[ERROR] in %s : thread[%x,%x] cannot allocate %d page(s) in cluster %x\n",
+        __FUNCTION__, this->process->pid, this->trdid, 1<<order, cxy );
                 return XPTR_NULL;
 …
         while( current_order > order )
+        {
         // update order, size, and local pointer for new free block
+        // update order and size
                 current_order --;
                 current_size >>= 1;
+        // update new free block order field in remote cluster
                 current_block = found_block + current_size;
-        // update new free block order field in remote cluster
                 hal_remote_s32( XPTR( cxy , &current_block->order ) , current_order );
 …
 #endif
         return XPTR( cxy , found_block );
+        return found_block;
 }  // end ppm_remote_alloc_pages()

trunk/kernel/mm/ppm.h

-                      r632
+                      r635
  * @ cxy       : remote cluster identifier.
  * @ order     : ln2( number of 4 Kbytes pages)
  * @ returns an extended pointer on the page descriptor if success / XPTR_NULL if error.
  ****************************************************************************************/
 xptr_t  ppm_remote_alloc_pages( cxy_t    cxy,
+ * @ returns a local pointer on remote page descriptor if success / XPTR_NULL if error.
+ ****************************************************************************************/
+void *  ppm_remote_alloc_pages( cxy_t    cxy,
                                 uint32_t order );

trunk/kernel/mm/vmm.c

-                      r634
+                      r635
 #include <hal_exception.h>
 //////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////////////////
 //   Extern global variables
 //////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////////////////
 extern  process_t  process_zero;      // allocated in cluster.c
 …
 }  // end vmm_detach_from_vsl()
 ////////////////////////////////////////////
 error_t vmm_user_init( process_t * process )
+{
-    vseg_t  * vseg_args;
-    vseg_t  * vseg_envs;
-    intptr_t  base;
-    intptr_t  size;
     uint32_t  i;
 …
 "STACK zone too small\n");
+    // initialize the lock protecting the VSL
+        remote_rwlock_init( XPTR( local_cxy , &vmm->vsl_lock ) , LOCK_VMM_VSL );
+/*
     // register "args" vseg in VSL
     base = CONFIG_VMM_UTILS_BASE << CONFIG_PPM_PAGE_SHIFT;
 …
     vmm->envs_vpn_base = base;
+*/
     // initialize STACK allocator
     vmm->stack_mgr.bitmap   = 0;
 …
     // initialize instrumentation counters
+        vmm->pgfault_nr = 0;
+        vmm->false_pgfault_nr    = 0;
+        vmm->local_pgfault_nr    = 0;
+        vmm->global_pgfault_nr   = 0;
+        vmm->false_pgfault_cost  = 0;
+        vmm->local_pgfault_cost  = 0;
+        vmm->global_pgfault_cost = 0;
     hal_fence();
 …
 #if DEBUG_VMM_USER_RESET
 uint32_t cycle = (uint32_t)hal_get_cycles();
+uint32_t   cycle;
 thread_t * this = CURRENT_THREAD;
+#endif
+#if (DEBUG_VMM_USER_RESET & 1 )
+cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_VMM_USER_RESET < cycle )
 printk("\n[%s] thread[%x,%x] enter for process %x in cluster %x / cycle %d\n",
 …
 #if (DEBUG_VMM_USER_RESET & 1 )
 if( DEBUG_VMM_USER_RESET < cycle )
 hal_vmm_display( process , true );
+hal_vmm_display( XPTR( local_cxy , process ) , true );
 #endif
 …
 #endif
+#if (DEBUG_VMM_USER_RESET & 1 )
+if( DEBUG_VMM_USER_RESET < cycle )
+hal_vmm_display( XPTR( local_cxy , process ) , true );
+#endif
 }  // end vmm_user_reset()
 …
 thread_t * this = CURRENT_THREAD;
 if( DEBUG_VMM_UPDATE_PTE < cycle )
+printk("\n[%s] thread[%x,%x] enter for process %x / vpn %x / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, process->pid , vpn , cycle );
+#endif
+// check cluster is reference
+assert( (GET_CXY( process->ref_xp ) == local_cxy) , "not called in reference cluster\n");
+printk("\n[%s] thread[%x,%x] enter for process %x / vpn %x / attr %x / ppn %x / ycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, process->pid, vpn, attr, ppn, cycle );
+#endif
     // get extended pointer on root of process copies xlist in owner cluster
 …
     process_root_xp  = XPTR( owner_cxy , process_root_ptr );
+// check local cluster is owner cluster
+assert( (owner_cxy == local_cxy) , "must be called in owner cluster\n");
     // loop on destination process copies
     XLIST_FOREACH( process_root_xp , process_iter_xp )
 …
         remote_process_cxy = GET_CXY( remote_process_xp );
 #if (DEBUG_VMM_UPDATE_PTE & 0x1)
+#if (DEBUG_VMM_UPDATE_PTE & 1)
 if( DEBUG_VMM_UPDATE_PTE < cycle )
 printk("\n[%s] threadr[%x,%x] handling vpn %x for process %x in cluster %x\n",
+printk("\n[%s] thread[%x,%x] handling vpn %x for process %x in cluster %x\n",
 __FUNCTION__, this->process->pid, this->trdid, vpn, process->pid, remote_process_cxy );
 #endif
 …
 #endif
+#if (DEBUG_VMM_UPDATE_PTE & 1)
+hal_vmm_display( process , true );
+#endif
 }  // end vmm_global_update_pte()
 …
     cxy_t           owner_cxy;
     lpid_t          owner_lpid;
+    // get target process PID
+    pid = process->pid;
 #if DEBUG_VMM_SET_COW
 …
 if( DEBUG_VMM_SET_COW < cycle )
 printk("\n[%s] thread[%x,%x] enter for process %x / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, process->pid , cycle );
+__FUNCTION__, this->process->pid, this->trdid, pid , cycle );
+#endif
+#if (DEBUG_VMM_SET_COW & 1)
+if( DEBUG_VMM_SET_COW < cycle )
+hal_vmm_display( process , true );
 #endif
 // check cluster is reference
 assert( (GET_CXY( process->ref_xp ) == local_cxy) ,
 "local cluster is not process reference cluster\n");
+assert( (XPTR( local_cxy , process ) == process->ref_xp),
+"local cluster must be process reference cluster\n");
     // get pointer on reference VMM
 …
     // get extended pointer on root of process copies xlist in owner cluster
-    pid              = process->pid;
     owner_cxy        = CXY_FROM_PID( pid );
     owner_lpid       = LPID_FROM_PID( pid );
 …
     vseg_root_xp  = XPTR( local_cxy , &vmm->vsegs_root );
     // loop on destination process copies
+    // loop on target process copies
     XLIST_FOREACH( process_root_xp , process_iter_xp )
+    {
         // get cluster and local pointer on remote process
+        // get cluster and local pointer on remote process copy
         remote_process_xp  = XLIST_ELEMENT( process_iter_xp , process_t , copies_list );
         remote_process_ptr = GET_PTR( remote_process_xp );
 …
 #if (DEBUG_VMM_SET_COW & 1)
 if( DEBUG_VMM_SET_COW < cycle )
 printk("\n[%s] thread[%x,%x] handling process %x in cluster %x\n",
 __FUNCTION__, this->process->pid, this->trdid, process->pid , remote_process_cxy );
+printk("\n[%s] thread[%x,%x] (%x) handles process %x in cluster %x\n",
+__FUNCTION__, this->process->pid, this->trdid, this, pid, remote_process_cxy );
 #endif
 …
             vseg     = GET_PTR( vseg_xp );
-assert( (GET_CXY( vseg_xp ) == local_cxy) ,
-"all vsegs in reference VSL must be local\n" );
             // get vseg type, base and size
             uint32_t type     = vseg->type;
 …
 #if (DEBUG_VMM_SET_COW & 1)
 if( DEBUG_VMM_SET_COW < cycle )
 printk("\n[%s] thread[%x,%x] handling vseg %s / vpn_base = %x / vpn_size = %x\n",
+printk("\n[%s] thread[%x,%x] found vseg %s / vpn_base = %x / vpn_size = %x\n",
 __FUNCTION__, this->process->pid, this->trdid, vseg_type_str(type), vpn_base, vpn_size );
 #endif
 …
                 // atomically increment pending forks counter in physical pages,
                 // for all vseg pages that are mapped in reference cluster
+                // this is only done once, when handling the reference copy
                 if( remote_process_cxy == local_cxy )
+                {
+#if (DEBUG_VMM_SET_COW & 1)
+if( DEBUG_VMM_SET_COW < cycle )
+printk("\n[%s] thread[%x,%x] handles vseg %s / vpn_base = %x / vpn_size = %x\n",
+__FUNCTION__, this->process->pid, this->trdid, vseg_type_str(type), vpn_base, vpn_size );
+#endif
                     // scan all pages in vseg
                     for( vpn = vpn_base ; vpn < (vpn_base + vpn_size) ; vpn++ )
 …
+                        }
                     }   // end loop on vpn
+#if (DEBUG_VMM_SET_COW & 1)
+if( DEBUG_VMM_SET_COW < cycle )
+printk("\n[%s] thread[%x,%x] completes vseg %s / vpn_base = %x / vpn_size = %x\n",
+__FUNCTION__, this->process->pid, this->trdid, vseg_type_str(type), vpn_base, vpn_size );
+#endif
                 }   // end if local
             }   // end if vseg type
 …
     vseg_t    * child_vseg;
     uint32_t    type;
-    bool_t      cow;
     vpn_t       vpn;
     vpn_t       vpn_base;
     vpn_t       vpn_size;
-    xptr_t      page_xp;        // extended pointer on page descriptor
-    page_t    * page_ptr;
-    cxy_t       page_cxy;
-    xptr_t      forks_xp;       // extended pointer on forks counter in page descriptor
     xptr_t      parent_root_xp;
     bool_t      mapped;
 …
     parent_vmm = &parent_process->vmm;
     child_vmm  = &child_process->vmm;
-    // initialize the lock protecting the child VSL
-        remote_rwlock_init( XPTR( local_cxy , &child_vmm->vsl_lock ) , LOCK_VMM_VSL );
-    // initialize the child VSL as empty
-    xlist_root_init( XPTR( local_cxy, &child_vmm->vsegs_root ) );
-    child_vmm->vsegs_nr = 0;
-    // create an empty child GPT
-    error = hal_gpt_create( &child_vmm->gpt );
-    if( error )
+    {
-        printk("\n[ERROR] in %s : cannot create GPT\n", __FUNCTION__ );
-        return -1;
+    }
     // build extended pointer on parent VSL root and lock
 …
+            {
                 // activate the COW for DATA, ANON, REMOTE vsegs only
                 cow = ( type != VSEG_TYPE_FILE );
+                // cow = ( type != VSEG_TYPE_FILE );
                 vpn_base = child_vseg->vpn_base;
 …
                                               XPTR( parent_cxy , &parent_vmm->gpt ),
                                               vpn,
                                               cow,
                                               &ppn,
                                               &mapped );
+                                              false,      // does not handle COW flag
+                                              &ppn,       // unused
+                                              &mapped );  // unused
                     if( error )
+                    {
 …
+                    }
-                    // increment pending forks counter in page if mapped
-                    if( mapped )
+                    {
-                        // get pointers and cluster on page descriptor
-                        page_xp  = ppm_ppn2page( ppn );
-                        page_cxy = GET_CXY( page_xp );
-                        page_ptr = GET_PTR( page_xp );
-                        // get extended pointers on "forks" and "lock"
-                        forks_xp = XPTR( page_cxy , &page_ptr->forks );
-                        lock_xp  = XPTR( page_cxy , &page_ptr->lock );
-                        // get lock protecting "forks" counter
-                        remote_busylock_acquire( lock_xp );
-                        // increment "forks"
-                        hal_remote_atomic_add( forks_xp , 1 );
-                        // release lock protecting "forks" counter
-                        remote_busylock_release( lock_xp );
 #if DEBUG_VMM_FORK_COPY
 cycle = (uint32_t)hal_get_cycles();
 …
 __FUNCTION__ , this->process->pid, this->trdid , vpn , cycle );
 #endif
+                    }
+                }
             }   // end if no code & no stack
 …
     // release the parent VSL lock in read mode
     remote_rwlock_rd_release( parent_lock_xp );
-    // update child VMM with kernel vsegs
-    error = hal_vmm_kernel_update( child_process );
-    if( error )
+    {
-        printk("\n[ERROR] in %s : cannot update child VMM\n", __FUNCTION__ );
-        return -1;
+    }
     // initialize the child VMM STACK allocator
 …
     // initialize instrumentation counters
+        child_vmm->pgfault_nr    = 0;
+        child_vmm->false_pgfault_nr    = 0;
+        child_vmm->local_pgfault_nr    = 0;
+        child_vmm->global_pgfault_nr   = 0;
+        child_vmm->false_pgfault_cost  = 0;
+        child_vmm->local_pgfault_cost  = 0;
+        child_vmm->global_pgfault_cost = 0;
     // copy base addresses from parent VMM to child VMM
 …
 #if DEBUG_VMM_DESTROY
 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;
 if( DEBUG_VMM_DESTROY < cycle )
 printk("\n[%s] thread[%x,%x] enter for process %x in cluster %x / cycle %d\n",
 …
 #if (DEBUG_VMM_DESTROY & 1 )
 if( DEBUG_VMM_DESTROY < cycle )
 hal_vmm_display( process , true );
+hal_vmm_display( XPTR( local_cxy, process ) , true );
 #endif
 …
 vseg_t * vmm_create_vseg( process_t   * process,
                               vseg_type_t   type,
                           intptr_t      base,
+                          intptr_t      base,         // ltid for VSEG_TYPE_STACK
                               uint32_t      size,
                           uint32_t      file_offset,
 …
         error_t      error;
 #if DEBUG_VMM_CREATE_VSEG
+#if (DEBUG_VMM_CREATE_VSEG & 1)
 thread_t * this  = CURRENT_THREAD;
 uint32_t   cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_VMM_CREATE_VSEG < cycle )
+printk("\n[%s] thread[%x,%x] enter for process %x / %s / cxy %x / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, process->pid, vseg_type_str(type), cxy, cycle );
+printk("\n[%s] thread[%x,%x] enter / process %x / %s / base %x / cxy %x / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid,
+process->pid, vseg_type_str(type), base, cxy, cycle );
 #endif
 …
+        }
 #if DEBUG_VMM_CREATE_VSEG
+#if (DEBUG_VMM_CREATE_VSEG & 1)
 if( DEBUG_VMM_CREATE_VSEG < cycle )
 printk("\n[%s] thread[%x,%x] : base %x / size %x / vpn_base %x / vpn_size %x\n",
 …
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_VMM_CREATE_VSEG < cycle )
+printk("\n[%s] thread[%x,%x] exit / %s / cxy %x / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, vseg_type_str(type), cxy, cycle );
+printk("\n[%s] thread[%x,%x] exit / process %x / %s / base %x / cxy %x / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid,
+process->pid, vseg_type_str(type), base, cxy, cycle );
 #endif
 …
     xptr_t       page_xp;
     cxy_t        page_cxy;
+    page_t     * page_ptr;
     uint32_t     index;
 …
+    }
+    // allocate a 4 Kbytes physical page from target cluster
+    page_xp = ppm_remote_alloc_pages( page_cxy , 0 );
+    // allocate one small physical page from target cluster
+    page_ptr = ppm_remote_alloc_pages( page_cxy , 0 );
+    page_xp = XPTR( page_cxy , page_ptr );
 #if DEBUG_VMM_PAGE_ALLOCATE
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_VMM_PAGE_ALLOCATE < cycle )
 printk("\n[%s] thread[%x,%x] exit for vpn %x / ppn %x / cluster %x / cycle %d\n",
 __FUNCTION__ , this->process->pid, this->trdid, vpn, ppm_page2ppn(page_xp), page_cxy, cycle );
+printk("\n[%s] thread[%x,%x] exit for vpn %x / ppn %x / cycle %d\n",
+__FUNCTION__ , this->process->pid, this->trdid, vpn, ppm_page2ppn(page_xp), cycle );
 #endif
 …
 uint32_t   cycle = (uint32_t)hal_get_cycles();
 thread_t * this  = CURRENT_THREAD;
+// if( DEBUG_VMM_GET_ONE_PPN < cycle )
+if( vpn == 0x40B )
+if( (DEBUG_VMM_GET_ONE_PPN < cycle) && (vpn == 0x40b) )
 printk("\n[%s] thread[%x,%x] enter for vpn %x / type %s / page_id  %d / cycle %d\n",
 __FUNCTION__, this->process->pid, this->trdid, vpn, vseg_type_str(type), page_id, cycle );
 …
         page_xp = vmm_page_allocate( vseg , vpn );
         if( page_xp == XPTR_NULL ) return ENOMEM;
+        if( page_xp == XPTR_NULL ) return -1;
         // initialise missing page from .elf file mapper for DATA and CODE types
 …
 #if (DEBUG_VMM_GET_ONE_PPN & 0x1)
+// if( DEBUG_VMM_GET_ONE_PPN < cycle )
+if( vpn == 0x40B )
+if( (DEBUG_VMM_GET_ONE_PPN < cycle) && (vpn == 0x40b) )
 printk("\n[%s] thread[%x,%x] for vpn = %x / elf_offset = %x\n",
 __FUNCTION__, this->process->pid, this->trdid, vpn, elf_offset );
 …
 #if (DEBUG_VMM_GET_ONE_PPN & 0x1)
+// if( DEBUG_VMM_GET_ONE_PPN < cycle )
+if( vpn == 0x40B )
+if( (DEBUG_VMM_GET_ONE_PPN < cycle) && (vpn == 0x40b) )
 printk("\n[%s] thread[%x,%x] for vpn  %x / fully in BSS\n",
 __FUNCTION__, this->process->pid, this->trdid, vpn );
 …
 #if (DEBUG_VMM_GET_ONE_PPN & 0x1)
+// if( DEBUG_VMM_GET_ONE_PPN < cycle )
+if( vpn == 0x40B )
+if( (DEBUG_VMM_GET_ONE_PPN < cycle) && (vpn == 0x40b) )
 printk("\n[%s] thread[%x,%x] for vpn  %x / fully in mapper\n",
 __FUNCTION__, this->process->pid, this->trdid, vpn );
 …
 #if (DEBUG_VMM_GET_ONE_PPN & 0x1)
+// if( DEBUG_VMM_GET_ONE_PPN < cycle )
+if( vpn == 0x40B )
+if( (DEBUG_VMM_GET_ONE_PPN < cycle) && (vpn == 0x40b) )
 printk("\n[%s] thread[%x,%x] for vpn  %x / both mapper & BSS\n"
 "      %d bytes from mapper / %d bytes from BSS\n",
 …
 #if DEBUG_VMM_GET_ONE_PPN
 cycle = (uint32_t)hal_get_cycles();
+// if( DEBUG_VMM_GET_ONE_PPN < cycle )
+if( vpn == 0x40B )
+printk("\n[%s] thread[%x,%x] exit for vpn %x / ppn %x / cycle\n",
+if( (DEBUG_VMM_GET_ONE_PPN < cycle) && (vpn == 0x40b) )
+printk("\n[%s] thread[%x,%x] exit for vpn %x / ppn %x / cycle %d\n",
 __FUNCTION__ , this->process->pid, this->trdid , vpn , *ppn, cycle );
 #endif
 …
 #if DEBUG_VMM_HANDLE_PAGE_FAULT
 if( (start_cycle > DEBUG_VMM_HANDLE_PAGE_FAULT) && (vpn == vpn) )
+if( (start_cycle > DEBUG_VMM_HANDLE_PAGE_FAULT) && (vpn > 0) )
 printk("\n[%s] thread[%x,%x] enter for vpn %x / cycle %d\n",
 __FUNCTION__, this->process->pid, this->trdid, vpn, start_cycle );
 …
 #if (DEBUG_VMM_HANDLE_PAGE_FAULT & 1)
 if( (start_cycle > DEBUG_VMM_HANDLE_PAGE_FAULT) && (vpn == vpn) )
 hal_vmm_display( this->process , false );
+if( (start_cycle > DEBUG_VMM_HANDLE_PAGE_FAULT) && (vpn > 0) )
+hal_vmm_display( this->process , true );
 #endif
 …
+    }
 #if DEBUG_VMM_HANDLE_PAGE_FAULT
 if( (start_cycle > DEBUG_VMM_HANDLE_PAGE_FAULT) && (vpn == vpn) )
+#if (DEBUG_VMM_HANDLE_PAGE_FAULT & 1)
+if( (start_cycle > DEBUG_VMM_HANDLE_PAGE_FAULT) && (vpn > 0) )
 printk("\n[%s] thread[%x,%x] found vseg %s\n",
 __FUNCTION__, this->process->pid, this->trdid, vseg_type_str(vseg->type) );
 …
+    }
 #if DEBUG_VMM_HANDLE_PAGE_FAULT
 if( (start_cycle > DEBUG_VMM_HANDLE_PAGE_FAULT) && (vpn == vpn) )
 printk("\n[%s] thread[%x,%x] locked vpn %x in cluster %x / cycle %d\n",
+#if (DEBUG_VMM_HANDLE_PAGE_FAULT & 1)
+if( (start_cycle > DEBUG_VMM_HANDLE_PAGE_FAULT) && (vpn > 0) )
+printk("\n[%s] thread[%x,%x] locked vpn %x in cluster %x\n",
 __FUNCTION__, this->process->pid, this->trdid, vpn, local_cxy );
 #endif
 …
+        {
+#if DEBUG_VMM_HANDLE_PAGE_FAULT
+if( (start_cycle > DEBUG_VMM_HANDLE_PAGE_FAULT) && (vpn == vpn) )
+printk("\n[%s] thread[%x,%x] access local gpt : cxy %x / ref_cxy %x / type %s\n",
+__FUNCTION__, this->process->pid, this->trdid, local_cxy, ref_cxy, vseg_type_str(vseg->type) );
+#if (DEBUG_VMM_HANDLE_PAGE_FAULT & 1)
+if( (start_cycle > DEBUG_VMM_HANDLE_PAGE_FAULT) && (vpn > 0) )
+printk("\n[%s] thread[%x,%x] access local gpt : cxy %x / ref_cxy %x / type %s / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid,
+local_cxy, ref_cxy, vseg_type_str(vseg->type), (uint32_t)hal_get_cycles() );
 #endif
             // allocate and initialise a physical page
 …
 #if DEBUG_VMM_HANDLE_PAGE_FAULT
 if( (end_cycle > DEBUG_VMM_HANDLE_PAGE_FAULT) && (vpn == vpn) )
+if( (end_cycle > DEBUG_VMM_HANDLE_PAGE_FAULT) && (vpn > 0) )
 printk("\n[%s] thread[%x,%x] handled local pgfault / ppn %x / attr %x / cycle %d\n",
 __FUNCTION__, this->process->pid, this->trdid, ppn, attr, end_cycle );
 …
+        {
+#if DEBUG_VMM_HANDLE_PAGE_FAULT
+if( (start_cycle > DEBUG_VMM_HANDLE_PAGE_FAULT) && (vpn == vpn) )
+printk("\n[%s] thread[%x,%x] access ref gpt : cxy %x / ref_cxy %x / type %s\n",
+__FUNCTION__, this->process->pid, this->trdid, local_cxy, ref_cxy, vseg_type_str(vseg->type) );
+#if (DEBUG_VMM_HANDLE_PAGE_FAULT & 1)
+if( (start_cycle > DEBUG_VMM_HANDLE_PAGE_FAULT) && (vpn > 0) )
+printk("\n[%s] thread[%x,%x] access ref gpt : cxy %x / ref_cxy %x / type %s / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid,
+local_cxy, ref_cxy, vseg_type_str(vseg->type), (uint32_t)hal_get_cycles() );
 #endif
             // build extended pointer on reference GPT
 …
+            }
 #if DEBUG_VMM_HANDLE_PAGE_FAULT
 if( (start_cycle > DEBUG_VMM_HANDLE_PAGE_FAULT) && (vpn == vpn) )
+#if (DEBUG_VMM_HANDLE_PAGE_FAULT & 1)
+if( (start_cycle > DEBUG_VMM_HANDLE_PAGE_FAULT) && (vpn > 0) )
 printk("\n[%s] thread[%x,%x] get pte from ref gpt / attr %x / ppn %x\n",
 __FUNCTION__, this->process->pid, this->trdid, ref_attr, ref_ppn );
 …
                                  ref_ppn );
 #if DEBUG_VMM_HANDLE_PAGE_FAULT
 if( (start_cycle > DEBUG_VMM_HANDLE_PAGE_FAULT) && (vpn == vpn) )
+#if (DEBUG_VMM_HANDLE_PAGE_FAULT & 1)
+if( (start_cycle > DEBUG_VMM_HANDLE_PAGE_FAULT) && (vpn > 0) )
 printk("\n[%s] thread[%x,%x] updated local gpt for a false pgfault\n",
 __FUNCTION__, this->process->pid, this->trdid );
 …
                 hal_gpt_unlock_pte( ref_gpt_xp, vpn );
 #if DEBUG_VMM_HANDLE_PAGE_FAULT
 if( (start_cycle > DEBUG_VMM_HANDLE_PAGE_FAULT) && (vpn == vpn) )
+#if (DEBUG_VMM_HANDLE_PAGE_FAULT &1)
+if( (start_cycle > DEBUG_VMM_HANDLE_PAGE_FAULT) && (vpn > 0) )
 printk("\n[%s] thread[%x,%x] unlock the ref gpt after a false pgfault\n",
 __FUNCTION__, this->process->pid, this->trdid );
 …
 #if DEBUG_VMM_HANDLE_PAGE_FAULT
 if( (end_cycle > DEBUG_VMM_HANDLE_PAGE_FAULT) && (vpn == vpn) )
+if( (end_cycle > DEBUG_VMM_HANDLE_PAGE_FAULT) && (vpn > 0) )
 printk("\n[%s] thread[%x,%x] handled false pgfault / ppn %x / attr %x / cycle %d\n",
 __FUNCTION__, this->process->pid, this->trdid, ref_ppn, ref_attr, end_cycle );
 …
                 if( vseg->flags & VSEG_CACHE ) attr |= GPT_CACHABLE;
 #if DEBUG_VMM_HANDLE_PAGE_FAULT
 if( (start_cycle > DEBUG_VMM_HANDLE_PAGE_FAULT) && (vpn == vpn) )
+#if (DEBUG_VMM_HANDLE_PAGE_FAULT & 1)
+if( (start_cycle > DEBUG_VMM_HANDLE_PAGE_FAULT) && (vpn > 0) )
 printk("\n[%s] thread[%x,%x] build a new PTE for a true pgfault\n",
 __FUNCTION__, this->process->pid, this->trdid );
 …
                                  ppn );
 #if DEBUG_VMM_HANDLE_PAGE_FAULT
 if( (start_cycle > DEBUG_VMM_HANDLE_PAGE_FAULT) && (vpn == vpn) )
+#if (DEBUG_VMM_HANDLE_PAGE_FAULT & 1)
+if( (start_cycle > DEBUG_VMM_HANDLE_PAGE_FAULT) && (vpn > 0) )
 printk("\n[%s] thread[%x,%x] set new PTE in ref gpt for a true page fault\n",
 __FUNCTION__, this->process->pid, this->trdid );
 …
 #if DEBUG_VMM_HANDLE_PAGE_FAULT
 if( (end_cycle > DEBUG_VMM_HANDLE_PAGE_FAULT) && (vpn == vpn) )
+if( (end_cycle > DEBUG_VMM_HANDLE_PAGE_FAULT) && (vpn > 0) )
 printk("\n[%s] thread[%x,%x] handled global pgfault / ppn %x / attr %x / cycle %d\n",
 __FUNCTION__, this->process->pid, this->trdid, ppn, attr, end_cycle );
 …
 #if DEBUG_VMM_HANDLE_PAGE_FAULT
 if( (end_cycle > DEBUG_VMM_HANDLE_PAGE_FAULT) && (vpn == vpn) )
+if( (end_cycle > DEBUG_VMM_HANDLE_PAGE_FAULT) && (vpn > 0) )
 printk("\n[%s] handled by another thread / vpn %x / ppn %x / attr %x / cycle %d\n",
 __FUNCTION__, vpn, ppn, attr, end_cycle );
 …
 #endif
 #if (DEBUG_VMM_HANDLE_PAGE_FAULT & 1)
+#if ((DEBUG_VMM_HANDLE_COW & 3) == 3 )
 hal_vmm_display( process , true );
 #endif
 …
 #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",
+printk("\n[%s] thread[%x,%x] no pending forks / keep existing PPN %x\n",
 __FUNCTION__, this->process->pid, this->trdid, old_ppn );
 #endif
 …
     // build new_attr : set WRITABLE, reset COW, reset LOCKED
     new_attr = (((old_attr | GPT_WRITABLE) & (~GPT_COW)) & (~GPT_LOCKED));
+#if(DEBUG_VMM_HANDLE_COW & 1)
+if( DEBUG_VMM_HANDLE_COW < cycle )
+printk("\n[%s] thread[%x,%x] new_attr %x / new_ppn %x\n",
+__FUNCTION__, this->process->pid, this->trdid, new_attr, new_ppn );
+#endif
     // update the relevant GPT(s)
 …
     if( (vseg->type == VSEG_TYPE_STACK) || (vseg->type == VSEG_TYPE_CODE) )
+    {
         // set the new PTE2
+        // set new PTE in local gpt
         hal_gpt_set_pte( gpt_xp,
                          vpn,
 …
 #endif
+#if ((DEBUG_VMM_HANDLE_COW & 3) == 3)
+hal_vmm_display( process , true );
+#endif
      return EXCP_NON_FATAL;

trunk/kernel/mm/vmm.h

-                      r632
+                      r635
  * - The allocator checks that the requested slot has not been already allocated, and set the
  *   corresponding bit in the bitmap.
  * - The de-allocator function reset the corresponding bit in the bitmap.
+ * - The de-allocator reset the corresponding bit in the bitmap.
  ********************************************************************************************/
 …
 typedef struct vmm_s
+{
+        remote_rwlock_t  vsl_lock;           /*! lock protecting the local VSL                  */
+        xlist_entry_t    vsegs_root;         /*! Virtual Segment List (complete in reference)   */
+        uint32_t         vsegs_nr;           /*! total number of local vsegs                    */
+    gpt_t            gpt;                /*! Generic Page Table (complete in reference)     */
+    stack_mgr_t      stack_mgr;          /*! embedded STACK vsegs allocator                 */
+    mmap_mgr_t       mmap_mgr;           /*! embedded MMAP vsegs allocator                  */
+        uint32_t         pgfault_nr;         /*! page fault counter (instrumentation)           */
+    vpn_t            args_vpn_base;      /*! args vseg first page                           */
+    vpn_t            envs_vpn_base;      /*! envs vseg first page                           */
+        vpn_t            code_vpn_base;      /*! code vseg first page                           */
+        vpn_t            data_vpn_base;      /*! data vseg first page                           */
+    vpn_t            heap_vpn_base;      /*! heap zone first page                           */
+        intptr_t         entry_point;        /*! main thread entry point                        */
+        remote_rwlock_t  vsl_lock;            /*! lock protecting the local VSL                 */
+        xlist_entry_t    vsegs_root;          /*! Virtual Segment List (complete in reference)  */
+        uint32_t         vsegs_nr;            /*! total number of local vsegs                   */
+    gpt_t            gpt;                 /*! Generic Page Table (complete in reference)    */
+    stack_mgr_t      stack_mgr;           /*! embedded STACK vsegs allocator                */
+    mmap_mgr_t       mmap_mgr;            /*! embedded MMAP vsegs allocator                 */
+        uint32_t         false_pgfault_nr;    /*! false page fault counter (for all threads)    */
+        uint32_t         local_pgfault_nr;    /*! false page fault counter (for all threads)    */
+        uint32_t         global_pgfault_nr;   /*! false page fault counter (for all threads)    */
+    uint32_t         false_pgfault_cost;  /*! cumulated cost (for all threads)              */
+    uint32_t         local_pgfault_cost;  /*! cumulated cost (for all threads)              */
+    uint32_t         global_pgfault_cost; /*! cumulated cost (for all threads)              */
+    vpn_t            args_vpn_base;       /*! args vseg first page                          */
+    vpn_t            envs_vpn_base;       /*! envs vseg first page                          */
+        vpn_t            code_vpn_base;       /*! code vseg first page                          */
+        vpn_t            data_vpn_base;       /*! data vseg first page                          */
+    vpn_t            heap_vpn_base;       /*! heap zone first page                          */
+        intptr_t         entry_point;         /*! main thread entry point                       */
+}
 vmm_t;
 /*********************************************************************************************
+ * This function mkkes a partial initialisation of the VMM attached to an user process.
+ * The GPT must have been previously created, with the hal_gpt_create() function.
+ * - It registers "args", "envs" vsegs in the VSL.
+ * - It initializes the STACK and MMAP allocators.
+ * Note:
+ * This function makes only a partial initialisation of the VMM attached to an user
+ * process: It intializes the STACK and MMAP allocators, and the VSL lock.
+ * - The GPT has been previously created, with the hal_gpt_create() function.
+ * - The "kernel" vsegs are previously registered, by the hal_vmm_kernel_update() function.
  * - The "code" and "data" vsegs are registered by the elf_load_process() function.
  * - The "stack" vsegs are dynamically registered by the thread_user_create() function.
 …
  * This function is called by the process_make_fork() function. It partially copies
  * the content of a remote parent process VMM to the local child process VMM:
+ * - The KERNEL vsegs required by the architecture must have been previously
+ *   created in the child VMM, using the hal_vmm_kernel_update() function.
  * - The DATA, ANON, REMOTE vsegs registered in the parent VSL are registered in the
+ *   child VSL. All valid PTEs in parent GPT are copied to the child GPT, but the
+ *   WRITABLE flag is reset and the COW flag is set.
+ *   child VSL. All valid PTEs in parent GPT are copied to the child GPT.
+ *   The WRITABLE  and COW flags are not modified, as it will be done later for those
+ *   shared pages by the vmm_set_cow() function.
  * - The CODE vsegs registered in the parent VSL are registered in the child VSL, but the
  *   GPT entries are not copied in the child GPT, and will be dynamically updated from
 …
  * - The FILE vsegs registered in the parent VSL are registered in the child VSL, and all
  *   valid GPT entries in parent GPT are copied to the child GPT. The COW flag is not set.
+ * - No STACK vseg is copied from  parent VMM to child VMM, because the child stack vseg
+ *   must be copied later from the cluster containing the user thread requesting the fork().
+ * - The KERNEL vsegs required by the target architecture are re-created in the child
+ *   VMM, from the local kernel process VMM, using the hal_vmm_kernel_update() function.
+ * - No STACK vseg is copied from  parent VMM to child VMM: the child stack vseg is copied
+ *   later from the cluster containing the user thread requesting the fork().
  *********************************************************************************************
  * @ child_process     : local pointer on local child process descriptor.
 …
  * This function modifies one GPT entry identified by the <process> and <vpn> arguments
  * in all clusters containing a process copy. It is used to maintain coherence in GPT
  * copies, using the list of copies stored in the owner process, and remote_write accesses.
+ * copies, using remote_write accesses.
  * It must be called by a thread running in the process owner cluster.
  * Use the RPC_VMM_GLOBAL_UPDATE_PTE if required.
 …
  * - For the FILE, ANON, & REMOTE types, it does not use the <base> and <size> arguments,
  *   but uses the specific MMAP virtual memory allocator.
  * - For the STACK type, it does not use the <size> argument, and the <base> argument
  *   defines the user thread LTID used by the specific STACK virtual memory allocator.
  * It checks collision with all pre-existing vsegs.
+ * - For the STACK type, it does not use the <base> and <size> arguments,  but uses the
+ *   and the <base> argument the specific STACK virtual memory allocator.
+ * It checks collision with pre-existing vsegs.
  * To comply with the "on-demand" paging policy, this function does NOT modify the GPT,
  * and does not allocate physical memory for vseg data.

trunk/kernel/mm/vseg.c

-                      r625
+                      r635
  * vseg.c - virtual segment (vseg) related operations
+ *
+ * Authors   Ghassan Almaless (2008,2009,2010,2011, 2012)
+ *           Mohamed Lamine Karaoui (2015)
+ *           Alain Greiner (2016,2017,2018,2019)
+ * Authors   Alain Greiner (2016,2017,2018,2019)
+ *
  * Copyright (c) UPMC Sorbonne Universites
 …
     kmem_req_t   req;
     req.type  = KMEM_VSEG;
         req.size  = sizeof(vseg_t);
         req.flags = AF_KERNEL;
     return (vseg_t *)kmem_alloc( &req );
+    req.type  = KMEM_KCM;
+        req.order = bits_log2( sizeof(vseg_t) );
+        req.flags = AF_KERNEL | AF_ZERO;
+    return kmem_alloc( &req );
+}
 …
     kmem_req_t  req;
         req.type = KMEM_VSEG;
+        req.type = KMEM_KCM;
         req.ptr  = vseg;
         kmem_free( &req );

Context Navigation

Legend:

trunk/kernel/mm/kcm.c

trunk/kernel/mm/kcm.h

trunk/kernel/mm/khm.h

trunk/kernel/mm/kmem.c

trunk/kernel/mm/kmem.h

trunk/kernel/mm/mapper.c

trunk/kernel/mm/mapper.h

trunk/kernel/mm/page.c

trunk/kernel/mm/page.h

trunk/kernel/mm/ppm.c

trunk/kernel/mm/ppm.h

trunk/kernel/mm/vmm.c

trunk/kernel/mm/vmm.h

trunk/kernel/mm/vseg.c

Download in other formats: