Changeset 433 for trunk/kernel/mm

Timestamp:

Feb 14, 2018, 3:40:19 PM (7 years ago)

Author:

alain

Message:

blip

Location:

trunk/kernel/mm

Files:

• kcm.c (modified) (4 diffs)
• kmem.c (modified) (2 diffs)
• page.c (modified) (1 diff)
• page.h (modified) (2 diffs)
• ppm.c (modified) (9 diffs)
• ppm.h (modified) (2 diffs)
• vmm.c (modified) (47 diffs)
• vmm.h (modified) (10 diffs)

trunk/kernel/mm/kcm.c

@@ -47 +47 @@
                              kcm_page_t * kcm_page )
 {
-        kcm_dmsg("\n[DBG] %s : enters for %s / page %x / count = %d / active = %d\n",
-                 __FUNCTION__ , kmem_type_str( kcm->type ) ,
-                 (intptr_t)kcm_page , kcm_page->count , kcm_page->active );
+
+#if CONFIG_DEBUG_KCM_ALLOC
+uint32_t cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_KCM_ALLOC < cycle )
+printk("\n[DBG] %s : thread %x enters for %s / page %x / count %d / active %d\n",
+__FUNCTION__ , CURRENT_THREAD , kmem_type_str( kcm->type ) ,
+(intptr_t)kcm_page , kcm_page->count , kcm_page->active );
+#endif
 
         assert( kcm_page->active , __FUNCTION__ , "kcm_page should be active" );
@@ -80 +85 @@
                      + (index * kcm->block_size) );
 
-        kcm_dmsg("\n[DBG] %s : allocated one block  %s / ptr = %p / page = %x / count = %d\n",
-                 __FUNCTION__ , kmem_type_str( kcm->type ) , ptr ,
-                 (intptr_t)kcm_page , kcm_page->count );
+#if CONFIG_DEBUG_KCM_ALLOC
+cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_KCM_ALLOC < cycle )
+printk("\n[DBG] %s : thread %x exit / type  %s / ptr %p / page %x / count %d\n",
+__FUNCTION__ , CURRENT_THREAD , kmem_type_str( kcm->type ) , ptr ,
+(intptr_t)kcm_page , kcm_page->count );
+#endif
 
         return ptr;
@@ -300 +309 @@
                 kcm->active_pages_nr ++;
                 kcm_page->active = 1;
-
-                kcm_dmsg("\n[DBG] %s : enters for type %s at cycle %d / new page = %x / count = %d\n",
-                         __FUNCTION__ , kmem_type_str( kcm->type ) , hal_get_cycles() ,
-                         (intptr_t)kcm_page , kcm_page->count );
-
         }
         else                                    // get first page from active list
@@ -310 +314 @@
                 // get page pointer from active list
                 kcm_page = (kcm_page_t *)LIST_FIRST( &kcm->active_root , kcm_page_t , list );
-
-                kcm_dmsg("\n[DBG] %s : enters for type %s at cycle %d / page = %x / count = %d\n",
-                         __FUNCTION__ , kmem_type_str( kcm->type ) , hal_get_cycles() ,
-                         (intptr_t)kcm_page , kcm_page->count );
         }
 

trunk/kernel/mm/kmem.c

@@ -198 +198 @@
         if( type == KMEM_PAGE )                        // PPM allocator
         {
+
+#if CONFIG_DEBUG_KMEM_ALLOC
+if( CONFIG_DEBUG_KMEM_ALLOC < (uint32_t)hal_get_cycles() )
+printk("\n[DBG] in %s : thread %x enter for %d page(s)\n",
+__FUNCTION__ , CURRENT_THREAD , 1<<size );
+#endif
+
                 // allocate the number of requested pages
                 ptr = (void *)ppm_alloc_pages( size );
@@ -213 +220 @@
                           __FUNCTION__, local_cxy , kmem_type_str( type ) ,
                           (intptr_t)ptr , (intptr_t)ppm_page2base( ptr ) );
+
+#if CONFIG_DEBUG_KMEM_ALLOC
+if( CONFIG_DEBUG_KMEM_ALLOC < (uint32_t)hal_get_cycles() )
+printk("\n[DBG] in %s : thread %x exit / %d page(s) allocated / ppn = %x\n",
+__FUNCTION__ , CURRENT_THREAD , 1<<size , ppm_page2ppn( XPTR( local_cxy , ptr ) ) );
+#endif
+
         }
         else if( type == KMEM_GENERIC )                // KHM allocator

trunk/kernel/mm/page.c

@@ -47 +47 @@
         page->index    = 0;
         page->refcount = 0;
-        page->fork_nr  = 0;
+        page->forks    = 0;
 
         spinlock_init( &page->lock );

trunk/kernel/mm/page.h

@@ -56 +56 @@
  * This structure defines a physical page descriptor.
  * Size is 64 bytes for a 32 bits core...
+ * TODO : the list of waiting threads seems to be unused [AG]
+ $ TODO : the spinlock use has to be clarified [AG]
  ************************************************************************************/
 
@@ -67 +69 @@
     xlist_entry_t     wait_root;      /*! root of list of waiting threads      (16) */
         uint32_t          refcount;       /*! reference counter                    (4)  */
-        uint32_t          fork_nr;        /*! number of pending forks              (4)  */
-        spinlock_t        lock;           /*! only used to set the PG_LOCKED flag  (16) */
+        uint32_t          forks;          /*! number of pending forks              (4)  */
+        spinlock_t        lock;           /*! To Be Defined [AG]                   (16) */
 }
 page_t;

trunk/kernel/mm/ppm.c

@@ -193 +193 @@
         list_add_first( &ppm->free_pages_root[current_order] , &current->list );
         ppm->free_pages_nr[current_order] ++;
-}
+
+}  // end ppm_free_pages_nolock()
 
 ////////////////////////////////////////////
@@ -201 +202 @@
         page_t   * remaining_block;
         uint32_t   current_size;
+ 
+#if CONFIG_DEBUG_PPM_ALLOC_PAGES
+uint32_t cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_PPM_ALLOC_PAGES < cycle )
+printk("\n[DBG] in %s : thread %x enter for %d page(s) / cycle %d\n",
+__FUNCTION__ , CURRENT_THREAD , 1<<order, cycle );
+#endif
+
+#if(CONFIG_DEBUG_PPM_ALLOC_PAGES & 0x1)
+if( CONFIG_DEBUG_PPM_ALLOC_PAGES < cycle )
+ppm_print();
+#endif
 
         ppm_t    * ppm = &LOCAL_CLUSTER->ppm;
@@ -208 +221 @@
 
         page_t * block = NULL;  
-
-        ppm_dmsg("\n[DBG] %s : enters / order = %d\n",
-                 __FUNCTION__ , order );
 
         // take lock protecting free lists
@@ -231 +241 @@
                 spinlock_unlock( &ppm->free_lock );
 
