Changeset 632 for trunk/kernel/mm

Timestamp:

May 28, 2019, 2:56:04 PM (5 years ago)

Author:

alain

Message:

This version replace the RPC by direct remote memory access
for physical pages allacation/release.
It is commited before being tested.

Location:

trunk/kernel/mm

Files:

• page.c (modified) (1 diff)
• page.h (modified) (9 diffs)
• ppm.c (modified) (16 diffs)
• ppm.h (modified) (4 diffs)
• vmm.c (modified) (29 diffs)
• vmm.h (modified) (1 diff)

trunk/kernel/mm/page.c

@@ -93 +93 @@
 }
 
-////////////////////////////////
-void page_print( page_t * page )
+
+////////////////////////////////////////////////////
+inline void page_remote_set_flag( xptr_t    page_xp,
+                                  uint32_t  value )
 {
-        printk("*** Page %d : base = %x / flags = %x / order = %d / count = %d\n",
-                page->index,
-                GET_PTR( ppm_page2base( XPTR( local_cxy , page ) ) ),
-                page->flags,
-                page->order,
-                page->refcount );
+    cxy_t    page_cxy = GET_CXY( page_xp );
+    page_t * page_ptr = GET_PTR( page_xp );
+
+        hal_remote_atomic_or( XPTR( page_cxy , &page_ptr->flags ) , value );
 }
 
+//////////////////////////////////////////////////////
+inline void page_remote_clear_flag( xptr_t    page_xp,
+                                    uint32_t  value )
+{
+    cxy_t    page_cxy = GET_CXY( page_xp );
+    page_t * page_ptr = GET_PTR( page_xp );
+
+        hal_remote_atomic_and( XPTR( page_cxy , &page_ptr->flags ) , value );
+}
+
+/////////////////////////////////////////////////////
+inline bool_t page_remote_is_flag( xptr_t    page_xp,
+                                   uint32_t  value )
+{
+    cxy_t    page_cxy = GET_CXY( page_xp );
+    page_t * page_ptr = GET_PTR( page_xp );
+
+    uint32_t flags = hal_remote_l32( XPTR( page_cxy , &page_ptr->flags ) );
+    
+    return (flags & value) ? 1 : 0;
+}
+
+/////////////////////////////////////////////////////
+inline void page_remote_refcount_up( xptr_t page_xp )
+{
+    cxy_t    page_cxy = GET_CXY( page_xp );
+    page_t * page_ptr = GET_PTR( page_xp );
+
+    hal_remote_atomic_add( XPTR( page_cxy , &page_ptr->refcount ) , 1 );
+}
+
+///////////////////////////////////////////////////////
+inline void page_remote_refcount_down( xptr_t page_xp )
+{
+    cxy_t    page_cxy = GET_CXY( page_xp );
+    page_t * page_ptr = GET_PTR( page_xp );
+
+    hal_remote_atomic_add( XPTR( page_cxy , &page_ptr->refcount ) , -1 );
+}
+
+///////////////////////////////////////////
+void page_remote_display( xptr_t  page_xp )
+{
+    page_t  page;   // local copy of page decriptor
+
+    hal_remote_memcpy( XPTR( local_cxy , &page ) , page_xp , sizeof( page_t ) );
+                      
+        printk("*** Page %d in cluster %x : ppn %x / flags %x / order %d / refcount %d\n",
+                page.index,
+            GET_CXY( page_xp ),
+                ppm_page2ppn( page_xp ),
+                page.flags,
+                page.order,
+                page.refcount );
+}
+
+
+

trunk/kernel/mm/page.h

@@ -3 +3 @@
  *
  * Authors Ghassan Almalles (2008,2009,2010,2011,2012)
- *         Alain Greiner    (2016)
+ *         Alain Greiner    (2016,2017,2018,2019)
  *
  * Copyright (c) UPMC Sorbonne Universites
@@ -68 +68 @@
 
 /*************************************************************************************
- * This function initializes one page descriptor.
+ * This function must be called by a thread running in the local cluster.
+ * It initializes the page descriptor.
  *************************************************************************************
  * @ page    : pointer to page descriptor
@@ -75 +76 @@
 
 /*************************************************************************************
- * This function atomically set one or several flags in page descriptor flags.
+ * This function must be called by a thread running in the local cluster.
+ * It atomically set one or several flags in page descriptor flags.
  *************************************************************************************
  * @ page    : pointer to page descriptor.
@@ -84 +86 @@
 
 /*************************************************************************************
- * This function atomically reset one or several flags in page descriptor flags.
+ * This function must be called by a thread running in the local cluster.
+ * It atomically reset one or several flags in page descriptor flags.
  *************************************************************************************
  * @ page    : pointer to page descriptor.
@@ -93 +96 @@
 
 /*************************************************************************************
- * This function tests the value of one or several flags in page descriptor flags.
+ * This function must be called by a thread running in the local cluster.
+ * It tests the value of one or several flags in page descriptor flags.
  *************************************************************************************
  * @ page    : pointer to page descriptor.
@@ -103 +107 @@
 
 /*************************************************************************************
- * This function resets to 0 all bytes in a given page.
+ * This function must be called by a thread running in the local cluster.
+ * It resets to 0 all bytes in a given page.
  *************************************************************************************
  * @ page     : pointer on page descriptor.
@@ -110 +115 @@
 
 /*************************************************************************************
- * This blocking function atomically increments the page refcount.
+ * This function must be called by a thread running in the local cluster.
+ * It atomically increments the page refcount.
  *************************************************************************************
  * @ page     : pointer on page descriptor.
@@ -117 +123 @@
 
 /*************************************************************************************
- * This blocking function atomically decrements the page refcount.
+ * This function must be called by a thread running in the local cluster.
+ * It atomically decrements the page refcount.
  *************************************************************************************
  * @ page     : pointer on page descriptor.
@@ -123 +130 @@
 inline void page_refcount_down( page_t * page );
 
-/*************************************************************************************
- * This function display the values contained in a page descriptor.
- *************************************************************************************
- * @ page     : pointer on page descriptor.
- ************************************************************************************/
-void page_print( page_t * page );
 
 
+
+/*************************************************************************************
+ * This function can be called by any thread running in any cluster.
+ * It atomically set one or several flags in a remote page descriptor
+ * identified by the <page_xp> argument.
+ *************************************************************************************
+ * @ page_xp : extended pointer to page descriptor.
+ * @ value   : all non zero bits in value will be set.
+ ************************************************************************************/
+inline void page_remote_set_flag( xptr_t    page_xp,
+                                  uint32_t  value );
+
+/*************************************************************************************
+ * This function can be called by any thread running in any cluster.
+ * It atomically reset one or several flags in a remote page descriptor
+ * identified by the <page_xp> argument.
+ *************************************************************************************
+ * @ page_xp : extended pointer to page descriptor.
+ * @ value   : all non zero bits in value will be cleared.
+ ************************************************************************************/
+inline void page_remote_clear_flag( xptr_t    page_xp,
+                                    uint32_t  value );
+
+/*************************************************************************************
+ * This function can be called by any thread running in any cluster.
+ * It tests the value of one or several flags in a remote page descriptor
+ * identified by the <page_xp> argument.
+ *************************************************************************************
+ * @ page_xp : extended pointer to page descriptor.
+ * @ value   : all non zero bits will be tested.
+ * @ returns true if at least one non zero bit in value is set / false otherwise.
+ ************************************************************************************/
+inline bool_t page_remote_is_flag( xptr_t    page_xp,
+                                   uint32_t  value );
+
+/*************************************************************************************
+ * This function can be called by any thread running in any cluster.
+ * It atomically increments the refcount for the remote page identified by
+ * the <page_xp> argument.
+ *************************************************************************************
+ * @ page_xp   : extended pointer on page descriptor.
+ ************************************************************************************/
+inline void page_remote_refcount_up( xptr_t page_xp );
+
+/*************************************************************************************
+ * This function can be called by any thread running in any cluster.
+ * It atomically decrements the refcount for the remote page identified by
+ * the <page_xp> argument.
+ *************************************************************************************
+ * @ page_xp   : extended pointer on page descriptor.
+ ************************************************************************************/
+inline void page_remote_refcount_down( xptr_t  page_xp );
+
+/*************************************************************************************
+ * This debug function can be called by any thread running in any cluster.
+ * It displays the values contained in a page descriptor.
+ *************************************************************************************
+ * @ page_xp     : extended pointer on page descriptor.
+ ************************************************************************************/
+void page_remote_display( xptr_t  page_xp );
+
 #endif  /* _PAGE_H_ */