+#if CONFIG_DEBUG_PPM_ALLOC_PAGES
+cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_PPM_ALLOC_PAGES < cycle )
+printk("\n[DBG] in %s : thread %x cannot allocate %d page(s) at cycle %d\n",
+__FUNCTION__ , CURRENT_THREAD , 1<<order, cycle );
+#endif
+
                 return NULL;
         }
@@ -260 +277 @@
         spinlock_unlock( &ppm->free_lock );
 
-        ppm_dmsg("\n[DBG] %s : base = %x / order = %d\n",
-                 __FUNCTION__ , (uint32_t)ppm_page2base( block ) , order );
+#if CONFIG_DEBUG_PPM_ALLOC_PAGES
+cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_PPM_ALLOC_PAGES < cycle )
+printk("\n[DBG] in %s : thread %x exit / %d page(s) allocated / ppn = %x / cycle %d\n",
+__FUNCTION__, CURRENT_THREAD, 1<<order, ppm_page2ppn(XPTR( local_cxy , block )), cycle );
+#endif
 
         return block;
-}
+
+}  // end ppm_alloc_pages()
 
 
@@ -272 +294 @@
         ppm_t * ppm = &LOCAL_CLUSTER->ppm;
 
+#if CONFIG_DEBUG_PPM_FREE_PAGES
+uint32_t cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_PPM_FREE_PAGES < cycle )
+printk("\n[DBG] in %s : thread %x enter for %d page(s) / cycle %d\n",
+__FUNCTION__ , CURRENT_THREAD , 1<<page->order , cycle );
+#endif
+
+#if(CONFIG_DEBUG_PPM_FREE_PAGES & 0x1)
+if( CONFIG_DEBUG_PPM_FREE_PAGES < cycle )
+ppm_print();
+#endif
+
         // get lock protecting free_pages[] array
         spinlock_lock( &ppm->free_lock );
@@ -279 +313 @@
         // release lock protecting free_pages[] array
         spinlock_unlock( &ppm->free_lock );
+
+#if CONFIG_DEBUG_PPM_FREE_PAGES
+cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_PPM_FREE_PAGES < cycle )
+printk("\n[DBG] in %s : thread %x exit / %d page(s) released / ppn = %x / cycle %d\n",
+__FUNCTION__, CURRENT_THREAD, 1<<page->order, ppm_page2ppn(XPTR(local_cxy , page)), cycle );
+#endif
+
 }
 
-////////////////////////////
-void ppm_print( ppm_t * ppm,
-                char  * string )
+////////////////
+void ppm_print()
 {
         uint32_t       order;
@@ -289 +330 @@
         page_t       * page;
 
+    ppm_t * ppm = &LOCAL_CLUSTER->ppm;
+
         // get lock protecting free lists
         spinlock_lock( &ppm->free_lock );
 
-        printk("\n***  PPM in cluster %x : %d pages / &pages_tbl = %x / vaddr_base = %x ***\n",
-    local_cxy , ppm->pages_nr , (intptr_t)ppm->pages_tbl , (intptr_t)ppm->vaddr_base );
+        printk("\n***  PPM in cluster %x : %d pages ***\n", local_cxy , ppm->pages_nr );
 
         for( order = 0 ; order < CONFIG_PPM_MAX_ORDER ; order++ )
         {
-                printk("- order = %d / free_pages = %d  [",
+                printk("- order = %d / free_pages = %d\t: ",
                        order , ppm->free_pages_nr[order] );
 
@@ -303 +345 @@
                 {
                         page = LIST_ELEMENT( iter , page_t , list );
-                        printk("%d," , page - ppm->pages_tbl );
+                        printk("%x," , page - ppm->pages_tbl );
                 }
 
-                printk("]\n", NULL );
+                printk("\n");
         }
 

trunk/kernel/mm/ppm.h

@@ -52 +52 @@
  * from the "kernel_heap" section.
  * This low-level allocator implements the buddy algorithm: an allocated block is
- * an integer number n of 4 Kbytes pages, and n (called order) is a power of 2.
+ * an integer number n of 4 small pages, and n (called order) is a power of 2.
  ****************************************************************************************/
 
@@ -163 +163 @@
 
 /*****************************************************************************************
- * This function prints the PPM allocator status.
- *****************************************************************************************
- * @ ppm      : pointer on PPM allocator.
- * @ string   : define context of display.
+ * This function prints the PPM allocator status in the calling thread cluster.
  ****************************************************************************************/
-void ppm_print( ppm_t * ppm,
-                char  * string );
+void ppm_print();
 
 /*****************************************************************************************

trunk/kernel/mm/vmm.c

@@ -63 +63 @@
     intptr_t  size;
 
-vmm_dmsg("\n[DBG] %s : core[%x,%d] enters for process %x\n", 
-__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , process->pid );
+#if CONFIG_DEBUG_VMM_INIT
+uint32_t cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_VMM_INIT )
+printk("\n[DBG] %s : thread %x enter for process %x / cycle %d\n", 
+__FUNCTION__ , CURRENT_THREAD , process->pid , cycle );
+#endif
 
     // get pointer on VMM
@@ -179 +183 @@
     hal_fence();
 
-vmm_dmsg("\n[DBG] %s : core[%x,%d] exit for process %x / entry_point = %x\n",
-__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , 
-process->pid , process->vmm.entry_point );
+#if CONFIG_DEBUG_VMM_INIT
+cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_VMM_INIT )
+printk("\n[DBG] %s : thread %x exit for process %x / entry_point = %x / cycle %d\n", 
+__FUNCTION__ , CURRENT_THREAD , process->pid , process->vmm.entry_point , cycle );
+#endif
 
     return 0;
@@ -211 +218 @@
     {
         vseg_xp = XLIST_ELEMENT( iter_xp , vseg_t , xlist );
-        vseg    = (vseg_t *)GET_PTR( vseg_xp );
+        vseg    = GET_PTR( vseg_xp );
 
         printk(" - %s : base = %X / size = %X / npages = %d\n",
@@ -239 +246 @@
 }  // vmm_display()
 
-/////////////////////i////////////////////
-void vmm_update_pte( process_t * process,
-                     vpn_t       vpn,
-                     uint32_t    attr,
-                     ppn_t       ppn )
+/////////////////////i//////////////////////////
+void vmm_global_update_pte( process_t * process,
+                            vpn_t       vpn,
+                            uint32_t    attr,
+                            ppn_t       ppn )
 {
 
@@ -258 +265 @@
     cxy_t           owner_cxy;
     lpid_t          owner_lpid;
+
+#if CONFIG_DEBUG_VMM_UPDATE_PTE
+uint32_t cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_VMM_UPDATE_PTE < cycle )
+printk("\n[DBG] %s : thread %x enter for process %x / vpn %x / cycle %d\n",
+__FUNCTION__ , CURRENT_THREAD , process->pid , vpn , cycle );
+#endif
+
+    // check cluster is reference
+    assert( (GET_CXY( process->ref_xp ) == local_cxy) , __FUNCTION__,
+    "not called in reference cluster\n");
 
     // get extended pointer on root of process copies xlist in owner cluster
@@ -271 +289 @@
         // get cluster and local pointer on remote process
         remote_process_xp  = XLIST_ELEMENT( process_iter_xp , process_t , copies_list );
-        remote_process_ptr = (process_t *)GET_PTR( remote_process_xp );
+        remote_process_ptr = GET_PTR( remote_process_xp );
         remote_process_cxy = GET_CXY( remote_process_xp );
+
+#if (CONFIG_DEBUG_VMM_UPDATE_PTE & 0x1)
+if( CONFIG_DEBUG_VMM_UPDATE_PTE < cycle )
+printk("\n[DBG] %s : thread %x handling process %x in cluster %x\n",
+__FUNCTION__ , CURRENT_THREAD , process->pid , remote_process_cxy );
+#endif
 
         // get extended pointer on remote gpt
         remote_gpt_xp = XPTR( remote_process_cxy , &remote_process_ptr->vmm.gpt );
 
-        hal_gpt_update_pte( remote_gpt_xp,
-                            vpn,
-                            attr,
-                            ppn );
+        // update remote GPT
+        hal_gpt_update_pte( remote_gpt_xp, vpn, attr, ppn );
     }  
-}  // end vmm_update_pte()
+
+#if CONFIG_DEBUG_VMM_UPDATE_PTE
+cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_VMM_UPDATE_PTE < cycle )
+printk("\n[DBG] %s : thread %x exit for process %x / vpn %x / cycle %d\n",
+__FUNCTION__ , CURRENT_THREAD , process->pid , vpn , cycle );
+#endif
+
+}  // end vmm_global_update_pte()
 
 ///////////////////////////////////////
@@ -308 +338 @@
     lpid_t          owner_lpid;
 
-vmm_dmsg("\n[DBG] %s : core[%x,%d] enters for process %x\n",
-__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , process->pid );
+#if CONFIG_DEBUG_VMM_SET_COW
+uint32_t cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_VMM_SET_COW < cycle )
+printk("\n[DBG] %s : thread %x enter for process %x / cycle %d\n",
+__FUNCTION__ , CURRENT_THREAD , process->pid , cycle );
+#endif
 
     // check cluster is reference
@@ -333 +367 @@
         // get cluster and local pointer on remote process
         remote_process_xp  = XLIST_ELEMENT( process_iter_xp , process_t , copies_list );
-        remote_process_ptr = (process_t *)GET_PTR( remote_process_xp );
+        remote_process_ptr = GET_PTR( remote_process_xp );
         remote_process_cxy = GET_CXY( remote_process_xp );
 
-vmm_dmsg("\n[DBG] %s : core[%x,%d] handling process %x in cluster %x\n",
-__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , process->pid , remote_process_cxy );
+#if (CONFIG_DEBUG_VMM_SET_COW &0x1)
+if( CONFIG_DEBUG_VMM_SET_COW < cycle )
+printk("\n[DBG] %s : thread %x handling process %x in cluster %x\n",
+__FUNCTION__ , CURRENT_THREAD , process->pid , remote_process_cxy );
+#endif
 
         // get extended pointer on remote gpt
@@ -347 +384 @@
             // get pointer on vseg
             vseg_xp  = XLIST_ELEMENT( vseg_iter_xp , vseg_t , xlist );
-            vseg     = (vseg_t *)GET_PTR( vseg_xp );
+            vseg     = GET_PTR( vseg_xp );
 
             assert( (GET_CXY( vseg_xp ) == local_cxy) , __FUNCTION__,
@@ -357 +394 @@
             vpn_t    vpn_size = vseg->vpn_size;
 
-vmm_dmsg("\n[DBG] %s : core[%x,%d] handling vseg %s / vpn_base = %x / vpn_size = %x\n",
-__FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, vseg_type_str(type), vpn_base, vpn_size );
-
-            // set COW flag on the remote GPT depending on vseg type
+#if (CONFIG_DEBUG_VMM_SET_COW & 0x1)
+if( CONFIG_DEBUG_VMM_SET_COW < cycle )
+printk("\n[DBG] %s : thread %x handling vseg %s / vpn_base = %x / vpn_size = %x\n",
+__FUNCTION__, CURRENT_THREAD , vseg_type_str(type), vpn_base, vpn_size );
+#endif
+            // only DATA, ANON and REMOTE vsegs
             if( (type == VSEG_TYPE_DATA)  ||
                 (type == VSEG_TYPE_ANON)  ||
                 (type == VSEG_TYPE_REMOTE) )
             {
-                hal_gpt_flip_cow( true,             // set_cow
-                                  remote_gpt_xp,
-                                  vpn_base,
-                                  vpn_size );
-            }
-        }    // en loop on vsegs
+                vpn_t      vpn;
+                uint32_t   attr;
+                ppn_t      ppn;
+                xptr_t     page_xp;
+                cxy_t      page_cxy;
+                page_t   * page_ptr;
+                xptr_t     forks_xp;
+
+                // update flags in remote GPT 
+                hal_gpt_set_cow( remote_gpt_xp,
+                                 vpn_base,
+                                 vpn_size ); 
+
+                // atomically increment pending forks counter in physical pages,
+                // for all vseg pages that are mapped in reference cluster 
+                if( remote_process_cxy == local_cxy )
+                {
+                    // the reference GPT is the local GPT
+                    gpt_t * gpt = GET_PTR( remote_gpt_xp );
+
+                    // scan all pages in vseg 
+                    for( vpn = vpn_base ; vpn < (vpn_base + vpn_size) ; vpn++ )
+                    {
+                        // get page attributes and PPN from reference GPT
+                        hal_gpt_get_pte( gpt , vpn , &attr , &ppn ); 
+
+                        // atomically update pending forks counter if page is mapped
+                        if( attr & GPT_MAPPED )
+                        {
+                            page_xp  = ppm_ppn2page( ppn );
+                            page_cxy = GET_CXY( page_xp );
+                            page_ptr = GET_PTR( page_xp );
+                            forks_xp = XPTR( page_cxy , &page_ptr->forks );
+                            hal_remote_atomic_add( forks_xp , 1 );
+                        }
+                    }   // end loop on vpn
+                }   // end if local
+            }   // end if vseg type
+        }   // end loop on vsegs
     }   // end loop on process copies
  
-vmm_dmsg("\n[DBG] %s : core[%x,%d] exit for process %x\n",
-__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , process->pid );
+#if CONFIG_DEBUG_VMM_SET_COW
+cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_VMM_SET_COW < cycle )
+printk("\n[DBG] %s : thread %x exit for process %x / cycle %d\n",
+__FUNCTION__ , CURRENT_THREAD , process->pid , cycle );
+#endif
 
 }  // end vmm_set-cow()
@@ -404 +480 @@
     ppn_t       ppn;
 
-vmm_dmsg("\n[DBG] %s : core[%x,%d] enter\n",
-__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid );
+#if CONFIG_DEBUG_VMM_FORK_COPY
+uint32_t cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_VMM_FORK_COPY < cycle )
+printk("\n[DBG] %s : thread %x enter / cycle %d\n",
+__FUNCTION__ , CURRENT_THREAD, cycle );
+#endif
 
     // get parent process cluster and local pointer
     parent_cxy     = GET_CXY( parent_process_xp );
-    parent_process = (process_t *)GET_PTR( parent_process_xp );
+    parent_process = GET_PTR( parent_process_xp );
 
     // get local pointers on parent and child VMM
@@ -445 +525 @@
         // get local and extended pointers on current parent vseg
         parent_vseg_xp = XLIST_ELEMENT( iter_xp , vseg_t , xlist );
-        parent_vseg    = (vseg_t *)GET_PTR( parent_vseg_xp );
+        parent_vseg    = GET_PTR( parent_vseg_xp );
 
         // get vseg type
         type = hal_remote_lw( XPTR( parent_cxy , &parent_vseg->type ) );
         
-
-vmm_dmsg("\n[DBG] %s : core[%x,%d] found parent vseg %s / vpn_base = %x\n",
-__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , vseg_type_str(type),
-hal_remote_lw( XPTR( parent_cxy , &parent_vseg->vpn_base ) ) );
+#if CONFIG_DEBUG_VMM_FORK_COPY
+cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_VMM_FORK_COPY < cycle )
+printk("\n[DBG] %s : thread %x found parent vseg %s / vpn_base = %x / cycle %d\n",
+__FUNCTION__ , CURRENT_THREAD, vseg_type_str(type),
+hal_remote_lw( XPTR( parent_cxy , &parent_vseg->vpn_base ) ) , cycle );
+#endif
 
         // all parent vsegs - but STACK - must be copied in child VSL
@@ -473 +556 @@
             vseg_attach( child_vmm , child_vseg );
 
-vmm_dmsg("\n[DBG] %s : core[%x,%d] copied to child VSL : vseg %s / vpn_base = %x\n",
-__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , vseg_type_str(type),
-hal_remote_lw( XPTR( parent_cxy , &parent_vseg->vpn_base ) ) );
+#if CONFIG_DEBUG_VMM_FORK_COPY
+cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_VMM_FORK_COPY < cycle )
+printk("\n[DBG] %s : thread %x copied vseg %s / vpn_base = %x to child VSL / cycle %d\n",
+__FUNCTION__ , CURRENT_THREAD , vseg_type_str(type),
+hal_remote_lw( XPTR( parent_cxy , &parent_vseg->vpn_base ) ) , cycle );
+#endif
 
             // copy DATA, MMAP, REMOTE, FILE parent GPT entries to child GPT
@@ -502 +589 @@
                     }
 
-                    // increment page descriptor fork_nr for the referenced page if mapped
+                    // increment pending forks counter in page if mapped
                     if( mapped )
                     {
                         page_xp = ppm_ppn2page( ppn );
                         page_cxy = GET_CXY( page_xp );
-                        page_ptr = (page_t *)GET_PTR( page_xp );
-                        hal_remote_atomic_add( XPTR( page_cxy , &page_ptr->fork_nr ) , 1 );
-
-vmm_dmsg("\n[DBG] %s : core[%x,%d] copied to child GPT : vpn %x\n",
-__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , vpn );
+                        page_ptr = GET_PTR( page_xp );
+                        hal_remote_atomic_add( XPTR( page_cxy , &page_ptr->forks ) , 1 );
+
+#if CONFIG_DEBUG_VMM_FORK_COPY
+cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_VMM_FORK_COPY < cycle )
+printk("\n[DBG] %s : thread %x copied vpn %x to child GPT / cycle %d\n",
+__FUNCTION__ , CURRENT_THREAD , vpn , cycle );
+#endif
 
                     }
@@ -558 +649 @@
     hal_fence();
 
+#if CONFIG_DEBUG_VMM_FORK_COPY
+cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_VMM_FORK_COPY < cycle )
+printk("\n[DBG] %s : thread %x exit successfully / cycle %d\n",
+__FUNCTION__ , CURRENT_THREAD , cycle );
+#endif
+
     return 0;
 
@@ -568 +666 @@
         vseg_t * vseg;
 
-vmm_dmsg("\n[DBG] %s : core[%x,%d] enter\n",
-__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid );
-
-    // get pointer on VMM
+#if CONFIG_DEBUG_VMM_DESTROY
+uint32_t cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_VMM_DESTROY < cycle )
+printk("\n[DBG] %s : thread %x enter for process %x / cycle %d\n",
+__FUNCTION__ , CURRENT_THREAD , process->pid , cycle );
+#endif
+
+    // get pointer on local VMM
     vmm_t  * vmm = &process->vmm;
 
@@ -586 +688 @@
         // get pointer on first vseg in VSL
                 vseg_xp = XLIST_FIRST_ELEMENT( root_xp , vseg_t , xlist );
-        vseg = (vseg_t *)GET_PTR( vseg_xp );
-
-        // unmap and release all pages
+        vseg    = GET_PTR( vseg_xp );
+
+        // unmap rand release physical pages if required)
         vmm_unmap_vseg( process , vseg );
 
@@ -598 +700 @@
         }
 
-    // release lock
+    // release lock protecting VSL
         remote_rwlock_wr_unlock( lock_xp );
 
@@ -616 +718 @@
     hal_gpt_destroy( &vmm->gpt );
 
-vmm_dmsg("\n[DBG] %s : core[%x,%d] exit\n",
-__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid );
+#if CONFIG_DEBUG_VMM_DESTROY
+cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_VMM_DESTROY < cycle )
+printk("\n[DBG] %s : thread %x exit / cycle %d\n",
+__FUNCTION__ , CURRENT_THREAD , cycle );
+#endif
 
 }  // end vmm_destroy()
@@ -637 +743 @@
         {
                 vseg_xp = XLIST_ELEMENT( iter_xp , vseg_t , xlist );
-        vseg    = (vseg_t *)GET_PTR( vseg_xp );
+        vseg    = GET_PTR( vseg_xp );
 
                 if( ((vpn_base + vpn_size) > vseg->vpn_base) &&
@@ -766 +872 @@
         error_t      error;
 
-vmm_dmsg("\n[DBG] %s : core[%x,%d] enters / process %x / base %x / size %x / %s / cxy = %x\n",
-__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid ,
-process->pid , base , size , vseg_type_str(type) , cxy );
+#if CONFIG_DEBUG_VMM_CREATE_VSEG
+uint32_t cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_VMM_CREATE_VSEG < cycle )
+printk("\n[DBG] %s : thread %x enter / process %x / base %x / size %x / %s / cxy %x / cycle %d\n",
+__FUNCTION__, CURRENT_THREAD, process->pid, base, size, vseg_type_str(type), cxy, cycle );
+#endif
 
     // get pointer on VMM 
@@ -854 +963 @@
         remote_rwlock_wr_unlock( lock_xp );
 
-vmm_dmsg("\n[DBG] %s : core[%x,%d] exit / process %x / base %x / size %x / type %s\n",
-__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid ,
-process->pid , base , size , vseg_type_str(type) );
+#if CONFIG_DEBUG_VMM_CREATE_VSEG
+cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_VMM_CREATE_VSEG < cycle )
+printk("\n[DBG] %s : thread %x exit / process %x / %s / cxy %x / cycle %d\n",
+__FUNCTION__, CURRENT_THREAD, process->pid, vseg_type_str(type), cxy, cycle );
+#endif
 
         return vseg;
@@ -985 +1097 @@
     cxy_t       page_cxy;   // page descriptor cluster
     page_t    * page_ptr;   // page descriptor pointer
-
-vmm_dmsg("\n[DBG] %s : core[%x, %d] enter / process %x / vseg %s / base %x / cycle %d\n",
-__FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, process->pid ,
-vseg_type_str( vseg->type ), vseg->vpn_base, (uint32_t)hal_get_cycles() );
-
-    // get pointer on process GPT
+    xptr_t      forks_xp;   // extended pointer on pending forks counter
+    uint32_t    count;      // actual number of pendinf forks
+
+#if CONFIG_DEBUG_VMM_UNMAP_VSEG
+uint32_t cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_VMM_UNMAP_VSEG < cycle )
+printk("\n[DBG] %s : thread %x enter / process %x / vseg %s / base %x / cycle %d\n",
+__FUNCTION__, CURRENT_THREAD, process->pid, vseg_type_str( vseg->type ), vseg->vpn_base, cycle );
+#endif
+
+    // get pointer on local GPT
     gpt_t     * gpt = &process->vmm.gpt;
 
@@ -1007 +1124 @@
             "an user vseg must use small pages" );
 
-            // unmap GPT entry
+            // unmap GPT entry in all GPT copies
             hal_gpt_reset_pte( gpt , vpn );
 
-            // release memory if not identity mapped
-            if( (vseg->flags & VSEG_IDENT)  == 0 )
+            // handle pending forks counter if
+            // 1) not identity mapped
+            // 2) running in reference cluster
+            if( ((vseg->flags & VSEG_IDENT)  == 0) &&
+                (GET_CXY( process->ref_xp ) == local_cxy) )
             {
-                // get extended pointer on page descriptor
+                // get extended pointer on physical page descriptor
                 page_xp  = ppm_ppn2page( ppn );
                 page_cxy = GET_CXY( page_xp );
-                page_ptr = (page_t *)GET_PTR( page_xp );
-
-                // release physical page to relevant cluster
-                if( page_cxy == local_cxy )                   // local cluster
+                page_ptr = GET_PTR( page_xp );
+
+                // FIXME lock the physical page
+
+                // get extended pointer on pending forks counter
+                forks_xp = XPTR( page_cxy , &page_ptr->forks );
+
+                // get pending forks counter
+                count = hal_remote_lw( forks_xp );
+                
+                if( count )  // decrement pending forks counter
                 {
-                    req.type = KMEM_PAGE;
-                    req.ptr  = page_ptr; 
-                    kmem_free( &req );
+                    hal_remote_atomic_add( forks_xp , -1 );
+                }  
+                else         // release physical page to relevant cluster
+                {
+                    if( page_cxy == local_cxy )   // local cluster
+                    {
+                        req.type = KMEM_PAGE;
+                        req.ptr  = page_ptr; 
+                        kmem_free( &req );
+                    }
+                    else                          // remote cluster
+                    {
+                        rpc_pmem_release_pages_client( page_cxy , page_ptr );
+                    }
                 }
-                else                                          // remote cluster
-                {
-                    rpc_pmem_release_pages_client( page_cxy , page_ptr );
-                }
+
+                // FIXME unlock the physical page
             }
         }
     }
+
+#if CONFIG_DEBUG_VMM_UNMAP_VSEG
+cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_VMM_UNMAP_VSEG < cycle )
+printk("\n[DBG] %s : thread %x exit / process %x / vseg %s / base %x / cycle %d\n",
+__FUNCTION__, CURRENT_THREAD, process->pid, vseg_type_str( vseg->type ), vseg->vpn_base, cycle );
+#endif
+
 }  // end vmm_unmap_vseg()
 
@@ -1061 +1205 @@
     {
         vseg_xp = XLIST_ELEMENT( iter_xp , vseg_t , xlist );
-        vseg    = (vseg_t *)GET_PTR( vseg_xp );
+        vseg    = GET_PTR( vseg_xp );
         if( (vaddr >= vseg->min) && (vaddr < vseg->max) )
         {
@@ -1185 +1329 @@
         // get cluster and local pointer on reference process 
         cxy_t       ref_cxy = GET_CXY( ref_xp );
-        process_t * ref_ptr = (process_t *)GET_PTR( ref_xp );
+        process_t * ref_ptr = GET_PTR( ref_xp );
 
         if( local_cxy == ref_cxy )  return -1;   // local cluster is the reference
@@ -1224 +1368 @@
                                  vpn_t    vpn )
 {
+
+#if CONFIG_DEBUG_VMM_ALLOCATE_PAGE
+if( CONFIG_DEBUG_VMM_ALLOCATE_PAGE < (uint32_t)hal_get_cycles() )
+printk("\n[DBG] in %s : thread %x enter for vpn %x\n",
+__FUNCTION__ , CURRENT_THREAD, vpn );
+#endif
+
     // compute target cluster
     page_t     * page_ptr;
@@ -1262 +1413 @@
     }
 
+#if CONFIG_DEBUG_VMM_ALLOCATE_PAGE
+if( CONFIG_DEBUG_VMM_ALLOCATE_PAGE < (uint32_t)hal_get_cycles() )
+printk("\n[DBG] in %s : thread %x exit for vpn = %d / ppn = %x\n",
+__FUNCTION__ , CURRENT_THREAD, vpn, ppm_page2ppn( XPTR( page_cxy , page_ptr ) ) );
+#endif
+
     if( page_ptr == NULL ) return XPTR_NULL;
     else                   return XPTR( page_cxy , page_ptr );
@@ -1281 +1438 @@
     index     = vpn - vseg->vpn_base;
 
-vmm_dmsg("\n[DBG] %s : core[%x,%d] enter for vpn = %x / type = %s / index = %d\n",
-__FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, vpn, vseg_type_str(type), index );
+#if CONFIG_DEBUG_VMM_GET_ONE_PPN 
+if( CONFIG_DEBUG_VMM_GET_ONE_PPN < (uint32_t)hal_get_cycles() )
+printk("\n[DBG] %s : thread %x enter for vpn = %x / type = %s / index = %d\n",
+__FUNCTION__, CURRENT_THREAD, vpn, vseg_type_str(type), index );
+#endif
 
     // FILE type : get the physical page from the file mapper
@@ -1295 +1455 @@
         // get mapper cluster and local pointer
         cxy_t      mapper_cxy = GET_CXY( mapper_xp );
-        mapper_t * mapper_ptr = (mapper_t *)GET_PTR( mapper_xp );
+        mapper_t * mapper_ptr = GET_PTR( mapper_xp );
 
         // get page descriptor from mapper
@@ -1316 +1476 @@
     else
     {
-        // allocate physical page 
+        // allocate one physical page 
         page_xp = vmm_page_allocate( vseg , vpn );
 
@@ -1322 +1482 @@
 
         // initialise missing page from .elf file mapper for DATA and CODE types
-        // => the mapper_xp field is an extended pointer on the .elf file mapper
+        // (the vseg->mapper_xp field is an extended pointer on the .elf file mapper)
         if( (type == VSEG_TYPE_CODE) || (type == VSEG_TYPE_DATA) )
         {
@@ -1333 +1493 @@
             // get mapper cluster and local pointer
             cxy_t      mapper_cxy = GET_CXY( mapper_xp );
-            mapper_t * mapper_ptr = (mapper_t *)GET_PTR( mapper_xp );
+            mapper_t * mapper_ptr = GET_PTR( mapper_xp );
 
             // compute missing page offset in vseg
@@ -1341 +1501 @@
             uint32_t elf_offset = vseg->file_offset + offset;
 
-vmm_dmsg("\n[DBG] %s : core[%x,%d] for vpn = %x / elf_offset = %x\n",
-__FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, vpn, elf_offset );
+#if (CONFIG_DEBUG_VMM_GET_ONE_PPN & 0x1)
+if( CONFIG_DEBUG_VMM_GET_ONE_PPN < (uint32_t)hal_get_cycles() )
+printk("\n[DBG] %s : thread %x for vpn = %x / elf_offset = %x\n",
+__FUNCTION__, CURRENT_THREAD, vpn, elf_offset );
+#endif
 
             // compute extended pointer on page base 
@@ -1352 +1515 @@
             if( file_size < offset )                 // missing page fully in  BSS 
             {
-vmm_dmsg("\n[DBG] %s : core[%x,%d] for vpn = %x / fully in BSS\n",
-__FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, vpn );
+
+#if (CONFIG_DEBUG_VMM_GET_ONE_PPN & 0x1)
+if( CONFIG_DEBUG_VMM_GET_ONE_PPN < (uint32_t)hal_get_cycles() )
+printk("\n[DBG] %s : thread%x for vpn = %x / fully in BSS\n",
+__FUNCTION__, CURRENT_THREAD, vpn );
+#endif
 
                 if( GET_CXY( page_xp ) == local_cxy )
@@ -1367 +1534 @@
             {
 
-vmm_dmsg("\n[DBG] %s : core[%x,%d] for vpn = %x / fully in mapper\n",
-__FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, vpn );
+#if (CONFIG_DEBUG_VMM_GET_ONE_PPN & 0x1)
+if( CONFIG_DEBUG_VMM_GET_ONE_PPN < (uint32_t)hal_get_cycles() )
+printk("\n[DBG] %s : thread %x, for vpn = %x / fully in mapper\n",
+__FUNCTION__, CURRENT_THREAD, vpn );
+#endif
 
                 if( mapper_cxy == local_cxy ) 
@@ -1396 +1566 @@
             {
 
-vmm_dmsg("\n[DBG] %s : core[%x,%d] for vpn = %x / both mapper & BSS\n"
-         "      %d bytes from mapper / %d bytes from BSS\n",
-__FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, vpn,
+#if (CONFIG_DEBUG_VMM_GET_ONE_PPN & 0x1)
+if( CONFIG_DEBUG_VMM_GET_ONE_PPN < (uint32_t)hal_get_cycles() )
+printk("\n[DBG] %s : thread %x for vpn = %x / both mapper & BSS\n"
+"      %d bytes from mapper / %d bytes from BSS\n",
+__FUNCTION__, CURRENT_THREAD, vpn,
 file_size - offset , offset + CONFIG_PPM_PAGE_SIZE - file_size  );
-
+#endif
                 // initialize mapper part
                 if( mapper_cxy == local_cxy )
@@ -1441 +1613 @@
     *ppn = ppm_page2ppn( page_xp );
 
-vmm_dmsg("\n[DBG] %s : core[%x,%d] exit for vpn = %x / ppn = %x\n",
-__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , vpn , *ppn );
+#if CONFIG_DEBUG_VMM_GET_ONE_PPN
+if( CONFIG_DEBUG_VMM_GET_ONE_PPN < (uint32_t)hal_get_cycles() )
+printk("\n[DBG] %s : thread %x exit for vpn = %x / ppn = %x\n",
+__FUNCTION__ , CURRENT_THREAD , vpn , *ppn );
+#endif
 
     return 0;
@@ -1455 +1630 @@
                      ppn_t     * ppn )
 {
-    vseg_t  * vseg;       // pointer on vseg containing VPN
+    vseg_t  * vseg;       // vseg containing VPN
     ppn_t     old_ppn;    // current PTE_PPN
     uint32_t  old_attr;   // current PTE_ATTR
@@ -1466 +1641 @@
     "not called in the reference cluster\n" );
 
-vmm_dmsg("\n[DBG] %s : core[%x,%d] enter for vpn = %x in process %x / cow = %d\n",
-__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , vpn , process->pid , cow );
+#if CONFIG_DEBUG_VMM_GET_PTE
+uint32_t cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_VMM_GET_PTE > cycle )
+printk("\n[DBG] %s : thread %x enter for vpn = %x / process %x / cow = %d / cycle %d\n",
+__FUNCTION__ , CURRENT_THREAD , vpn , process->pid , cow , cycle );
+#endif
 
     // get VMM pointer
     vmm_t * vmm = &process->vmm;
 
-    // get vseg pointer from ref VSL
+    // get vseg pointer from reference VSL
     error = vmm_get_vseg( process , vpn<<CONFIG_PPM_PAGE_SHIFT , &vseg );
 
@@ -1482 +1661 @@
     }
 
-vmm_dmsg("\n[DBG] %s : core[%x,%d] found vseg %s / vpn_base = %x / vpn_size = %x\n",
-__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid ,
-vseg_type_str(vseg->type) , vseg->vpn_base , vseg->vpn_size );
+#if CONFIG_DEBUG_VMM_GET_PTE
+cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_VMM_GET_PTE < cycle )
+printk("\n[DBG] %s : thread %x found vseg %s / vpn_base = %x / vpn_size = %x\n",
+__FUNCTION__, CURRENT_THREAD, vseg_type_str(vseg->type), vseg->vpn_base, vseg->vpn_size );
+#endif
 
     // access GPT to get current PTE attributes and PPN
@@ -1493 +1675 @@
     // clusters containing a copy, and return the new_ppn and new_attr
 
-    if( cow )               ////////////// copy_on_write request ///////////
+    if( cow )  /////////////////////////// copy_on_write request //////////////////////
     {
         assert( (old_attr & GPT_MAPPED) , __FUNCTION__ , 
         "PTE must be mapped for a copy-on-write exception\n" );
 
-excp_dmsg("\n[DBG] %s : core[%x,%d] handling COW for vpn %x\n",
-__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , vpn );
-
-        // get extended pointer, cluster and local pointer on page descriptor
+#if CONFIG_DEBUG_VMM_GET_PTE
+cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_VMM_GET_PTE < cycle )
+printk("\n[DBG] %s : thread %x handling COW for vpn %x in process %x\n",
+__FUNCTION__, CURRENT_THREAD, vpn, process->pid );
+#endif
+
+        // get extended pointer, cluster and local pointer on physical page descriptor
         xptr_t   page_xp  = ppm_ppn2page( old_ppn );
         cxy_t    page_cxy = GET_CXY( page_xp );
-        page_t * page_ptr = (page_t *)GET_PTR( page_xp );
+        page_t * page_ptr = GET_PTR( page_xp );
 
         // get number of pending forks in page descriptor
-        uint32_t count = hal_remote_lw( XPTR( page_cxy , &page_ptr->fork_nr ) );
-
-        if( count )        // pending fork => allocate a new page, copy it, reset COW
+        uint32_t forks = hal_remote_lw( XPTR( page_cxy , &page_ptr->forks ) );
+
+        if( forks )        // pending fork => allocate a new page, copy old to new
         {
             // allocate a new physical page
@@ -1539 +1725 @@
 
         // update GPT[vpn] for all GPT copies
-        // to maintain coherence of copies
-        vmm_update_pte( process,
-                        vpn,
-                        new_attr,
-                        new_ppn );
-
-        // decrement fork_nr in page descriptor
-        hal_remote_atomic_add( XPTR( page_cxy , &page_ptr->fork_nr ) , -1 );
-    }
-    else                         /////////////// page_fault request ///////////
+        vmm_global_update_pte( process, vpn, new_attr, new_ppn );
+
+        // decrement pending forks counter in page descriptor
+        hal_remote_atomic_add( XPTR( page_cxy , &page_ptr->forks ) , -1 );
+    }
+    else  ////////////////////////////////// page_fault request ////////////////////////
     {  
         if( (old_attr & GPT_MAPPED) == 0 )   // true page_fault => map it
         {
 
-excp_dmsg("\n[DBG] %s : core[%x,%d] handling page fault for vpn %x\n",
-__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , vpn );
+#if CONFIG_DEBUG_VMM_GET_PTE
+cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_VMM_GET_PTE < cycle )
+printk("\n[DBG] %s : thread %x handling page fault for vpn %x in process %x\n",
+__FUNCTION__, CURRENT_THREAD, vpn, process->pid );
+#endif
 
             // allocate new_ppn, depending on vseg type
@@ -1592 +1778 @@
     }
 
-excp_dmsg("\n[DBG] %s : core[%x,%d] update GPT for vpn %x / ppn = %x / attr = %x\n",
-__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , vpn , new_ppn , new_attr );
-
-    // retur success
+#if CONFIG_DEBUG_VMM_GET_PTE
+cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_VMM_GET_PTE < cycle )
+printk("\n[DBG] %s : thread,%x exit for vpn %x in process %x / ppn = %x / attr = %x / cycle %d\n",
+__FUNCTION__, CURRENT_THREAD, vpn, process->pid, new_ppn, new_attr, cycle );
+#endif
+
+    // return success
     *ppn  = new_ppn;
     *attr = new_attr;
@@ -1612 +1802 @@
     // get reference process cluster and local pointer
     cxy_t       ref_cxy = GET_CXY( process->ref_xp );
-    process_t * ref_ptr = (process_t *)GET_PTR( process->ref_xp );
+    process_t * ref_ptr = GET_PTR( process->ref_xp );
 
     // get missing PTE attributes and PPN from reference cluster
@@ -1651 +1841 @@
                         vpn_t       vpn )
 {
-    uint32_t         attr;          // missing page attributes
-    ppn_t            ppn;           // missing page PPN
+    uint32_t         attr;          // page attributes
+    ppn_t            ppn;           // page PPN
     error_t          error;
 
+    
     // get reference process cluster and local pointer
     cxy_t       ref_cxy = GET_CXY( process->ref_xp );
-    process_t * ref_ptr = (process_t *)GET_PTR( process->ref_xp );
+    process_t * ref_ptr = GET_PTR( process->ref_xp );
 
     // get new PTE attributes and PPN from reference cluster
@@ -1722 +1913 @@
     {
         cxy_t       ref_cxy = GET_CXY( process->ref_xp );
-        process_t * ref_ptr = (process_t *)GET_PTR( process->ref_xp );
+        process_t * ref_ptr = GET_PTR( process->ref_xp );
         rpc_vmm_get_pte_client( ref_cxy , ref_ptr , vpn , false , &attr , &ppn , &error );
     }

trunk/kernel/mm/vmm.h

@@ -99 +99 @@
  *    a remote_rwlock, because it can be accessed by a thread running in a remote cluster.
  *    An exemple is the vmm_fork_copy() function.
- * 2. In most custers, the VSL and GPT are only partial copies of the reference VSL and GPT
+ * 2. In most clusters, the VSL and GPT are only partial copies of the reference VSL and GPT
  *    structures, stored in the reference cluster.
  ********************************************************************************************/
@@ -155 +155 @@
 
 /*********************************************************************************************
- * This function is called by the process_fork_create() function. It partially copies
+ * 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:
  * - all DATA, MMAP, REMOTE vsegs registered in the parent VSL are registered in the child
@@ -176 +176 @@
 
 /*********************************************************************************************
- * This function is called by the process_make_fork() function to handle the fork syscall.
+ * This function is called by the process_make_fork() function executing the fork syscall.
  * It set the COW flag, and reset the WRITABLE flag of all GPT entries of the DATA, MMAP,
  * and REMOTE vsegs of a process identified by the <process> argument.
  * It must be called by a thread running in the reference cluster, that contains the complete
- * list of vsegs. Use the rpc_vmm_set_cow_client() when the calling thread client is remote. 
+ * VSL and GPT (use the rpc_vmm_set_cow_client() when the calling thread client is remote). 
  * It updates all copies of the process in all clusters, to maintain coherence in GPT copies,
  * using the list of copies stored in the owner process, and using remote_write accesses to
- * update the remote GPTs. It cannot fail, as only mapped entries in GPT copies are updated.
+ * update the remote GPTs. It atomically increment the pending_fork counter, in all involved
+ * physical page descriptors. It cannot fail, as only mapped entries in GPTs are updated.
  *********************************************************************************************
  * @ process   : local pointer on local reference process descriptor.
@@ -190 +191 @@
 
 /*********************************************************************************************
- * This function is called by the vmm_get_pte() function in case of COW exception.
- * It modifies both the PPN an the attributes for a GPT entry identified by the <process>
- * and <vpn> arguments. 
+ * This global function modifies a GPT entry identified  by the <process> and <vpn> 
+ * arguments in all clusters containing a process copy.
+ * It must be called by a thread running in the reference cluster.
  * It updates all copies of the process in all clusters, to maintain coherence in GPT copies,
  * using the list of copies stored in the owner process, and using remote_write accesses to
@@ -202 +203 @@
  * @ ppn       : PTE / physical page index.
  ********************************************************************************************/
-void vmm_update_pte( struct process_s * process,
-                     vpn_t              vpn,
-                     uint32_t           attr,
-                     ppn_t              ppn );
-
-/*********************************************************************************************
- * This function scan the list of vsegs registered in the VSL of the process 
- * identified by the <process> argument, and for each vseg:
- * - it unmap from the GPT and releases all mapped pages in vseg.
- * - it removes the vseg from the process VSL.
- * - It releases the memory allocated to the vseg descriptor.
+void vmm_global_update_pte( struct process_s * process,
+                            vpn_t              vpn,
+                            uint32_t           attr,
+                            ppn_t              ppn );
+
+/*********************************************************************************************
+ * This function unmaps from the local GPT all mapped PTEs of a vseg identified by the
+ * <process> and <vseg> arguments. It can be used for any type of vseg.
+ * If this function is executed in the reference cluster, it handles for each referenced 
+ * physical pages the pending forks counter :
+ * - if counter is non-zero, it decrements it.
+ * - if counter is zero, it releases the physical page to local kmem allocator.
+ *********************************************************************************************
+ * @ process  : pointer on process descriptor.
+ * @ vseg     : pointer on the vseg to be unmapped.
+ ********************************************************************************************/
+void vmm_unmap_vseg( struct process_s * process,
+                     vseg_t           * vseg );
+
+/*********************************************************************************************
+ * This function deletes, in the local cluster, all vsegs registered in the VSL
+ * of the process identified by the <process> argument. For each vseg:
+ * - it unmaps all vseg PTEs from the GPT (release the physical pages when required). 
+ * - it removes the vseg from the local VSL.
+ * - it releases the memory allocated to the local vseg descriptors.
  * Finally, it releases the memory allocated to the GPT itself.
  *********************************************************************************************
@@ -291 +306 @@
 
 /*********************************************************************************************
- * This function unmaps all mapped PTEs of a given vseg, from the generic page table 
- * associated to a given process descriptor, and releases the physical memory allocated
- * to all mapped GPT entries.  It can be used for any type of vseg.
- *********************************************************************************************
- * @ process  : pointer on process descriptor.
- * @ vseg     : pointer on the vseg to be unmapped.
- ********************************************************************************************/
-void vmm_unmap_vseg( struct process_s * process,
-                     vseg_t           * vseg );
-
-/*********************************************************************************************
  * This function removes a given region (defined by a base address and a size) from
  * the VMM of a given process descriptor. This can modify the number of vsegs:
@@ -340 +344 @@
 /*********************************************************************************************
  * This function is called by the generic exception handler when a page-fault event
- * has been detected in a given cluster. 
+ * has been detected for a given process in a given cluster.
  * - If the local cluster is the reference, it call directly the vmm_get_pte() function.
  * - If the local cluster is not the reference cluster, it send a RPC_VMM_GET_PTE
@@ -355 +359 @@
 /*********************************************************************************************
  * This function is called by the generic exception handler when a copy-on-write event
- * has been detected in a given cluster. 
- * - If the local cluster is the reference, it call directly the vmm_get_pte() function.
- * - If the local cluster is not the reference cluster, it send a RPC_VMM_GET_PTE
- *   to the reference cluster to get the missing PTE attributes and PPN,
- *   and update the local page table. 
+ * has been detected for a given process in a given cluster.
+ * It takes the lock protecting the physical page, and test the pending forks counter.
+ * If no pending fork:
+ * - it reset the COW flag and set the WRITE flag in the reference GPT entry, and in all
+ *   the GPT copies
+
+ * If there is a pending forkon the
+ * - It get the involved vseg pointer. 
+ * - It allocates a new physical page from the cluster defined by the vseg type.
+ * - It copies the old physical page content to the new physical page.
+ * - It decrements the pending_fork counter in old physical page descriptor.
+
  *********************************************************************************************
  * @ process   : pointer on process descriptor.
@@ -369 +380 @@
 
 /*********************************************************************************************
- * This function is called when a new PTE (GPT entry) is required because a "page-fault",
- * or "copy-on_write" event has been detected for a given <vpn> in a given <process>. 
- * The <cow> argument defines the type of event to be handled. 
+ * This function handle both the "page-fault" and "copy-on_write" events for a given <vpn> 
+ * in a given <process>.  The <cow> argument defines the type of event to be handled. 
  * This function must be called by a thread running in reference cluster, and the vseg
- * containing the searched VPN should be registered in the reference VMM.
- * - for an actual page-fault, it allocates the missing physical page from the target cluster
- *   defined by the vseg type, initialize it, and update the reference page table. 
+ * containing the searched VPN must be registered in the reference VMM.
+ * - for an page-fault, it allocates the missing physical page from the target cluster
+ *   defined by the vseg type, initializes it, and updates the reference GPT, but not
+ *   the copies GPT, that will be updated on demand. 
  * - for a copy-on-write, it allocates a new physical page from the target cluster,
- *   initialise it from the old physical page, and update the reference page table. 
- * In both cases, it calls the RPC_PMEM_GET_PAGES to get the new physical page if the
- * target cluster is not the reference cluster.
+ *   initialise it from the old physical page, and updates the reference GPT and all
+ *   the GPT copies, for coherence. 
+ * In both cases, it calls the RPC_PMEM_GET_PAGES to get the new physical page when
+ * the target cluster is not the reference cluster.
  * It returns in the <attr> and <ppn> arguments the accessed or modified PTE.
  *********************************************************************************************
@@ -400 +412 @@
  * (Physical Page Number) associated to a missing page defined by the <vpn> argument.
  * - For the FILE type, it returns directly the physical page from the file mapper.
- * - For the CODE and DATA types, it allocates a new phsical page from the cluster defined
+ * - For the CODE and DATA types, it allocates a new physical page from the cluster defined
  *   by the <vseg->cxy> field, or by the <vpn> MSB bits for a distributed vseg,
  *   and initialize this page from the .elf file mapper.