trunk/kernel/mm/ppm.c

@@ -3 +3 @@
  *
  * Authors  Ghassan Almaless (2008,2009,2010,2011,2012)
- *          Alain Greiner    (2016,2017,2018)
+ *          Alain Greiner    (2016,2017,2018,2019)
  *
  * Copyright (c) UPMC Sorbonne Universites
@@ -45 +45 @@
 ////////////////////////////////////////////////////////////////////////////////////////
 
-////////////////////////////////////////////////
-inline bool_t ppm_page_is_valid( page_t * page )
-{
-        ppm_t    * ppm  = &LOCAL_CLUSTER->ppm;
-        uint32_t   pgnr = (uint32_t)( page - ppm->pages_tbl );
-        return (pgnr <= ppm->pages_nr);
-}
 
 /////////////////////////////////////////////
@@ -151 +144 @@
 void ppm_free_pages_nolock( page_t * page )
 {
-        page_t   * buddy;            // searched buddy page descriptor
-        uint32_t   buddy_index;      // buddy page index
-        page_t   * current;          // current (merged) page descriptor
-        uint32_t   current_index;    // current (merged) page index
-        uint32_t   current_order;    // current (merged) page order
+        page_t   * buddy;            // searched buddy block page descriptor
+        uint32_t   buddy_index;      // buddy bloc index in page_tbl[]
+        page_t   * current;          // current (merged) block page descriptor
+        uint32_t   current_index;    // current (merged) block index in page_tbl[]
+        uint32_t   current_order;    // current (merged) block order
 
         ppm_t    * ppm         = &LOCAL_CLUSTER->ppm;
         page_t   * pages_tbl   = ppm->pages_tbl;
 
-        assert( !page_is_flag( page , PG_FREE ) ,
-    "page already released : ppn = %x\n" , ppm_page2ppn(XPTR(local_cxy,page)) );
-
-        assert( !page_is_flag( page , PG_RESERVED ) ,
-    "reserved page : ppn = %x\n" , ppm_page2ppn(XPTR(local_cxy,page)) );
+assert( !page_is_flag( page , PG_FREE ) ,
+"page already released : ppn = %x\n" , ppm_page2ppn(XPTR(local_cxy,page)) );
+
+assert( !page_is_flag( page , PG_RESERVED ) ,
+"reserved page : ppn = %x\n" , ppm_page2ppn(XPTR(local_cxy,page)) );
 
         // update released page descriptor flags
@@ -172 +165 @@
         // - merge with current page descriptor if found
         // - exit to release the current page descriptor if not found
-        current       = page ,
+        current       = page;
         current_index = (uint32_t)(page - ppm->pages_tbl);
         for( current_order = page->order ;
@@ -181 +174 @@
                 buddy       = pages_tbl + buddy_index;
 
-                if( !page_is_flag( buddy , PG_FREE ) || (buddy->order != current_order) ) break;
-
-                // remove buddy from free list
+        // exit this loop if buddy block not found
+                if( !page_is_flag( buddy , PG_FREE ) || 
+            (buddy->order != current_order) ) break;
+
+                // remove buddy block from free_list 
                 list_unlink( &buddy->list );
                 ppm->free_pages_nr[current_order] --;
 
-                // merge buddy with current
+        // reset order field in buddy block page descriptor
                 buddy->order = 0;
+
+                // compute merged block index in page_tbl[]
                 current_index &= buddy_index;
         }
 
-        // update merged page descriptor order
+        // update pointer and order field for merged block page descriptor 
         current        = pages_tbl + current_index;
         current->order = current_order;
 
-        // insert current in free list
+        // insert merged block in free list
         list_add_first( &ppm->free_pages_root[current_order] , &current->list );
         ppm->free_pages_nr[current_order] ++;
@@ -205 +202 @@
 page_t * ppm_alloc_pages( uint32_t   order )
 {
+        page_t   * current_block;
         uint32_t   current_order;
-        page_t   * remaining_block;
         uint32_t   current_size;
+        page_t   * found_block;  
 
 #if DEBUG_PPM_ALLOC_PAGES
@@ -213 +211 @@
 uint32_t cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_PPM_ALLOC_PAGES < cycle )
-printk("\n[%s] thread[%x,%x] enter for %d page(s) / cycle %d\n",
-__FUNCTION__, this->process->pid, this->trdid, 1<<order, cycle );
+printk("\n[%s] thread[%x,%x] enter for %d page(s) in cluster %x / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, 1<<order, cxy, cycle );
 #endif
 
 #if(DEBUG_PPM_ALLOC_PAGES & 0x1)
 if( DEBUG_PPM_ALLOC_PAGES < cycle )
-ppm_print("enter ppm_alloc_pages");
+ppm_remote_display( local_cxy );
 #endif
 
@@ -227 +225 @@
 assert( (order < CONFIG_PPM_MAX_ORDER) , "illegal order argument = %d\n" , order );
 
-        page_t * block = NULL;  
+    //build extended pointer on lock protecting remote PPM
+    xptr_t lock_xp = XPTR( local_cxy , &ppm->free_lock );
 
         // take lock protecting free lists
-        busylock_acquire( &ppm->free_lock );
+        remote_busylock_acquire( lock_xp );
+
+        current_block = NULL;
 
         // find a free block equal or larger to requested size
@@ -237 +238 @@
                 if( !list_is_empty( &ppm->free_pages_root[current_order] ) )
                 {
-                        block = LIST_FIRST( &ppm->free_pages_root[current_order] , page_t , list );
-                        list_unlink( &block->list );
-                        break;
+            // get first free block in this free_list
+                        current_block = LIST_FIRST( &ppm->free_pages_root[current_order] , page_t , list );
+
+            // remove this block from this free_list
+                        list_unlink( &current_block->list );
+
+            // 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;  
                 }
         }
 
-        if( block == NULL ) // return failure
+        if( current_block == NULL ) // return failure if no free block found
         {
                 // release lock protecting free lists
-                busylock_release( &ppm->free_lock );
+                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) / cycle %d\n",
-__FUNCTION__, this->process->pid, this->trdid, 1<<order, 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
 
@@ -258 +272 @@
         }
 
-        // update free-lists after removing a block
-        ppm->free_pages_nr[current_order] --;
-        current_size = (1 << current_order);
-
-        // split the removed block in smaller sub-blocks if required
+
+        // split the found block in smaller sub-blocks if required
         // and update the free-lists accordingly
         while( current_order > order )
         {
                 current_order --;
+
+        // update pointer, size, and order fiels for new free block
                 current_size >>= 1;
-
-                remaining_block = block + current_size;
-                remaining_block->order = current_order;
-
-                list_add_first( &ppm->free_pages_root[current_order] , &remaining_block->list );
+                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] ++;
         }
 
-        // update page descriptor
-        page_clear_flag( block , PG_FREE );
-        page_refcount_up( block );
-        block->order = order;
+        // update found block page descriptor
+        page_clear_flag( found_block , PG_FREE );
+        page_refcount_up( found_block );
+        found_block->order = order;
 
         // release lock protecting free lists
-        busylock_release( &ppm->free_lock );
+        remote_busylock_release( lock_xp );
 
     // update DQDT
-    dqdt_increment_pages( order );
+    dqdt_increment_pages( local_cxy , order );
 
 #if DEBUG_PPM_ALLOC_PAGES
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_PPM_ALLOC_PAGES < cycle )
-printk("\n[%s] thread[%x,%x] exit for %d page(s) / ppn = %x / cycle %d\n",
+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, 
-1<<order, ppm_page2ppn(XPTR( local_cxy , block )), cycle );
+1<<order, ppm_page2ppn(XPTR( local_cxy , found_block )), cxy, cycle );
 #endif
 
 #if(DEBUG_PPM_ALLOC_PAGES & 0x1)
 if( DEBUG_PPM_ALLOC_PAGES < cycle )
-ppm_print("exit ppm_alloc_pages");
-#endif
-
-        return block;
+ppm_remote_display( local_cxy );
+#endif
+
+        return found_block;
 
 }  // end ppm_alloc_pages()
@@ -311 +326 @@
 
 #if DEBUG_PPM_FREE_PAGES
-uint32_t cycle = (uint32_t)hal_get_cycles();
+thread_t * this  = CURRENT_THREAD;
+uint32_t   cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_PPM_FREE_PAGES < cycle )
-printk("\n[%s] thread[%x,%x] enter for %d page(s) / ppn %x / cycle %d\n",
+printk("\n[%s] thread[%x,%x] enter for %d page(s) in cluster %x / ppn %x / cycle %d\n",
 __FUNCTION__, this->process->pid, this->trdid, 
-1<<page->order, ppm_page2ppn(XPTR(local_cxy , page)), cycle );
+1<<page->order, local_cxy, ppm_page2ppn(XPTR(local_cxy , page)), cycle );
 #endif
 
 #if(DEBUG_PPM_FREE_PAGES & 0x1)
 if( DEBUG_PPM_FREE_PAGES < cycle )
-ppm_print("enter ppm_free_pages");
-#endif
+ppm_remote_display( local_cxy );
+#endif
+
+    //build extended pointer on lock protecting free_lists
+    xptr_t lock_xp = XPTR( local_cxy , &ppm->free_lock );
 
         // get lock protecting free_pages[] array
-        busylock_acquire( &ppm->free_lock );
+        remote_busylock_acquire( lock_xp );
 
         ppm_free_pages_nolock( page );
 
-        // release lock protecting free_pages[] array
-        busylock_release( &ppm->free_lock );
+        // release lock protecting free_lists
+        remote_busylock_release( lock_xp );
 
     // update DQDT
-    dqdt_decrement_pages( page->order );
+    dqdt_decrement_pages( local_cxy , page->order );
 
 #if DEBUG_PPM_FREE_PAGES
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_PPM_FREE_PAGES < cycle )
-printk("\n[%s] thread[%x,%x] exit for %d page(s) / ppn %x / cycle %d\n",
+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, 
-1<<page->order, ppm_page2ppn(XPTR(local_cxy , page)), cycle );
+1<<page->order, local_cxy, ppm_page2ppn(XPTR(local_cxy , page)) , cycle );
 #endif
 
 #if(DEBUG_PPM_FREE_PAGES & 0x1)
 if( DEBUG_PPM_FREE_PAGES < cycle )
-ppm_print("exit ppm_free_pages");
+ppm_remote_display( local_cxy );
 #endif
 
 }  // end ppm_free_pages()
 
-////////////////////////
-void ppm_display( void )
+/////////////////////////////////////////////
+xptr_t ppm_remote_alloc_pages( cxy_t     cxy,
+                               uint32_t  order )
+{
+        uint32_t   current_order;
+        uint32_t   current_size;
+    page_t   * current_block;   
+    page_t   * found_block;
+
+#if DEBUG_PPM_ALLOC_PAGES
+thread_t * this  = CURRENT_THREAD;
+uint32_t   cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_PPM_ALLOC_PAGES < cycle )
+printk("\n[%s] thread[%x,%x] enter for %d small page(s) in cluster %x / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, 1<<order, cxy, cycle );
+#endif
+
+#if(DEBUG_PPM_ALLOC_PAGES & 0x1)
+if( DEBUG_PPM_ALLOC_PAGES < cycle )
+ppm_remote_display( cxy );
+#endif
+
+// check order
+assert( (order < CONFIG_PPM_MAX_ORDER) , "illegal order argument = %d\n" , order );
+
+    // get local pointer on PPM (same in all clusters)
+        ppm_t * ppm = &LOCAL_CLUSTER->ppm;
+
+    //build extended pointer on lock protecting remote PPM
+    xptr_t lock_xp = XPTR( cxy , &ppm->free_lock );
+
+        // take lock protecting free lists in remote cluster
+        remote_busylock_acquire( lock_xp );
+
+    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
+        list_entry_t * root = &ppm->free_pages_root[current_order];
+
+                if( !list_remote_is_empty( cxy , root ) )
+                {
+            // get local pointer on first free page descriptor in remote cluster
+                        current_block = LIST_REMOTE_FIRST( cxy, root , page_t , list );
+
+            // remove first free page from the free-list in remote cluster
+                        list_remote_unlink( cxy , &current_block->list );
+
+            // 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;
+                }
+        }
+
+        if( current_block == NULL ) // return failure
+        {
+                // release lock protecting free lists
+                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, cxy, cycle );
+#endif
+
+                return XPTR_NULL;
+        }
+
+        // split the found block in smaller sub-blocks if required
+        // and update the free-lists accordingly in remote cluster
+        while( current_order > order )
+        {
+        // update order, size, and local pointer for new free block
+                current_order --;
+                current_size >>= 1;
+                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 );
+
+        // get local pointer on the root of the relevant free_list in remote cluster  
+        list_entry_t * root = &ppm->free_pages_root[current_order];
+
+        // insert new free block in this free_list
+                list_remote_add_first( cxy , root, &current_block->list );
+
+        // update free-list number of items in remote cluster
+        hal_remote_atomic_add( XPTR(cxy , &ppm->free_pages_nr[current_order]), 1 );
+        }
+
+        // update refcount, flags and order fields in found block remote page descriptor
+        page_remote_clear_flag( XPTR( cxy , found_block ), PG_FREE );
+        page_remote_refcount_up( XPTR( cxy , found_block ) );
+        hal_remote_s32( XPTR( cxy , &found_block->order ) , order );
+    
+        // release lock protecting free lists in remote cluster
+        remote_busylock_release( lock_xp );
+
+    // update DQDT page counter in remote cluster
+    dqdt_increment_pages( cxy , order );
+
+#if DEBUG_PPM_ALLOC_PAGES
+cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_PPM_ALLOC_PAGES < cycle )
+printk("\n[%s] thread[%x,%x] exit for %d page(s) / ppn = %x in cluster %x / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, 
+1<<order, ppm_page2ppn(XPTR( local_cxy , found_block )), cxy, cycle );
+#endif
+
+#if(DEBUG_PPM_ALLOC_PAGES & 0x1)
+if( DEBUG_PPM_ALLOC_PAGES < cycle )
+ppm_remote_display( cxy );
+#endif
+
+        return XPTR( cxy , found_block );
+
+}  // end ppm_remote_alloc_pages()
+
+//////////////////////////////////////////
+void ppm_remote_free_pages( cxy_t     cxy,
+                            page_t  * page )
+{
+    xptr_t     page_xp;          // extended pointer on released page descriptor
+    uint32_t   order;            // released block order
+        page_t   * buddy_ptr;        // searched buddy block page descriptor
+    uint32_t   buddy_order;      // searched buddy block order
+        uint32_t   buddy_index;      // buddy block index in page_tbl[]
+        page_t   * current_ptr;      // current (merged) block page descriptor
+        uint32_t   current_index;    // current (merged) block index in page_tbl[]
+        uint32_t   current_order;    // current (merged) block order
+
+#if DEBUG_PPM_FREE_PAGES
+thread_t * this  = CURRENT_THREAD;
+uint32_t   cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_PPM_FREE_PAGES < cycle )
+printk("\n[%s] thread[%x,%x] enter for %d page(s) in cluster %x / ppn %x / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, 
+1<<page->order, cxy, ppm_page2ppn(XPTR(cxy , page)), cycle );
+#endif
+
+#if(DEBUG_PPM_FREE_PAGES & 0x1)
+if( DEBUG_PPM_FREE_PAGES < cycle )
+ppm_remote_display( cxy );
+#endif
+
+    // build extended pointer on released page descriptor
+    page_xp = XPTR( cxy , page );
+    
+    // get released page order
+    order = hal_remote_l32( XPTR( cxy , &page->order ) );
+
+    // get local pointer on PPM (same in all clusters)
+        ppm_t * ppm = &LOCAL_CLUSTER->ppm;
+
+    // build extended pointer on lock protecting remote PPM
+    xptr_t lock_xp = XPTR( cxy , &ppm->free_lock );
+
+    // get local pointer on remote PPM page_tbl[] array 
+        page_t * pages_tbl = hal_remote_lpt( XPTR( cxy , &ppm->pages_tbl ) );
+
+        // get lock protecting free_pages in remote cluster
+        remote_busylock_acquire( lock_xp );
+
+assert( !page_remote_is_flag( page_xp , PG_FREE ) ,
+"page already released : ppn = %x\n" , ppm_page2ppn(XPTR(local_cxy,page)) );
+
+assert( !page_remote_is_flag( page_xp , PG_RESERVED ) ,
+"reserved page : ppn = %x\n" , ppm_page2ppn(XPTR(local_cxy,page)) );
+
+        // update released page descriptor flags
+        page_remote_set_flag( page_xp , PG_FREE );
+
+        // search the buddy page descriptor
+        // - merge with current page descriptor if found
+        // - exit to release the current page descriptor if not found
+        current_ptr   = page;
+        current_index = (uint32_t)(page - ppm->pages_tbl);
+        for( current_order = order ;
+             current_order < CONFIG_PPM_MAX_ORDER ;
+             current_order++ )
+        {
+                buddy_index = current_index ^ (1 << current_order);
+                buddy_ptr   = pages_tbl + buddy_index;
+
+        // get buddy block order
+        buddy_order = hal_remote_l32( XPTR( cxy , &buddy_ptr->order ) );
+
+        // exit loop if buddy block not found
+                if( !page_remote_is_flag( XPTR( cxy , buddy_ptr ) , PG_FREE ) || 
+            (buddy_order != current_order) ) break;
+
+                // remove buddy from free list in remote cluster
+                list_remote_unlink( cxy , &buddy_ptr->list );
+        hal_remote_atomic_add( XPTR( cxy , &ppm->free_pages_nr[current_order] ) , -1 );
+
+        // reset order field in buddy block page descriptor
+        hal_remote_s32( XPTR( cxy , &buddy_ptr->order ) , 0 );
+
+                // compute merged block index in page_tbl[] array 
+                current_index &= buddy_index;
+        }
+
+        // update merged page descriptor order field
+        current_ptr = pages_tbl + current_index;
+    hal_remote_s32( XPTR( cxy , &current_ptr->order ) , current_order );
+
+        // insert merged block into relevant free list in remote cluster
+        list_remote_add_first( cxy , &ppm->free_pages_root[current_order] , &current_ptr->list );
+    hal_remote_atomic_add( XPTR( cxy , &ppm->free_pages_nr[current_order] ) , 1 );
+
+        // release lock protecting free_pages[] array
+        remote_busylock_release( lock_xp );
+
+    // update DQDT
+    dqdt_decrement_pages( cxy , page->order );
+
+#if DEBUG_PPM_FREE_PAGES
+cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_PPM_FREE_PAGES < cycle )
+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, 
+1<<page->order, cxy, ppm_page2ppn(XPTR(cxy , page)), cycle );
+#endif
+
+#if(DEBUG_PPM_FREE_PAGES & 0x1)
+if( DEBUG_PPM_FREE_PAGES < cycle )
+ppm_remote_display( cxy );
+#endif
+
+}  // end ppm_remote_free_pages()
+
+////////////////////////////////////
+void ppm_remote_display( cxy_t cxy )
 {
         uint32_t       order;
@@ -358 +618 @@
     ppm_t * ppm = &LOCAL_CLUSTER->ppm;
 
-        // get lock protecting free lists
-        busylock_acquire( &ppm->free_lock );
+    // build extended pointer on lock protecting remote PPM
+    xptr_t lock_xp = XPTR( cxy , &ppm->free_lock );
+
+        // get lock protecting free lists in remote cluster
+        remote_busylock_acquire( lock_xp );
 
         printk("\n***** PPM in cluster %x / %d pages\n", local_cxy , ppm->pages_nr );
@@ -365 +628 @@
         for( order = 0 ; order < CONFIG_PPM_MAX_ORDER ; order++ )
         {
-                printk("- order = %d / free_pages = %d\t: ",
-                       order , ppm->free_pages_nr[order] );
-
-                LIST_FOREACH( &ppm->free_pages_root[order] , iter )
+        // get number of free pages for free_list[order] in remote cluster
+        uint32_t n = hal_remote_l32( XPTR( cxy , &ppm->free_pages_nr[order] ) );
+                printk("- order = %d / free_pages = %d\t: ", order , n );
+
+                LIST_REMOTE_FOREACH( cxy , &ppm->free_pages_root[order] , iter )
                 {
                         page = LIST_ELEMENT( iter , page_t , list );
@@ -377 +641 @@
         }
 
-        // release lock protecting free lists
-        busylock_release( &ppm->free_lock );
+        // release lock protecting free lists in remote cluster
+        remote_busylock_release( lock_xp );
 }
 
-///////////////////////////////////////
-error_t ppm_assert_order( ppm_t * ppm )
+////////////////////////////////
+error_t ppm_assert_order( void )
 {
         uint32_t       order;
         list_entry_t * iter;
         page_t       * page;
+
+    ppm_t * ppm = &LOCAL_CLUSTER->ppm;
 
         for( order=0 ; order < CONFIG_PPM_MAX_ORDER ; order++ )
@@ -438 +704 @@
         hal_remote_s32( page_flags_xp , flags | PG_DIRTY );
 
-                // The PPM dirty list is a LOCAL list !!!
-        // We must update 4 pointers to insert a new page in this list.
-        // We can use the standard LIST API when the page is local,
-        // but we cannot use the standard API if the page is remote...
-
-        if( page_cxy == local_cxy )         // locally update the PPM dirty list
-        {
-            list_add_first( &ppm->dirty_root , &page_ptr->list );
-        } 
-        else                                // remotely update the PPM dirty list
-        {
-            // get local and remote pointers on "root" list entry 
-            list_entry_t * root    = &ppm->dirty_root;
-            xptr_t         root_xp = XPTR( page_cxy , root );
-
-            // get local and remote pointers on "page" list entry 
-            list_entry_t * list    = &page_ptr->list;
-            xptr_t         list_xp = XPTR( page_cxy , list );
-
-            // get local and remote pointers on first dirty page 
-            list_entry_t * dirt    = hal_remote_lpt( XPTR( page_cxy, &root->next ) );
-            xptr_t         dirt_xp = XPTR( page_cxy , dirt );
-
-            // set root.next, list.next, list pred, curr.pred in remote cluster
-            hal_remote_spt( root_xp                    , list );
-            hal_remote_spt( list_xp                    , dirt );
-            hal_remote_spt( list_xp + sizeof(intptr_t) , root );
-            hal_remote_spt( dirt_xp + sizeof(intptr_t) , list );
-        }
+                // insert the page in the remote dirty list
+        list_remote_add_first( page_cxy , &ppm->dirty_root , &page_ptr->list );
 
                 done = true;
@@ -512 +751 @@
         hal_remote_s32( page_flags_xp , flags & (~PG_DIRTY) );
 
-                // The PPM dirty list is a LOCAL list !!!
-        // We must update 4 pointers to remove a page from this list.
-        // we can use the standard LIST API when the page is local,
-        // but we cannot use the standard API if the page is remote...
-
-        if( page_cxy == local_cxy )         // locally update the PPM dirty list
-        {
-            list_unlink( &page_ptr->list );
-        } 
-        else                                // remotely update the PPM dirty list
-        {
-            // get local and remote pointers on "page" list entry 
-            list_entry_t * list    = &page_ptr->list;
-            xptr_t         list_xp = XPTR( page_cxy , list );
-
-            // get local and remote pointers on "next" page list entry 
-            list_entry_t * next    = hal_remote_lpt( list_xp );
-            xptr_t         next_xp = XPTR( page_cxy , next );
-
-            // get local and remote pointers on "pred" page list entry 
-            list_entry_t * pred    = hal_remote_lpt( list_xp + sizeof(intptr_t) );
-            xptr_t         pred_xp = XPTR( page_cxy , pred );
-
-            // set root.next, list.next, list pred, curr.pred in remote cluster
-            hal_remote_spt( pred_xp                    , next );
-            hal_remote_spt( list_xp                    , NULL );
-            hal_remote_spt( list_xp + sizeof(intptr_t) , NULL );
-            hal_remote_spt( next_xp + sizeof(intptr_t) , pred );
-        }
+        // remove the page from remote dirty list
+        list_remote_unlink( page_cxy , &page_ptr->list );
 
                 done = true;

trunk/kernel/mm/ppm.h

@@ -51 +51 @@
  *
  * The main service provided by the PMM is the dynamic allocation of physical pages
- * from the "kernel_heap" section. This low-level allocator implements the buddy 
+ * from the "kernel_heap" section. This low-level allocator implements the "buddy" 
  * algorithm: an allocated block is an integer number n of small pages, where n 
- * is a power of 2, and ln(n) is called order.
- * This allocator being shared by the local threads, the free_page lists rooted 
- * in the PPM descriptor are protected by a local busylock, because it is used
- * by the idle_thread during kernel_init().
- *
- * Another service is to register the dirty pages in a specific dirty_list, that is
+ * is a power of 2, and ln(n) is called order. The free_pages_root[] array contains
+ * the roots ot the local lists of free pages for different sizes, as required by
+ * the "buddy" algorithm. 
+ * The local threads can access these free_lists by calling the ppm_alloc_pages() and
+ * ppm_free_page() functions, but the remote threads can access the same free lists,
+ * by calling the ppm_remote_alloc_pages() and ppm_remote_free_pages functions.
+ * Therefore, these free lists are protected by a remote_busy_lock.
+ * 
+ * Another service is to register the dirty pages in a specific local dirty_list,
  * also rooted in the PPM, in order to be able to synchronize all dirty pages on disk.
  * This dirty list is protected by a specific remote_queuelock, because it can be
- * modified by a remote thread, but it contains only local pages.
+ * modified by a remote thread.
  ****************************************************************************************/
 
 typedef struct ppm_s
 {
-        busylock_t          free_lock;          /*! lock protecting free_pages[] lists      */
+        remote_busylock_t   free_lock;          /*! lock protecting free_pages[] lists      */
         list_entry_t        free_pages_root[CONFIG_PPM_MAX_ORDER];  /*! roots of free lists */
         uint32_t            free_pages_nr[CONFIG_PPM_MAX_ORDER];    /*! free pages number   */
@@ -80 +83 @@
 
 /*****************************************************************************************
- * This is the low-level physical pages allocation function.
- * It allocates N contiguous physical pages. N is a power of 2.
- * In normal use, it should not be called directly, as the recommended way to get
- * physical pages is to call the generic allocator defined in kmem.h.
- *****************************************************************************************
- * @ order        : ln2( number of 4 Kbytes pages)
- * @ returns a pointer on the page descriptor if success / NULL otherwise
+ * This local allocator must be called by a thread running in local cluster. 
+ * It allocates n contiguous physical 4 Kbytes pages from the local cluster, where 
+ * n is a power of 2 defined by the <order> argument. 
+ * In normal use, it should not be called directly, as the recommended way to allocate
+ * physical pages is to call the generic allocator defined in kmem.h.
+ *****************************************************************************************
+ * @ order     : ln2( number of 4 Kbytes pages)
+ * @ returns a local pointer on the page descriptor if success / NULL if error.
  ****************************************************************************************/
 page_t * ppm_alloc_pages( uint32_t order );
 
 /*****************************************************************************************
- * This is the low-level physical pages release function. It takes the lock protecting
- * the free_list before register the released page in the relevant free_list.
+ * This function must be called by a thread running in local cluster to release
+ * physical pages. It takes the lock protecting the free_lists before register the 
+ * released page in the relevant free_list.
  * In normal use, you do not need to call it directly, as the recommended way to free
  * physical pages is to call the generic allocator defined in kmem.h.
  *****************************************************************************************
- * @ page         : pointer to the page descriptor to be released
+ * @ page   : local pointer on the page descriptor to be released
  ****************************************************************************************/
 void ppm_free_pages( page_t * page );
@@ -105 +110 @@
  * there is no concurrent access issue.
  *****************************************************************************************
- * @ page         : pointer to the page descriptor to be released
+ * @ page   : local pointer on the page descriptor to be released
  ****************************************************************************************/
 void ppm_free_pages_nolock( page_t * page );
 
 /*****************************************************************************************
- * This function check if a page descriptor pointer is valid.
- *****************************************************************************************
- * @ page         : pointer on a page descriptor
- * @ returns true if valid / false otherwise.
- ****************************************************************************************/
-inline bool_t ppm_page_is_valid( page_t * page );
+ * This remote  allocator can be called by any thread running in any cluster. 
+ * It allocates n contiguous physical 4 Kbytes pages from cluster identified 
+ * by the <cxy> argument, where n is a power of 2 defined by the <order> argument. 
+ * In normal use, it should not be called directly, as the recommended way to allocate
+ * physical pages is to call the generic allocator defined in kmem.h.
+ *****************************************************************************************
+ * @ 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,
+                                uint32_t order );
+
+/*****************************************************************************************
+ * This function can be called by any thread running in any cluster to release physical
+ * pages to a remote cluster. It takes the lock protecting the free_list before register
+ * the released page in the relevant free_list.
+ * In normal use, you do not need to call it directly, as the recommended way to free
+ * physical pages is to call the generic allocator defined in kmem.h.
+ *****************************************************************************************
+ * @ cxy       : remote cluster identifier.
+ * @ page      : local pointer on the page descriptor to be released in remote cluster.
+ ****************************************************************************************/
+void ppm_remote_free_pages( cxy_t    cxy,
+                            page_t * page );
+
+/*****************************************************************************************
+ * This debug function can be called by any thread running in any cluster to display
+ * the current PPM state of a remote cluster.
+ *****************************************************************************************
+ * @ cxy       : remote cluster identifier.
+ ****************************************************************************************/
+void ppm_remote_display( cxy_t cxy );
 
 
@@ -172 +204 @@
 
 /*****************************************************************************************
- * This function prints the PPM allocator status in the calling thread cluster.
- *****************************************************************************************
- * string   : character string printed in header
- ****************************************************************************************/
-void ppm_display( void );
-
-/*****************************************************************************************
- * This function checks PPM allocator consistency.
- *****************************************************************************************
- * @ ppm      : pointer on PPM allocator.
+ * This function can be called by any thread running in any cluster.
+ * It displays the PPM allocator status in cluster identified by the <cxy> argument.
+ *****************************************************************************************
+ * @ cxy   : remote cluster
+ ****************************************************************************************/
+void ppm_remote_display( cxy_t cxy );
+
+/*****************************************************************************************
+ * This function must be called by a thread running in local cluster.
+ * It checks the consistency of the local PPM allocator.
+ *****************************************************************************************
  * @ return 0 if PPM is OK / return -1 if PPM not consistent.
  ****************************************************************************************/
-error_t ppm_assert_order( ppm_t * ppm );
+error_t ppm_assert_order( void );
 
 

trunk/kernel/mm/vmm.c

@@ -1226 +1226 @@
     ppn_t       ppn;        // current PTE ppn value
     uint32_t    attr;       // current PTE attributes
-    kmem_req_t  req;        // request to release memory
     xptr_t      page_xp;    // extended pointer on page descriptor
     cxy_t       page_cxy;   // page descriptor cluster
@@ -1335 +1334 @@
 
             // release physical page to relevant kmem when required
-            if( ppn_release )
-            {
-                if( page_cxy == local_cxy )
-                {
-                    req.type = KMEM_PAGE;
-                    req.ptr  = page_ptr; 
-                    kmem_free( &req );
-                }
-                else
-                {
-                    rpc_pmem_release_pages_client( page_cxy , page_ptr );
-                }
-            }
+            if( ppn_release ) ppm_remote_free_pages( page_cxy , page_ptr );
 
 #if( DEBUG_VMM_REMOVE_VSEG & 1 )
@@ -1681 +1668 @@
 //////////////////////////////////////////////////////////////////////////////////////
 // This static function compute the target cluster to allocate a physical page
-// for a given <vpn> in a given <vseg>, allocates the page (with an RPC if required)
-// and returns an extended pointer on the allocated page descriptor.
-// It can be called by a thread running in any cluster.
+// for a given <vpn> in a given <vseg>, allocates the page and returns an extended 
+// pointer on the allocated page descriptor.
 // The vseg cannot have the FILE type.
 //////////////////////////////////////////////////////////////////////////////////////
@@ -1690 +1676 @@
 {
 
-#if DEBUG_VMM_ALLOCATE_PAGE
+#if DEBUG_VMM_PAGE_ALLOCATE
 uint32_t   cycle   = (uint32_t)hal_get_cycles();
 thread_t * this    = CURRENT_THREAD;
-if( DEBUG_VMM_ALLOCATE_PAGE < (uint32_t)hal_get_cycles() )
+if( DEBUG_VMM_PAGE_ALLOCATE < cycle )
 printk("\n[%s] thread[%x,%x] enter for vpn %x / cycle %d\n",
 __FUNCTION__ , this->process->pid, this->trdid, vpn, cycle );
 #endif
 
-    page_t     * page_ptr;
+    xptr_t       page_xp;
     cxy_t        page_cxy;
-    kmem_req_t   req;
     uint32_t     index;
 
@@ -1727 +1712 @@
     }
 
-    // allocate a physical page from target cluster
-    if( page_cxy == local_cxy )  // target cluster is the local cluster
-    {
-        req.type  = KMEM_PAGE;
-        req.size  = 0;
-        req.flags = AF_NONE;
-        page_ptr  = (page_t *)kmem_alloc( &req );
-    }
-    else                           // target cluster is not the local cluster
-    {
-        rpc_pmem_get_pages_client( page_cxy , 0 , &page_ptr );
-    }
-
-#if DEBUG_VMM_ALLOCATE_PAGE
+    // allocate a 4 Kbytes physical page from target cluster
+    page_xp = ppm_remote_alloc_pages( page_cxy , 0 );
+
+#if DEBUG_VMM_PAGE_ALLOCATE
 cycle = (uint32_t)hal_get_cycles();
-if( DEBUG_VMM_ALLOCATE_PAGE < (uint32_t)hal_get_cycles() )
-printk("\n[%s] thread[%x,%x] exit for vpn %x / ppn %x / cycle %d\n",
-__FUNCTION__ , this->process->pid, this->trdid, vpn,
-ppm_page2ppn( XPTR( page_cxy , page_ptr ) , cycle );
-#endif
-
-    if( page_ptr == NULL ) return XPTR_NULL;
-    else                   return XPTR( page_cxy , page_ptr );
+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 );
+#endif
+
+    return page_xp;
 
 }  // end vmm_page_allocate()  
@@ -1769 +1742 @@
 uint32_t   cycle = (uint32_t)hal_get_cycles();
 thread_t * this  = CURRENT_THREAD;
-if( DEBUG_VMM_GET_ONE_PPN < cycle )
+// if( DEBUG_VMM_GET_ONE_PPN < cycle )
+if( 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 );
@@ -1815 +1789 @@
 
 #if (DEBUG_VMM_GET_ONE_PPN & 0x1)
-if( DEBUG_VMM_GET_ONE_PPN < (uint32_t)hal_get_cycles() )
+// if( DEBUG_VMM_GET_ONE_PPN < cycle )
+if( vpn == 0x40B )
 printk("\n[%s] thread[%x,%x] for vpn = %x / elf_offset = %x\n",
 __FUNCTION__, this->process->pid, this->trdid, vpn, elf_offset );
@@ -1829 +1804 @@
 
 #if (DEBUG_VMM_GET_ONE_PPN & 0x1)
-if( DEBUG_VMM_GET_ONE_PPN < (uint32_t)hal_get_cycles() )
+// if( DEBUG_VMM_GET_ONE_PPN < cycle )
+if( vpn == 0x40B )
 printk("\n[%s] thread[%x,%x] for vpn  %x / fully in BSS\n",
 __FUNCTION__, this->process->pid, this->trdid, vpn );
@@ -1846 +1822 @@
 
 #if (DEBUG_VMM_GET_ONE_PPN & 0x1)
-if( DEBUG_VMM_GET_ONE_PPN < (uint32_t)hal_get_cycles() )
+// if( DEBUG_VMM_GET_ONE_PPN < cycle )
+if( vpn == 0x40B )
 printk("\n[%s] thread[%x,%x] for vpn  %x / fully in mapper\n",
 __FUNCTION__, this->process->pid, this->trdid, vpn );
@@ -1863 +1840 @@
 
 #if (DEBUG_VMM_GET_ONE_PPN & 0x1)
-if( DEBUG_VMM_GET_ONE_PPN < (uint32_t)hal_get_cycles() )
+// if( DEBUG_VMM_GET_ONE_PPN < cycle )
+if( vpn == 0x40B )
 printk("\n[%s] thread[%x,%x] for vpn  %x / both mapper & BSS\n"
 "      %d bytes from mapper / %d bytes from BSS\n",
@@ -1897 +1875 @@
 #if DEBUG_VMM_GET_ONE_PPN
 cycle = (uint32_t)hal_get_cycles();
-if( DEBUG_VMM_GET_ONE_PPN < cycle )
+// if( DEBUG_VMM_GET_ONE_PPN < cycle )
+if( vpn == 0x40B )
 printk("\n[%s] thread[%x,%x] exit for vpn %x / ppn %x / cycle\n",
 __FUNCTION__ , this->process->pid, this->trdid , vpn , *ppn, cycle );
@@ -1928 +1907 @@
 
 #if DEBUG_VMM_HANDLE_PAGE_FAULT
-if( DEBUG_VMM_HANDLE_PAGE_FAULT < start_cycle )
+if( vpn == 0x40b )
 printk("\n[%s] thread[%x,%x] enter for vpn %x / cycle %d\n",
 __FUNCTION__, this->process->pid, this->trdid, vpn, start_cycle );
@@ -1950 +1929 @@
 
 #if DEBUG_VMM_HANDLE_PAGE_FAULT
-if( DEBUG_VMM_HANDLE_PAGE_FAULT < start_cycle )
-printk("\n[%s] thread[%x,%x] found vseg %s\n",
-__FUNCTION__, this->process->pid, this->trdid, vseg_type_str(vseg->type) );
+uint32_t cycle = (uint32_t)hal_get_cycles();
+if( vpn == 0x40b )
+printk("\n[%s] thread[%x,%x] found vseg %s / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, vseg_type_str(vseg->type), cycle );
 #endif
 
@@ -1958 +1938 @@
     local_gpt_xp  = XPTR( local_cxy , &process->vmm.gpt );
 
-    // lock target PTE in local GPT and get current PPN and attributes
+    // lock PTE in local GPT and get current PPN and attributes
     error = hal_gpt_lock_pte( local_gpt_xp,
                               vpn,
@@ -1971 +1951 @@
     }
 
-    // handle page fault only if PTE still unmapped after lock
+#if DEBUG_VMM_HANDLE_PAGE_FAULT
+cycle = (uint32_t)hal_get_cycles();
+if( vpn == 0x40b )
+printk("\n[%s] thread[%x,%x] locked vpn %x in cluster %x / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, vpn, local_cxy, cycle );
+#endif
+
+    // handle page fault only if local PTE still unmapped after lock
     if( (attr & GPT_MAPPED) == 0 )
     {
@@ -1984 +1971 @@
             (ref_cxy    == local_cxy ) )
         {
-            // allocate and initialise a physical page depending on the vseg type
+
+#if DEBUG_VMM_HANDLE_PAGE_FAULT
+if( vpn == 0x40b )
+printk("\n[%s] thread[%x,%x] : access local gpt : local_cxy %x / ref_cxy %x / type %s\n",
+__FUNCTION__, this->process->pid, this->trdid, local_cxy, ref_cxy, vseg_type_str(vseg->type) );
+#endif
+            // allocate and initialise a physical page 
             error = vmm_get_one_ppn( vseg , vpn , &ppn );
 
@@ -1999 +1992 @@
 
             // define attr from vseg flags 
-            attr = GPT_MAPPED | GPT_SMALL;
+            attr = GPT_MAPPED | GPT_SMALL | GPT_READABLE;
             if( vseg->flags & VSEG_USER  ) attr |= GPT_USER;
             if( vseg->flags & VSEG_WRITE ) attr |= GPT_WRITABLE;
@@ -2006 +1999 @@
 
             // set PTE to local GPT 
+            // it unlocks this PTE
             hal_gpt_set_pte( local_gpt_xp,
                              vpn,
@@ -2016 +2010 @@
 
 #if DEBUG_VMM_HANDLE_PAGE_FAULT
-if( DEBUG_VMM_HANDLE_PAGE_FAULT < end_cycle )
-printk("\n[%s] local page fault handled / vpn %x / ppn %x / attr %x / cycle %d\n",
-__FUNCTION__, vpn, ppn, attr, end_cycle );
+if( vpn == 0x40b )
+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 );
 #endif
 
@@ -2033 +2027 @@
         else                                
         {
+
+#if DEBUG_VMM_HANDLE_PAGE_FAULT
+if( vpn == 0x40b )
+printk("\n[%s] thread[%x,%x] access ref gpt : local_cxy %x / ref_cxy %x / type %s\n",
+__FUNCTION__, this->process->pid, this->trdid, local_cxy, ref_cxy, vseg_type_str(vseg->type) );
+#endif
             // build extended pointer on reference GPT
             ref_gpt_xp = XPTR( ref_cxy , &ref_ptr->vmm.gpt );
 
-            // get current PPN and attributes from reference GPT
-            // without locking the PTE (in case of false page fault)
-            hal_gpt_get_pte( ref_gpt_xp,
-                             vpn,
-                             &ref_attr,
-                             &ref_ppn );
-
-            if( ref_attr & GPT_MAPPED )        // false page fault => update local GPT
+            // lock PTE in reference GPT and get current PPN and attributes
+            error = hal_gpt_lock_pte( ref_gpt_xp,
+                                      vpn,
+                                      &ref_attr,
+                                      &ref_ppn );
+            if( error )
+            {
+                printk("\n[PANIC] in %s : cannot lock PTE in ref GPT / vpn %x / process %x\n",
+                __FUNCTION__ , vpn , process->pid );
+        
+                // unlock PTE in local GPT
+                hal_gpt_unlock_pte( local_gpt_xp , vpn );
+                    
+                return EXCP_KERNEL_PANIC;
+            }
+
+#if DEBUG_VMM_HANDLE_PAGE_FAULT
+if( vpn == 0x40b )
+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 );
+#endif
+
+            if( ref_attr & GPT_MAPPED )        // false page fault 
             {
                 // update local GPT from reference GPT values
+                // this unlocks the PTE in local GPT
                 hal_gpt_set_pte( local_gpt_xp,
                                  vpn,
@@ -2051 +2067 @@
                                  ref_ppn );
 
+#if DEBUG_VMM_HANDLE_PAGE_FAULT
+if( vpn == 0x40b )
+printk("\n[%s] thread[%x,%x] updated local gpt for a false pgfault\n",
+__FUNCTION__, this->process->pid, this->trdid );
+#endif
+
+                // unlock the PTE in reference GPT
+                hal_gpt_unlock_pte( ref_gpt_xp, vpn );
+                             
+#if DEBUG_VMM_HANDLE_PAGE_FAULT
+if( vpn == 0x40b )
+printk("\n[%s] thread[%x,%x] unlock the ref gpt after a false pgfault\n",
+__FUNCTION__, this->process->pid, this->trdid );
+#endif
+
 #if (CONFIG_INSTRUMENTATION_PGFAULTS || DEBUG_VMM_HANDLE_PAGE_FAULT)
 uint32_t end_cycle = (uint32_t)hal_get_cycles();
@@ -2056 +2087 @@
 
 #if DEBUG_VMM_HANDLE_PAGE_FAULT
-if( DEBUG_VMM_HANDLE_PAGE_FAULT < end_cycle )
-printk("\n[%s] false page fault handled / vpn %x / ppn %x / attr %x / cycle %d\n",
-__FUNCTION__, vpn, ref_ppn, ref_attr, end_cycle );
+if( vpn == 0x40b )
+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 );
 #endif
 
@@ -2067 +2098 @@
                 return EXCP_NON_FATAL;
             }
-            else                            // true page fault => update both GPTs
+            else                            // true page fault 
             {
                 // allocate and initialise a physical page depending on the vseg type
@@ -2077 +2108 @@
                     __FUNCTION__ , process->pid , vpn );
 
-                    // unlock PTE in local GPT
+                    // unlock PTE in local GPT and in reference GPT
                     hal_gpt_unlock_pte( local_gpt_xp , vpn );
+                    hal_gpt_unlock_pte( ref_gpt_xp   , vpn );
                     
                     return EXCP_KERNEL_PANIC;
                 }
 
-                // lock PTE in reference GPT
-                error = hal_gpt_lock_pte( ref_gpt_xp,
-                                          vpn,
-                                          &ref_attr,
-                                          &ref_ppn );
-                if( error )
-                {
-                    printk("\n[PANIC] in %s : cannot lock PTE in ref GPT / vpn %x / process %x\n",
-                    __FUNCTION__ , vpn , process->pid );
-        
-                    // unlock PTE in local GPT
-                    hal_gpt_unlock_pte( local_gpt_xp , vpn );
-                    
-                    return EXCP_KERNEL_PANIC;
-                }
-
                 // define attr from vseg flags 
-                attr = GPT_MAPPED | GPT_SMALL;
+                attr = GPT_MAPPED | GPT_SMALL | GPT_READABLE;
                 if( vseg->flags & VSEG_USER  ) attr |= GPT_USER;
                 if( vseg->flags & VSEG_WRITE ) attr |= GPT_WRITABLE;
@@ -2106 +2122 @@
                 if( vseg->flags & VSEG_CACHE ) attr |= GPT_CACHABLE;
 
+#if DEBUG_VMM_HANDLE_PAGE_FAULT
+if( vpn == 0x40b )
+printk("\n[%s] thread[%x,%x] build a new PTE for a true pgfault\n",
+__FUNCTION__, this->process->pid, this->trdid );
+#endif
                 // set PTE in reference GPT
+                // this unlock the PTE 
                 hal_gpt_set_pte( ref_gpt_xp,
                                  vpn,
@@ -2112 +2134 @@
                                  ppn );
 
+#if DEBUG_VMM_HANDLE_PAGE_FAULT
+if( vpn == 0x40b )
+printk("\n[%s] thread[%x,%x] set new PTE in ref gpt for a true page fault\n",
+__FUNCTION__, this->process->pid, this->trdid );
+#endif
+
                 // set PTE in local GPT 
+                // this unlock the PTE 
                 hal_gpt_set_pte( local_gpt_xp,
                                  vpn,
@@ -2123 +2152 @@
 
 #if DEBUG_VMM_HANDLE_PAGE_FAULT
-if( DEBUG_VMM_HANDLE_PAGE_FAULT < end_cycle )
-printk("\n[%s] global page fault handled / vpn %x / ppn %x / attr %x / cycle %d\n",
-__FUNCTION__, vpn, ppn, attr, end_cycle );
+if( vpn == 0x40b )
+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 );
 #endif
 
@@ -2138 +2167 @@
     else   // page has been locally mapped by another concurrent thread
     {
-        // unlock PTE in local GPT
+        // unlock the PTE in local GPT
         hal_gpt_unlock_pte( local_gpt_xp , vpn );
 
+#if (CONFIG_INSTRUMENTATION_PGFAULTS || DEBUG_VMM_HANDLE_PAGE_FAULT)
+uint32_t end_cycle = (uint32_t)hal_get_cycles();
+#endif
+
+#if DEBUG_VMM_HANDLE_PAGE_FAULT
+if( vpn == 0x40b )
+printk("\n[%s] handled by another thread / vpn %x / ppn %x / attr %x / cycle %d\n",
+__FUNCTION__, vpn, ppn, attr, end_cycle );
+#endif
+
+#if CONFIG_INSTRUMENTATION_PGFAULTS 
+this->info.false_pgfault_nr++;
+this->info.false_pgfault_cost += (end_cycle - start_cycle);
+#endif
         return EXCP_NON_FATAL;
     }
@@ -2214 +2257 @@
 
     // lock target PTE in relevant GPT (local or reference) 
+    // and get current PTE value
     error = hal_gpt_lock_pte( gpt_xp,
                               vpn,

trunk/kernel/mm/vmm.h

@@ -202 +202 @@
 /*********************************************************************************************
  * This function modifies one GPT entry identified by the <process> and <vpn> arguments
- * in all clusters containing a process copy.
+ * 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.
  * It must be called by a thread running in the process owner cluster.
- * It is used to update to maintain coherence in GPT copies, using the list of copies 
- * stored in the owner process, and uses remote_write accesses.
+ * Use the RPC_VMM_GLOBAL_UPDATE_PTE if required.
  * It cannot fail, as only mapped PTE2 in GPT copies are updated.
  *********************************************************************************************