Changeset 632 for trunk

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

Files:

• hal/generic/hal_gpt.h (modified) (3 diffs)
• hal/tsar_mips32/core/hal_exception.c (modified) (2 diffs)
• hal/tsar_mips32/core/hal_gpt.c (modified) (14 diffs)
• hal/tsar_mips32/core/hal_irqmask.c (modified) (2 diffs)
• hal/tsar_mips32/core/hal_ppm.c (modified) (3 diffs)
• kernel/kern/dqdt.c (modified) (5 diffs)
• kernel/kern/dqdt.h (modified) (1 diff)
• kernel/kern/kernel_init.c (modified) (1 diff)
• kernel/kern/rpc.c (modified) (6 diffs)
• kernel/kern/rpc.h (modified) (4 diffs)
• kernel/kernel_config.h (modified) (5 diffs)
• kernel/libk/list.h (modified) (12 diffs)
• kernel/libk/remote_barrier.c (modified) (5 diffs)
• kernel/mm/page.c (modified) (1 diff)
• kernel/mm/page.h (modified) (9 diffs)
• kernel/mm/ppm.c (modified) (16 diffs)
• kernel/mm/ppm.h (modified) (4 diffs)
• kernel/mm/vmm.c (modified) (29 diffs)
• kernel/mm/vmm.h (modified) (1 diff)
• libs/libpthread/pthread.h (modified) (1 diff)

trunk/hal/generic/hal_gpt.h

@@ -96 +96 @@
  * of a remote GPT identified by the <gpt_xp> and <vpn> arguments, after checking 
  * (in a busy waiting loop) that this attribute has been reset. 
- * Then, it returns in the <attr> and <ppn> buffers the current value of the PTE.
- * It allocates memory required by the GPT implementation to register this lock
- * in the PTE when required.
+ * It returns in the <attr> and <ppn> buffers the value of the PTE before modification.
+ * It atomically allocates memory  to register this attribute in the PTE when 
+ * required by a specific GPT implementation (example : allocate a PT2 in the TSAR GPT).
  * WARNING : Only small pages can be locked.
  ****************************************************************************************
@@ -128 +128 @@
  *
  * WARNING : For a small page, it checks that the GPT_LOCKED attribute has been
- *           previously set, to prevent concurrent accesses.
+ *           previously set, to prevent concurrent mapping accesses.
  ****************************************************************************************
  * @ gpt_xp    : [in] extended pointer on the page table
@@ -212 +212 @@
  * It modifies an existing entry identified by the <vpn> argument in a remote GPT
  * identified by the <gpt_xp> argument, using remote accesses.
- * It does NOT require the GPT_LOCKED attribute to be set in the target PTE.
- * It cannot fail, because only MAPPED & SMALL entries are modified.
+ * - The MAPPED and SMALL attributes must be set, and the LOCKED attibute must be reset
+ *   in the <attr> argument.
+ * - The MAPPED and SMALL attributes must be set in the target PTE.
  ****************************************************************************************
  * @ gpt_xp    : [in] extended pointer on the page table

trunk/hal/tsar_mips32/core/hal_exception.c

@@ -165 +165 @@
 // in case of illegal virtual address. Finally, it updates the local page table from the
 // reference cluster.
+// WARNING : In order to prevent deadlocks, this function enable IRQs before calling the 
+// vmm_handle_page_fault() and the vmm_handle_cow() functions, because concurrent calls
+// to these functions can create cross dependencies...
 //////////////////////////////////////////////////////////////////////////////////////////
 // @ this     : pointer on faulty thread descriptor.
@@ -187 +190 @@
 
     // check thread type
-    if( CURRENT_THREAD->type != THREAD_USER )
+   if( CURRENT_THREAD->type != THREAD_USER )
     {
         printk("\n[PANIC] in %s : illegal thread type %s\n",

trunk/hal/tsar_mips32/core/hal_gpt.c

@@ -77 +77 @@
 #define TSAR_MMU_ATTR_FROM_PTE2( pte2 )    (pte2 & 0xFFC000FF)
 
-
 ///////////////////////////////////////////////////////////////////////////////////////
 // This static function translates the GPT attributes to the TSAR attributes
@@ -125 +124 @@
     return gpt_attr;
 }
+
+///////////////////////////////////////////////////////////////////////////////////////
+// The blocking hal_gpt_lock_pte() function implements a busy-waiting policy to get
+// exclusive access to a specific GPT entry.
+// - when non zero, the following variable defines the max number of iterations
+//   in the busy waiting loop.
+// - when zero, the watchdog mechanism is deactivated.
+///////////////////////////////////////////////////////////////////////////////////////
+
+#define GPT_LOCK_WATCHDOG   100000
 
 /////////////////////////////////////
@@ -317 +326 @@
 */
 
-/////////////////////////////////////////////////////////////////////////////////////////
-// This static function returns in the <ptd1_value> buffer the current value of
-// the PT1 entry identified by the <pte1_xp> argument, that must contain a PTD1
-// (i.e. a pointer on a PT2). If this PT1 entry is not mapped yet, it allocates a
-// new PT2 and updates the PT1 entry, using the TSAR_MMU_LOCKED attribute in PT1
-// entry, to handle possible concurrent mappings of the missing PTD1:
-// 1) If the PT1 entry is unmapped, it tries to atomically lock this PTD1.
-//    - if the atomic lock is successful it allocates a new PT1, and updates the PTD1.
-//    - else, it simply waits, in a polling loop, the mapping done by another thread.
-//    In both cases, returns the PTD1 value, when the mapping is completed. 
-// 2) If the PT1 entry is already mapped, it returns the PTD1 value, and does
-//    nothing else.
-/////////////////////////////////////////////////////////////////////////////////////////
-static error_t hal_gpt_allocate_pt2( xptr_t     ptd1_xp,
-                                     uint32_t * ptd1_value ) 
-{
-    cxy_t      gpt_cxy;     // target GPT cluster = GET_CXY( ptd1_xp );
-    uint32_t   ptd1;        // PTD1 value
-    ppn_t      pt2_ppn;     // PPN of page containing the new PT2
-    bool_t     atomic;
-    page_t   * page;
-    xptr_t     page_xp;
-
-    // get GPT cluster identifier
-    gpt_cxy = GET_CXY( ptd1_xp );
-
-    // get current ptd1 value
-    ptd1 = hal_remote_l32( ptd1_xp );
-
-    if( (ptd1 & TSAR_PTE_MAPPED) == 0)    // PTD1 unmapped and unlocked
-        {
-        // atomically lock the PTD1 to prevent concurrent PTD1 mappings
-        atomic = hal_remote_atomic_cas( ptd1_xp,
-                                        ptd1,
-                                        ptd1 | TSAR_PTE_LOCKED );
-
-        if( atomic )  // PTD1 successfully locked
-                {
-            // allocate one physical page for PT2
-            if( gpt_cxy == local_cxy )
-            {
-                    kmem_req_t req;
-                    req.type  = KMEM_PAGE;
-                    req.size  = 0;                     // 1 small page 
-                    req.flags = AF_KERNEL | AF_ZERO;
-                    page = (page_t *)kmem_alloc( &req );
-            }
-            else
-            {
-                rpc_pmem_get_pages_client( gpt_cxy , 0 , &page );
-            }
-
-            if( page == NULL ) return -1;
-
-            // get the PT2 PPN
-            page_xp = XPTR( gpt_cxy , page );        
-            pt2_ppn = ppm_page2ppn( page_xp );
-
-            // build  PTD1
-            ptd1 = TSAR_PTE_MAPPED | TSAR_PTE_SMALL | pt2_ppn;
-
-            // set the PTD1 value in PT1
-            hal_remote_s32( ptd1_xp , ptd1 );
-            hal_fence();
-
-#if DEBUG_HAL_GPT_ALLOCATE_PT2
-thread_t * this  = CURRENT_THREAD;
-uint32_t   cycle = (uint32_t)hal_get_cycles();
-if( DEBUG_HAL_GPT_ALLOCATE_PT2 < cycle )
-printk("\n[%s] : thread[%x,%x] map PTD1 / cxy %x / ix1 %d / pt1 %x / ptd1 %x\n", 
-__FUNCTION__, this->process->pid, this->trdid, gpt_cxy, ix1, pt1_ptr, ptd1 );
-#endif
-        }
-        else         // PTD1 modified by another thread 
-        {
-            // poll PTD1 until mapped by another thread
-            while( (ptd1 & TSAR_PTE_MAPPED) == 0 )  ptd1 = hal_remote_l32( ptd1_xp );
-        } 
-    }
-    else                                   // PTD1 mapped => just use it
-    {
-
-#if DEBUG_HAL_GPT_ALLOCATE_PT2
-thread_t * this  = CURRENT_THREAD;
-uint32_t   cycle = (uint32_t)hal_get_cycles();
-if( DEBUG_HAL_GPT_ALLOCATE_PT2 < cycle )
-printk("\n[%s] : thread[%x,%x] PTD1 mapped / cxy %x / ix1 %d / pt1 %x / ptd1 %x\n", 
-__FUNCTION__, this->process->pid, this->trdid, gpt_cxy, ix1, pt1_ptr, ptd1 );
-#endif
-
-    }
-
-    *ptd1_value = ptd1;
-    return 0;
-
-}  // end hal_gpt_allocate_pt2
-
-
-
-
 ////////////////////////////////////////////
 error_t hal_gpt_lock_pte( xptr_t     gpt_xp,
@@ -423 +332 @@
                           ppn_t    * ppn )
 {
-    error_t             error;
     uint32_t          * pt1_ptr;         // local pointer on PT1 base 
-    xptr_t              pte1_xp;         // extended pointer on PT1[x1] entry
-        uint32_t            pte1;            // value of PT1[x1] entry
+    xptr_t              ptd1_xp;         // extended pointer on PT1[x1] entry
+        uint32_t            ptd1;            // value of PT1[x1] entry
+
+    xptr_t              page_xp;
 
         ppn_t               pt2_ppn;         // PPN of page containing PT2
     uint32_t          * pt2_ptr;         // local pointer on PT2 base
-        xptr_t              pte2_attr_xp;    // extended pointer on PT2[ix2].attr
+        xptr_t              pte2_xp;         // extended pointer on PT2[ix2].attr
     uint32_t            pte2_attr;       // PT2[ix2].attr current value   
-        xptr_t              pte2_ppn_xp;     // extended pointer on PT2[ix2].ppn
     uint32_t            pte2_ppn;        // PT2[ix2].ppn current value   
         bool_t              atomic;
+
+#if GPT_LOCK_WATCHDOG
+    uint32_t count;
+#endif
 
     // get cluster and local pointer on GPT
@@ -440 +353 @@
     gpt_t * gpt_ptr = GET_PTR( gpt_xp );
 
-    // get indexes in PTI & PT2
+#if DEBUG_HAL_GPT_LOCK_PTE
+thread_t * this  = CURRENT_THREAD;
+uint32_t   cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_HAL_GPT_LOCK_PTE < cycle )
+printk("\n[%s] : thread[%x,%x] enters / vpn %x in cluster %x / cycle %d\n", 
+__FUNCTION__, this->process->pid, this->trdid, vpn, gpt_cxy, cycle );
+#endif
+
+    // get indexes in PTI & PT2 from vpn
     uint32_t  ix1 = TSAR_MMU_IX1_FROM_VPN( vpn );    // index in PT1
     uint32_t  ix2 = TSAR_MMU_IX2_FROM_VPN( vpn );    // index in PT2
@@ -447 +368 @@
     pt1_ptr = hal_remote_lpt( XPTR( gpt_cxy , &gpt_ptr->ptr ) );
 
-    // build extended pointer on PTE1 == PT1[ix1]
-        pte1_xp = XPTR( gpt_cxy , &pt1_ptr[ix1] );
-
-    // get PTE1 value from PT1 
-    // allocate a new PT2 for this PTE1 if required
-    error = hal_gpt_allocate_pt2( pte1_xp , &pte1 );
-
-    if( error )
+    // build extended pointer on PTD1 == PT1[ix1]
+        ptd1_xp = XPTR( gpt_cxy , &pt1_ptr[ix1] );
+
+    // get current PT1 entry value
+    ptd1 = hal_remote_l32( ptd1_xp );
+
+    // If PTD1 is unmapped and unlocked, try to atomically lock this PT1 entry.
+    // This PTD1 lock prevent multiple concurrent PT2 allocations
+    // - only the thread that successfully locked the PTD1 allocates a new PT2
+    //   and updates the PTD1
+    // - all other threads simply wait until the missing PTD1 is mapped.
+
+    if( ptd1 == 0 )  
+        {
+        // try to atomically lock the PTD1 to prevent concurrent PT2 allocations
+        atomic = hal_remote_atomic_cas( ptd1_xp,
+                                        ptd1,
+                                        ptd1 | TSAR_PTE_LOCKED );
+        if( atomic )  
+                {
+            // allocate one 4 Kbytes physical page for PT2
+            page_xp = ppm_remote_alloc_pages( gpt_cxy , 0 );
+
+            if( page_xp == NULL )
+            {
+                printk("\n[ERROR] in %s : cannot allocate memory for PT2\n", __FUNCTION__ );
+                return -1;
+            }
+
+            // get the PT2 PPN
+            pt2_ppn = ppm_page2ppn( page_xp );
+
+            // build  PTD1
+            ptd1 = TSAR_PTE_MAPPED | TSAR_PTE_SMALL | pt2_ppn;
+
+            // set the PTD1 value in PT1
+            // this unlocks the PTD1
+            hal_remote_s32( ptd1_xp , ptd1 );
+            hal_fence();
+
+#if (DEBUG_HAL_GPT_LOCK_PTE & 1)
+if( DEBUG_HAL_GPT_LOCK_PTE < cycle )
+printk("\n[%s] : thread[%x,%x] allocates a new PT2 for vpn %x in cluster %x\n", 
+__FUNCTION__, this->process->pid, this->trdid, vpn, gpt_cxy );
+#endif
+
+        }  // end if atomic
+    }  // end if (ptd1 == 0)
+
+    // wait until PTD1 is mapped by another thread
+    while( (ptd1 & TSAR_PTE_MAPPED) == 0 )
     {
-        printk("\n[ERROR] in %s : cannot allocate memory for PT2\n", __FUNCTION__ );
-        return -1;
+        ptd1 = hal_remote_l32( ptd1_xp );
+
+#if GPT_LOCK_WATCHDOG
+if( count > GPT_LOCK_WATCHDOG )  
+{
+    thread_t * thread = CURRENT_THREAD;
+    printk("\n[PANIC] in %s : thread[%x,%x] waiting PTD1 / vpn %x / cxy %x / %d iterations\n",
+    __FUNCTION__, thread->process->pid, thread->trdid, vpn, gpt_cxy, count );
+    hal_core_sleep();
+}
+count++;
+#endif
+
     }
 
-    if( (pte1 & TSAR_PTE_SMALL) == 0 )
-    {
-        printk("\n[ERROR] in %s : cannot lock a small page\n", __FUNCTION__ );
-        return -1;
-    }
-
-    // get pointer on PT2 base from PTE1 
-        pt2_ppn = TSAR_MMU_PTBA_FROM_PTE1( pte1 );
+// check ptd1 because only small page can be locked
+assert( (ptd1 & TSAR_PTE_SMALL), "cannot lock a big page\n");
+
+#if (DEBUG_HAL_GPT_LOCK_PTE & 1)
+if( DEBUG_HAL_GPT_LOCK_PTE < cycle )
+printk("\n[%s] : thread[%x,%x] get ptd1 %x for vpn %x in cluster %x\n", 
+__FUNCTION__, this->process->pid, this->trdid, ptd1, vpn, gpt_cxy );
+#endif
+
+    // get pointer on PT2 base from PTD1 
+        pt2_ppn = TSAR_MMU_PTBA_FROM_PTE1( ptd1 );
         pt2_ptr = GET_PTR( ppm_ppn2base( pt2_ppn ) );
 
-    // build extended pointers on PT2[ix2].attr and PT2[ix2].ppn 
-    pte2_attr_xp = XPTR( gpt_cxy , &pt2_ptr[2 * ix2] );
-    pte2_ppn_xp  = XPTR( gpt_cxy , &pt2_ptr[2 * ix2 + 1] );
- 
-    // wait until PTE2 unlocked, get PTE2.attr and set lock
+    // build extended pointers on PT2[ix2].attr  
+    pte2_xp = XPTR( gpt_cxy , &pt2_ptr[2 * ix2] );
+
+    // wait until PTE2 atomically set using a remote CAS
     do
     {
-        // busy waiting until TSAR_MMU_LOCK == 0
+
+#if GPT_LOCK_WATCHDOG
+count = 0;
+#endif
+
+        // wait until PTE lock released by the current owner
         do
                 {
-                        pte2_attr = hal_remote_l32( pte2_attr_xp );
+                        pte2_attr = hal_remote_l32( pte2_xp );
+
+#if GPT_LOCK_WATCHDOG
+if( count > GPT_LOCK_WATCHDOG )  
+{
+    thread_t * thread = CURRENT_THREAD;
+    printk("\n[PANIC] in %s : thread[%x,%x] waiting PTE2 / vpn %x / cxy %x / %d iterations\n",
+    __FUNCTION__, thread->process->pid, thread->trdid, vpn, gpt_cxy, count );
+    hal_core_sleep();
+}
+count++;
+#endif
+      
                 }
         while( (pte2_attr & TSAR_PTE_LOCKED) != 0 );
 
-        // try to atomically set the TSAR_MMU_LOCK attribute    
-                atomic = hal_remote_atomic_cas( pte2_attr_xp,
+        // try to atomically set the TSAR_PTE_LOCKED attribute    
+                atomic = hal_remote_atomic_cas( pte2_xp,
                                         pte2_attr,
                                         (pte2_attr | TSAR_PTE_LOCKED) );
@@ -492 +486 @@
 
     // get PTE2.ppn
-    pte2_ppn = hal_remote_l32( pte2_ppn_xp );
+    pte2_ppn = hal_remote_l32( pte2_xp + 4 );
+
+#if DEBUG_HAL_GPT_LOCK_PTE
+cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_HAL_GPT_LOCK_PTE < cycle )
+printk("\n[%s] : thread[%x,%x] exit / vpn %x in cluster %x / attr %x / ppn %x / cycle %d\n", 
+__FUNCTION__, this->process->pid, this->trdid, vpn, gpt_cxy, pte2_attr, pte2_ppn, cycle );
+#endif
+    
+    // return PPN and GPT attributes
+    *ppn  = pte2_ppn & ((1<<TSAR_MMU_PPN_WIDTH)-1);
+    *attr = tsar2gpt( pte2_attr );
+        return 0;
+
+}  // end hal_gpt_lock_pte()
+
+////////////////////////////////////////
+void hal_gpt_unlock_pte( xptr_t  gpt_xp,
+                         vpn_t   vpn )
+{
+    uint32_t * pt1_ptr;         // local pointer on PT1 base
+    xptr_t     ptd1_xp;         // extended pointer on PT1[ix1]
+        uint32_t   ptd1;            // value of PT1[ix1] entry
+
+        ppn_t      pt2_ppn;         // PPN of page containing PT2
+    uint32_t * pt2_ptr;         // PT2 base address
+        xptr_t     pte2_xp;         // extended pointer on PT2[ix2].attr 
+        uint32_t   pte2_attr;       // PTE2 attribute
+
+    // get cluster and local pointer on GPT
+    cxy_t   gpt_cxy = GET_CXY( gpt_xp );
+    gpt_t * gpt_ptr = GET_PTR( gpt_xp );
 
 #if DEBUG_HAL_GPT_LOCK_PTE
@@ -498 +523 @@
 uint32_t   cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_HAL_GPT_LOCK_PTE < cycle )
-printk("\n[%s] : thread[%x,%x] locks vpn %x / attr %x / ppn %x / cluster %x / cycle %d\n", 
-__FUNCTION__, this->process->pid, this->trdid, vpn, attr, ppn, gpt_cxy, cycle );
-#endif
-    
-    // return PPN and GPT attributes
-    *ppn  = hal_remote_l32( pte2_ppn_xp ) & ((1<<TSAR_MMU_PPN_WIDTH)-1);
-    *attr = tsar2gpt( pte2_attr );
-        return 0;
-
-}  // end hal_gpt_lock_pte()
-
-////////////////////////////////////////
-void hal_gpt_unlock_pte( xptr_t  gpt_xp,
-                         vpn_t   vpn )
-{
-    uint32_t * pt1_ptr;         // local pointer on PT1 base
-    xptr_t     pte1_xp;         // extended pointer on PT1[ix1]
-        uint32_t   pte1;            // value of PT1[ix1] entry
-
-        ppn_t      pt2_ppn;         // PPN of page containing PT2
-    uint32_t * pt2_ptr;         // PT2 base address
-        uint32_t   pte2_attr_xp;    // extended pointer on PT2[ix2].attr
-
-        uint32_t   attr;            // PTE2 attribute
-
-    // get cluster and local pointer on GPT
-    cxy_t   gpt_cxy = GET_CXY( gpt_xp );
-    gpt_t * gpt_ptr = GET_PTR( gpt_xp );
+printk("\n[%s] : thread[%x,%x] enters for vpn %x in cluster %x / cycle %d\n", 
+__FUNCTION__, this->process->pid, this->trdid, vpn, gpt_cxy, cycle );
+#endif
 
     // compute indexes in P1 and PT2
@@ -534 +534 @@
     pt1_ptr = hal_remote_lpt( XPTR( gpt_cxy , &gpt_ptr->ptr ) );
 
-    // build extended pointer on PTE1 == PT1[ix1]
-        pte1_xp = XPTR( gpt_cxy , &pt1_ptr[ix1] );
-
-    // get current pte1 value
-    pte1 = hal_remote_l32( pte1_xp );
-
-// check PTE1 attributes
-assert( (((pte1 & TSAR_PTE_MAPPED) != 0) && ((pte1 & TSAR_PTE_SMALL) != 0)),
-"try to unlock a big or unmapped PTE1\n");
-
-    // get pointer on PT2 base from PTE1 
-        pt2_ppn = TSAR_MMU_PTBA_FROM_PTE1( pte1 );
+    // build extended pointer on PTD1 == PT1[ix1]
+        ptd1_xp = XPTR( gpt_cxy , &pt1_ptr[ix1] );
+
+    // get current ptd1 value
+    ptd1 = hal_remote_l32( ptd1_xp );
+
+// check PTD1 attributes
+assert( ((ptd1 & TSAR_PTE_MAPPED) != 0), "unmapped PTE1\n");
+assert( ((ptd1 & TSAR_PTE_SMALL ) != 0), "big page PTE1\n");
+
+    // get pointer on PT2 base from PTD1 
+        pt2_ppn = TSAR_MMU_PTBA_FROM_PTE1( ptd1 );
         pt2_ptr = GET_PTR( ppm_ppn2base( pt2_ppn ) );
 
     // build extended pointers on PT2[ix2].attr  
-    pte2_attr_xp = XPTR( gpt_cxy , &pt2_ptr[2 * ix2] );
+    pte2_xp = XPTR( gpt_cxy , &pt2_ptr[2 * ix2] );
 
     // get PT2[ix2].attr
-    attr = hal_remote_l32( pte2_attr_xp );
-
-    // reset TSAR_MMU_LOCK attribute
-    hal_remote_s32( pte2_attr_xp , attr & ~TSAR_PTE_LOCKED );
+    pte2_attr = hal_remote_l32( pte2_xp );
+
+// check PTE2 attributes
+assert( ((pte2_attr & TSAR_PTE_MAPPED) != 0), "unmapped PTE2\n");
+assert( ((pte2_attr & TSAR_PTE_LOCKED) != 0), "unlocked PTE2\n");
+
+    // reset TSAR_PTE_LOCKED attribute 
+    hal_remote_s32( pte2_xp , pte2_attr & ~TSAR_PTE_LOCKED );
 
 #if DEBUG_HAL_GPT_LOCK_PTE
-thread_t * this  = CURRENT_THREAD;
-uint32_t   cycle = (uint32_t)hal_get_cycles();
+cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_HAL_GPT_LOCK_PTE < cycle )
-printk("\n[%s] : thread[%x,%x] unlocks vpn %x / attr %x / ppn %x / cluster %x / cycle %d\n", 
-__FUNCTION__, this->process->pid, this->trdid, vpn, attr, ppn, gpt_cxy, cycle );
-#endif
-  
+printk("\n[%s] : thread[%x,%x] unlocks vpn %x in cluster %x / cycle %d\n", 
+__FUNCTION__, this->process->pid, this->trdid, vpn, gpt_cxy, cycle );
+#endif
+
 }  // end hal_gpt_unlock_pte()
+
 
 ///////////////////////////////////////
@@ -693 +697 @@
     xptr_t     pte2_attr_xp;   // extended pointer on PT2[ix2].attr
     xptr_t     pte2_ppn_xp;    // extended pointer on PT2[ix2].ppn
-    uint32_t   pte2_attr;      // current value of PT2[ix2].attr
 
     // get cluster and local pointer on GPT
@@ -1065 +1068 @@
         ppn_t               pt2_ppn;             // PPN of PT2
         uint32_t          * pt2;                 // PT2 base address
+    xptr_t              pte2_xp;             // exended pointer on PTE2
 
     uint32_t            ix1;                 // index in PT1
     uint32_t            ix2;                 // index in PT2
 
+
     uint32_t            tsar_attr;           // PTE attributes for TSAR MMU
 
-    // check attr argument MAPPED and SMALL 
-    if( (attr & GPT_MAPPED) == 0 )  return;
-    if( (attr & GPT_SMALL ) == 0 )  return;
+// check MAPPED, SMALL, and not LOCKED in attr argument
+assert( ((attr & GPT_MAPPED) != 0), "attribute MAPPED must be set in new attributes\n" );
+assert( ((attr & GPT_SMALL ) != 0), "attribute SMALL  must be set in new attributes\n" );
+assert( ((attr & GPT_LOCKED) == 0), "attribute LOCKED must not be set in new attributes\n" );
 
     // get cluster and local pointer on remote GPT
@@ -1092 +1098 @@
     pte1 = hal_remote_l32( XPTR( gpt_cxy , &pt1[ix1] ) );
 
-    if( (pte1 & TSAR_PTE_MAPPED) == 0 ) return;
-    if( (pte1 & TSAR_PTE_SMALL ) == 0 ) return;
+// check MAPPED and SMALL in target PTE1
+assert( ((pte1 & GPT_MAPPED) != 0), "attribute MAPPED must be set in target PTE1\n" );
+assert( ((pte1 & GPT_SMALL ) != 0), "attribute SMALL  must be set in target PTE1\n" );
 
     // get PT2 base from PTE1 
@@ -1099 +1106 @@
     pt2     = GET_PTR( ppm_ppn2base( pt2_ppn ) );
 
+    // get extended pointer on PTE2
+    pte2_xp = XPTR( gpt_cxy , &pt2[2*ix2] );
+    
+// check MAPPED in target PTE2
+assert( ((hal_remote_l32(pte2_xp) & GPT_MAPPED) != 0),
+"attribute MAPPED must be set in target PTE2\n" );
+
     // set PTE2 in this order
-        hal_remote_s32( XPTR( gpt_cxy, &pt2[2 * ix2 + 1] ) , ppn );
+        hal_remote_s32( pte2_xp     , ppn );
         hal_fence();
-        hal_remote_s32( XPTR( gpt_cxy, &pt2[2 * ix2]     ) , tsar_attr );
+        hal_remote_s32( pte2_xp + 4 , tsar_attr );
         hal_fence();
 
@@ -1110 +1124 @@
 
 
-/* unused until now (march 2019) [AG]
-
-//////////////////////////////////////
-void hal_gpt_reset_range( gpt   * gpt,
-                          vpn_t   vpn_min,
-                          vpn_t   vpn_max )
-{
-    vpn_t      vpn;         // current vpn
-
-    uint32_t * pt1;         // PT1 base address
-    uint32_t   pte1;        // PT1 entry value
-
-    ppn_t      pt2_ppn;     // PPN of PT2 
-    uint32_t * pt2;         // PT2 base address
-
-    uint32_t   ix1;         // index in PT1
-    uint32_t   ix2;         // index in PT2
-
-    // get PT1
-    pt1 = gpt->ptr;
-
-    // initialize current index
-    vpn = vpn_min;
-
-    // loop on pages
-    while( vpn <= vpn_max )
-    {
-        // get ix1 index from vpn
-        ix1 = TSAR_MMU_IX1_FROM_VPN( vpn );
-
-        // get PTE1
-        pte1 = pt1[ix1]
-
-            if( (pte1 & TSAR_PTE_MAPPED) == 0 )     // PT1[ix1] unmapped 
-        {
-            // update vpn (next big page)
-            (vpn = ix1 + 1) << 9;
-        }
-            if( (pte1 & TSAR_PTE_SMALL) == 0 )      // it's a PTE1 (big page)
-            {
-            // unmap the big page
-            pt1[ix1] = 0;
-                hal_fence();
-            
-            // update vpn (next big page)
-            (vpn = ix1 + 1) << 9;
-        }
-        else                                    // it's a PTD1 (small page)
-        {
-            // compute PT2 base address
-            pt2_ppn = TSAR_MMU_PTBA_FROM_PTE1( pte1 );
-            pt2     = GET_PTR( ppm_ppn2base( pt2_ppn ) );
-
-            // get ix2 index from vpn
-            ix2 = TSAR_MMU_IX2_FROM_VPN( vpn );
-
-            // unmap the small page
-            pt2[2*ix2]   = 0;          
-            hal_fence();        
-
-            // update vpn (next small page)
-            vpn++;
-        }
-    }
-}  // hal_gpt_reset_range()
-*/
-
-
+

trunk/hal/tsar_mips32/core/hal_irqmask.c

@@ -33 +33 @@
         __asm__ volatile 
                 (".set noat                          \n"
-         "mfc0   $1,     $12                 \n"
-                 "or     %0,     $0,     $1          \n"
+         "mfc0   $1,     $12                 \n"   /* $1    <= c0_sr        */
+                 "or     %0,     $0,     $1          \n"   /* old   <= $1           */
                  "srl    $1,     $1,     1           \n"
-                 "sll    $1,     $1,     1           \n"
-                 "mtc0   $1,     $12                 \n"
+                 "sll    $1,     $1,     1           \n"   /* clear IE bit in $1    */
+                 "mtc0   $1,     $12                 \n"   /* c0_sr <= $1           */
          ".set at                            \n"
                  : "=&r" (sr) );
@@ -51 +51 @@
         __asm__ volatile 
                 (".set noat                          \n"
-                 "mfc0   $1,     $12                 \n"
-                 "or     %0,     $0,     $1          \n"
-                 "ori    $1,     $1,     0xFF01      \n"
-                 "mtc0   $1,     $12                 \n"
+                 "mfc0   $1,     $12                 \n"   /* s1    <= c0_sr        */
+                 "or     %0,     $0,     $1          \n"   /* old   <= $1           */
+                 "ori    $1,     $1,     0x1         \n"   /* set IE bit in $1      */
+                 "mtc0   $1,     $12                 \n"   /* c0_sr <= $1           */
          ".set at                            \n"
                  : "=&r" (sr) );

trunk/hal/tsar_mips32/core/hal_ppm.c

@@ -2 +2 @@
  * hal_ppm.c - Generic Physical Page Manager API implementation for TSAR
  *
- * Authors  Alain Greiner (2016,2017,2018)
+ * Authors  Alain Greiner (2016,2017,2018,2019)
  *
  * Copyright (c) UPMC Sorbonne Universites
@@ -60 +60 @@
 
         // initialize lock protecting the free_pages[] lists
-        busylock_init( &ppm->free_lock , LOCK_PPM_FREE );
+        remote_busylock_init( XPTR( local_cxy , &ppm->free_lock ) , LOCK_PPM_FREE );
 
         // initialize lock protecting the dirty_pages list
@@ -117 +117 @@
 
         // check consistency
-        return ppm_assert_order( ppm );
+        return  ppm_assert_order();
 
 }  // end hal_ppm_init()

trunk/kernel/kern/dqdt.c

@@ -373 +373 @@
 // It traverses the quad tree from clusters to root.
 ///////////////////////////////////////////////////////////////////////////
-// @ node       : extended pointer on current node
+// @ node_xp    : extended pointer on current node
 // @ increment  : number of pages variation
 ///////////////////////////////////////////////////////////////////////////
-static void dqdt_propagate_pages( xptr_t  node,
+static void dqdt_propagate_pages( xptr_t  node_xp,
                                   int32_t increment )
 {
     // get current node cluster identifier and local pointer
-    cxy_t         cxy = GET_CXY( node );
-    dqdt_node_t * ptr = GET_PTR( node );
+    cxy_t         node_cxy = GET_CXY( node_xp );
+    dqdt_node_t * node_ptr = GET_PTR( node_xp );
 
     // update current node pages number
-    hal_remote_atomic_add( XPTR( cxy , &ptr->pages ) , increment );
+    hal_remote_atomic_add( XPTR( node_cxy , &node_ptr->pages ) , increment );
 
     // get extended pointer on parent node
-    xptr_t parent = (xptr_t)hal_remote_l64( XPTR( cxy , &ptr->parent ) );
+    xptr_t parent_xp = (xptr_t)hal_remote_l64( XPTR( node_cxy , &node_ptr->parent ) );
 
     // propagate if required
-    if ( parent != XPTR_NULL ) dqdt_propagate_pages( parent, increment );
-}
-
-///////////////////////////////////////////
-void dqdt_increment_pages( uint32_t order )
-{
-        cluster_t   * cluster = LOCAL_CLUSTER;
-    dqdt_node_t * node    = &cluster->dqdt_tbl[0];
-
-    // update DQDT node level 0
-    hal_atomic_add( &node->pages , (1 << order) );
-
-    // propagate to DQDT upper levels
-    if( node->parent != XPTR_NULL ) dqdt_propagate_pages( node->parent , (1 << order) );
+    if ( parent_xp != XPTR_NULL ) dqdt_propagate_pages( parent_xp, increment );
+}
+
+////////////////////////////////////////
+void dqdt_increment_pages( cxy_t    cxy,
+                           uint32_t order )
+{
+    // get local pointer on node[0] (same in all clusters)
+    dqdt_node_t * node_ptr = &LOCAL_CLUSTER->dqdt_tbl[0];
+
+    // update DQDT node[0] in remote cluster cxy
+    hal_remote_atomic_add( XPTR( cxy , &node_ptr->pages ) , (1 << order) );
+
+    // get extended pointer on parent node in remote cluster cxy
+    xptr_t parent_xp = hal_remote_l64( XPTR( cxy , &node_ptr->parent ) );
+
+     // propagate to DQDT upper levels
+    if( parent_xp != XPTR_NULL ) dqdt_propagate_pages( parent_xp , (1 << order) );
 
 #if DEBUG_DQDT_UPDATE_PAGES
@@ -409 +413 @@
 if( cycle > DEBUG_DQDT_UPDATE_PAGES )
 printk("\n[DBG] %s : thread %x in process %x / %x pages in cluster %x / cycle %d\n",
-__FUNCTION__, CURRENT_THREAD->trdid, CURRENT_THREAD->process->pid, node->pages, local_cxy, cycle );
-#endif
-
-}
-
-///////////////////////////////////////////
-void dqdt_decrement_pages( uint32_t order )
-{
-        cluster_t   * cluster = LOCAL_CLUSTER;
-    dqdt_node_t * node    = &cluster->dqdt_tbl[0];
-
-    // update DQDT node level 0
-    hal_atomic_add( &node->pages , -(1 << order) );
-
-    // propagate to DQDT upper levels
-    if( node->parent != XPTR_NULL ) dqdt_propagate_pages( node->parent , -(1 << order) );
+__FUNCTION__, CURRENT_THREAD->trdid, CURRENT_THREAD->process->pid,
+hal_remote_l32( XPTR( cxy , &node_ptr->pages ), cxy, cycle );
+#endif
+
+}
+
+////////////////////////////////////////
+void dqdt_decrement_pages( cxy_t    cxy,
+                           uint32_t order )
+{
+    // get local pointer on node[0] (same in all clusters)
+    dqdt_node_t * node_ptr = &LOCAL_CLUSTER->dqdt_tbl[0];
+
+    // update DQDT node[0] in remote cluster cxy
+    hal_remote_atomic_add( XPTR( cxy , &node_ptr->pages ) , -(1 << order) );
+
+    // get extended pointer on parent node in remote cluster cxy
+    xptr_t parent_xp = hal_remote_l64( XPTR( cxy , &node_ptr->parent ) );
+
+     // propagate to DQDT upper levels
+    if( parent_xp != XPTR_NULL ) dqdt_propagate_pages( parent_xp , -(1 << order) );
 
 #if DEBUG_DQDT_UPDATE_PAGES
@@ -430 +439 @@
 if( cycle > DEBUG_DQDT_UPDATE_PAGES )
 printk("\n[DBG] %s : thread %x in process %x / %x pages in cluster %x / cycle %d\n",
-__FUNCTION__, CURRENT_THREAD->trdid, CURRENT_THREAD->process->pid, node->pages, local_cxy, cycle );
+__FUNCTION__, CURRENT_THREAD->trdid, CURRENT_THREAD->process->pid,
+hal_remote_l32( XPTR( cxy , &node_ptr->pages ), cxy, cycle );
 #endif
 
@@ -478 +488 @@
 if( cycle > DEBUG_DQDT_UPDATE_THREADS )
 printk("\n[DBG] %s : thread %x in process %x / %d threads in cluster %x / cycle %d\n",
-__FUNCTION__, CURRENT_THREAD->trdid, CURRENT_THREAD->process->pid, node->threads, local_cxy, cycle );
+__FUNCTION__, CURRENT_THREAD->trdid, CURRENT_THREAD->process->pid, 
+node->threads, local_cxy, cycle );
 #endif
 
@@ -499 +510 @@
 if( cycle > DEBUG_DQDT_UPDATE_THREADS )
 printk("\n[DBG] %s : thread %x in process %x / %d threads in cluster %x / cycle %d\n",
-__FUNCTION__, CURRENT_THREAD->trdid, CURRENT_THREAD->process->pid, node->threads, local_cxy, cycle );
+__FUNCTION__, CURRENT_THREAD->trdid, CURRENT_THREAD->process->pid, 
+node->threads, local_cxy, cycle );
 #endif
 

trunk/kernel/kern/dqdt.h

@@ -105 +105 @@
 
 /****************************************************************************************
- * This local function updates the total number of pages in level 0 DQDT node,
- * and immediately propagates the variation to the DQDT upper levels.
+ * These two functions can be called by any thread running in any cluster.
+ * They increment/decrement the total number of 4 Kbytes pages allocated in a cluster
+ * identified by the <cxy> argument, as specified by the <order> argument. The level 0 
+ * DQDT node is udated, and this change is immediately propagated to upper levels.
  * They are called by PPM on each physical memory page allocation or release.
  ****************************************************************************************
- * @ order   : ln2( number of small pages )
+ * @ cxy     : target cluster identifier.
+ * @ order   : ln2( number of 4 Kbytes pages )
  ***************************************************************************************/
-void dqdt_increment_pages( uint32_t order );
-void dqdt_decrement_pages( uint32_t order );
+void dqdt_increment_pages( cxy_t    cxy , 
+                           uint32_t order );
+
+void dqdt_decrement_pages( cxy_t    cxy,
+                           uint32_t order );
 
 /****************************************************************************************

trunk/kernel/kern/kernel_init.c

@@ -133 +133 @@
 
     "CLUSTER_KCM",           //  1
-    "PPM_FREE",              //  2
-    "SCHED_STATE",           //  3
-    "VMM_STACK",             //  4
-    "VMM_MMAP",              //  5
-    "VFS_CTX",               //  6
-    "KCM_STATE",             //  7
-    "KHM_STATE",             //  8
-    "HTAB_STATE",            //  9
-
+    "SCHED_STATE",           //  2
+    "VMM_STACK",             //  3
+    "VMM_MMAP",              //  4
+    "VFS_CTX",               //  5
+    "KCM_STATE",             //  6
+    "KHM_STATE",             //  7
+    "HTAB_STATE",            //  8
+
+    "PPM_FREE",              //  9
     "THREAD_JOIN",           // 10
     "XHTAB_STATE",           // 11

trunk/kernel/kern/rpc.c

@@ -51 +51 @@
 rpc_server_t * rpc_server[RPC_MAX_INDEX] =
 {
-    &rpc_pmem_get_pages_server,            // 0
-    &rpc_pmem_release_pages_server,        // 1
-    &rpc_ppm_display_server,               // 2
+    &rpc_undefined,                        // 0
+    &rpc_undefined,                        // 1
+    &rpc_undefined,                        // 2
     &rpc_process_make_fork_server,         // 3
     &rpc_user_dir_create_server,           // 4
@@ -87 +87 @@
 char * rpc_str[RPC_MAX_INDEX] =
 {
-    "PMEM_GET_PAGES",            // 0
-    "PMEM_RELEASE_PAGES",        // 1
-    "PPM_DISPLAY",               // 2
+    "undefined_0",               // 0
+    "undefined_1",               // 1
+    "undefined_2",               // 2
     "PROCESS_MAKE_FORK",         // 3
     "USER_DIR_CREATE",           // 4
@@ -423 +423 @@
 
 /////////////////////////////////////////////////////////////////////////////////////////
-// [0]           Marshaling functions attached to RPC_PMEM_GET_PAGES (blocking)
-/////////////////////////////////////////////////////////////////////////////////////////
-
+// [0]       RPC_PMEM_GET_PAGES deprecated [AG] May 2019
+/////////////////////////////////////////////////////////////////////////////////////////
+
+/*
 ///////////////////////////////////////////////
 void rpc_pmem_get_pages_client( cxy_t      cxy,
@@ -495 +496 @@
 #endif
 }
-
-/////////////////////////////////////////////////////////////////////////////////////////
-// [1]       Marshaling functions attached to RPC_PMEM_RELEASE_PAGES 
-/////////////////////////////////////////////////////////////////////////////////////////
-
+*/
+
+/////////////////////////////////////////////////////////////////////////////////////////
+// [1]       RPC_PMEM_RELEASE_PAGES deprecated [AG] may 2019
+/////////////////////////////////////////////////////////////////////////////////////////
+
+/*
 //////////////////////////////////////////////////
 void rpc_pmem_release_pages_client( cxy_t     cxy,
@@ -565 +568 @@
 #endif
 }
-
-/////////////////////////////////////////////////////////////////////////////////////////
-// [2]            Marshaling functions attached to RPC_PPM_DISPLAY    
-/////////////////////////////////////////////////////////////////////////////////////////
-
+*/
+
+/////////////////////////////////////////////////////////////////////////////////////////
+// [2]          RPC_PPM_DISPLAY deprecated [AG] May 2019    
+/////////////////////////////////////////////////////////////////////////////////////////
+
+/*
 /////////////////////////////////////////
 void rpc_ppm_display_client( cxy_t  cxy )
@@ -621 +626 @@
 #endif
 }
+*/
 
 /////////////////////////////////////////////////////////////////////////////////////////

trunk/kernel/kern/rpc.h

@@ -60 +60 @@
 typedef enum
 {
-    RPC_PMEM_GET_PAGES            = 0,
-    RPC_PMEM_RELEASE_PAGES        = 1,
-    RPC_PPM_DISPLAY               = 2,      
+    RPC_UNDEFINED_0               = 0,   // RPC_PMEM_GET_PAGES     deprecated [AG]
+    RPC_UNDEFINED_1               = 1,   // RPC_PMEM_RELEASE_PAGES deprecated [AG]
+    RPC_UNDEFINED_2               = 2,   // RPC_PMEM_DISPLAY       deprecated [AG]     
     RPC_PROCESS_MAKE_FORK         = 3,
     RPC_USER_DIR_CREATE           = 4,
@@ -177 +177 @@
  * [0] The RPC_PMEM_GET_PAGES allocates one or several pages in a remote cluster,
  * and returns the local pointer on the page descriptor.
+ *         deprecated [AG] may 2019
  ***********************************************************************************
  * @ cxy     : server cluster identifier
@@ -182 +183 @@
  * @ page    : [out] local pointer on page descriptor / NULL if failure
  **********************************************************************************/
+
+/*
 void rpc_pmem_get_pages_client( cxy_t             cxy,
                                 uint32_t          order,
@@ -187 +190 @@
 
 void rpc_pmem_get_pages_server( xptr_t xp );
+*/
 
 /***********************************************************************************
  * [1] The RPC_PMEM_RELEASE_PAGES release one or several pages to a remote cluster.
+ *         deprecated [AG] may 2019
  ***********************************************************************************
  * @ cxy     : server cluster identifier
  * @ page    : [in] local pointer on page descriptor to release.
  **********************************************************************************/
+
+/*
 void rpc_pmem_release_pages_client( cxy_t            cxy,
                                     struct page_s  * page );
 
 void rpc_pmem_release_pages_server( xptr_t xp );
+*/
 
 /***********************************************************************************
  * [2] The RPC_PPM_DISPLAY allows any client thread to require any remote cluster
  * identified by the <cxy> argumentto display the physical memory allocator state.
- **********************************************************************************/
+ *         deprecated [AG] may 2019
+ **********************************************************************************/
+
+/*
 void rpc_ppm_display_client( cxy_t  cxy );
 
 void rpc_ppm_display_server( xptr_t xp );
+*/
 
 /***********************************************************************************

trunk/kernel/kernel_config.h

@@ -95 +95 @@
 #define DEBUG_HAL_CONTEXT                 0
 #define DEBUG_HAL_EXCEPTIONS              0
-#define DEBUG_HAL_GPT_SET_PTE             0
 #define DEBUG_HAL_GPT_COPY                0
 #define DEBUG_HAL_GPT_CREATE              0
 #define DEBUG_HAL_GPT_DESTROY             0
+#define DEBUG_HAL_GPT_LOCK_PTE            0
+#define DEBUG_HAL_GPT_SET_PTE             0
 #define DEBUG_HAL_IOC_RX                  0
 #define DEBUG_HAL_IOC_TX                  0
@@ -140 +141 @@
 #define DEBUG_QUEUELOCK_CXY               0
 
-#define DEBUG_RPC_CLIENT_GENERIC          0
-#define DEBUG_RPC_SERVER_GENERIC          0
+#define DEBUG_RPC_CLIENT_GENERIC             21000000
+#define DEBUG_RPC_SERVER_GENERIC             21000000
 
 #define DEBUG_RPC_KCM_ALLOC               0
@@ -147 +148 @@
 #define DEBUG_RPC_MAPPER_HANDLE_MISS      0
 #define DEBUG_RPC_MAPPER_MOVE_USER        0
-#define DEBUG_RPC_PMEM_GET_PAGES          0
+#define DEBUG_RPC_PMEM_GET_PAGES             21000000
 #define DEBUG_RPC_PMEM_RELEASE_PAGES      0
 #define DEBUG_RPC_PROCESS_MAKE_FORK       0
@@ -254 +255 @@
 #define DEBUG_VMM_DESTROY                 0
 #define DEBUG_VMM_FORK_COPY               0
-#define DEBUG_VMM_GET_ONE_PPN             0
+#define DEBUG_VMM_GET_ONE_PPN                2
 #define DEBUG_VMM_GET_PTE                 0
-#define DEBUG_VMM_HANDLE_PAGE_FAULT       0
+#define DEBUG_VMM_HANDLE_PAGE_FAULT          2
 #define DEBUG_VMM_HANDLE_COW              0
 #define DEBUG_VMM_MMAP_ALLOC              0
-#define DEBUG_VMM_PAGE_ALLOCATE           0
+#define DEBUG_VMM_PAGE_ALLOCATE              2
 #define DEBUG_VMM_REMOVE_VSEG             0
 #define DEBUG_VMM_RESIZE_VSEG             0
@@ -276 +277 @@
 
 #define LOCK_CLUSTER_KCM       1   // local  (B)  protect dynamic KCM creation in cluster
-#define LOCK_PPM_FREE          2   // local  (B)  protect PPM allocator free_pages lists
-#define LOCK_SCHED_STATE       3   // local  (B)  protect scheduler state for given core
-#define LOCK_VMM_STACK         4   // local  (B)  protect VMM stack vseg allocator   
-#define LOCK_VMM_MMAP          5   // local  (B)  protect VMM mmap vseg allocator
-#define LOCK_VFS_CTX           6   // local  (B)  protect vfs context state
-#define LOCK_KCM_STATE         7   // local  (B)  protect KCM allocator state
-#define LOCK_KHM_STATE         8   // local  (B)  protect KHM allocator state
-#define LOCK_HTAB_STATE        9   // local  (B)  protect a local htab state
-
+#define LOCK_SCHED_STATE       2   // local  (B)  protect scheduler state for given core
+#define LOCK_VMM_STACK         3   // local  (B)  protect VMM stack vseg allocator   
+#define LOCK_VMM_MMAP          4   // local  (B)  protect VMM mmap vseg allocator
+#define LOCK_VFS_CTX           5   // local  (B)  protect vfs context state
+#define LOCK_KCM_STATE         6   // local  (B)  protect KCM allocator state
+#define LOCK_KHM_STATE         7   // local  (B)  protect KHM allocator state
+#define LOCK_HTAB_STATE        8   // local  (B)  protect a local htab state
+
+#define LOCK_PPM_FREE          9   // remote (B)  protect PPM allocator free_pages lists
 #define LOCK_THREAD_JOIN      10   // remote (B)  protect join/exit between two threads
 #define LOCK_XHTAB_STATE      11   // remote (B)  protect  a distributed xhtab state

trunk/kernel/libk/list.h

@@ -1 +1 @@
 /*
- * list.h - Double circular chained lists, inspired from linux
+ * list.h - Double circular linked list
  *
  * Authors Ghassan Almaless  (2008,2009,2010,2011,2012)
- *         Alain Greiner     (2016,2017,2018)
+ *         Alain Greiner     (2016,2017,2018i,2019)
  *
  * Copyright (c) UPMC Sorbonne Universites
@@ -28 +28 @@
 #include <kernel_config.h>
 #include <hal_kernel_types.h>
+#include <hal_remote.h>
 #include <printk.h>
 
@@ -34 +35 @@
 #endif
 
+
+////////////////////////////////////////////////////////////////////////////
+//          Double circular linked list functions & macros
+// 
+// It defines a generic local list, as all elements are in the same cluster.
+//
+// There is two sets of access functions, because these local lists can be
+// accessed by local threads, using local pointers, but they can also be 
+// accessed by remote threads running in any cluster, with specific access
+// functions using extended pointers.
+////////////////////////////////////////////////////////////////////////////
+
+/***************************************************************************
+ * This structure defines a Double Circular Linked List entry.
+ * Note : The list root is an extra list-entry_t, that is NOT part
+ *            of the set of linked elements.
+ **************************************************************************/
+
+typedef struct list_entry_s
+{
+        struct list_entry_s * next;
+        struct list_entry_s * pred;
+}
+list_entry_t;
 
 /***************************************************************************
@@ -46 +71 @@
 #endif
 
-////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////
-//          Double circular linked list functions & macros 
-////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////
-
-/***************************************************************************
- * This structure defines a Double Circular Linked List entry.
- * Note : The list root is an extra list-entry_t, that is NOT part
- *            of the set of linked elements.
- **************************************************************************/
-
-typedef struct list_entry_s
-{
-        struct list_entry_s * next;
-        struct list_entry_s * pred;
-}
-list_entry_t;
-
 /***************************************************************************
  * This macro returns a pointer on a structure containing a list_entry_t.
@@ -77 +83 @@
         (container_type *)( (char*)__member_ptr - OFFSETOF( container_type , member_name ));})
 
+
+////////////////////////////////////////////////////////////////////////////
+// These functions and macros mus be called by a thread running
+// in the local cluster to access the local list.
+////////////////////////////////////////////////////////////////////////////
+
 /***************************************************************************
  * This macro returns t pointer on the first element of a list. 
@@ -101 +113 @@
 /***************************************************************************
  * This macro traverse a rooted double linked list in forward order.
- * WARNING : Don't use 2 LIST_FOREACH in the same function, because the 
- * variable __ptr will be defined twice, wich result in a compilation error.
+ * WARNING : Don't use this macro when you want to remove one or several
+ * item(s) from the traversed list.     
  ***************************************************************************
  * @ root      : pointer on the root list_entry
@@ -149 +161 @@
 
 /***************************************************************************
- * This function inserts a new entry in first place of a double linked list.
+ * This function must be called by a thread running in local cluster.
+ * It inserts a new entry in first place of a double linked list.
  ***************************************************************************
  * @ root    : pointer on the list root
@@ -157 +170 @@
                                    list_entry_t * entry )
 {
-    list_entry_t * pred_entry;
-    list_entry_t * next_entry;
-  
-        pred_entry = root;
-        next_entry = root->next;
-        
-        entry->next = next_entry;
-        entry->pred = pred_entry;
-  
-        pred_entry->next = entry;
-        next_entry->pred = entry;
-}
-
-/***************************************************************************
- * This function inserts a new entry in last place of a double linked list.
+    list_entry_t * next = root->next;  
+
+        entry->next = next;
+        entry->pred = root;
+  
+        root->next = entry;
+        next->pred = entry;
+}
+
+/***************************************************************************
+ * This function must be called by a thread running in local cluster.
+ * It inserts a new entry in last place of a double linked list.
  ***************************************************************************
  * @ root    : pointer on the list root
@@ -179 +189 @@
                                   list_entry_t * entry )
 {
-    list_entry_t * pred_entry;
-    list_entry_t * next_entry;
-
-        pred_entry = root->pred;
-        next_entry = root;
-        
-        entry->next = next_entry;
-        entry->pred = pred_entry;
-  
-        pred_entry->next = entry;
-        next_entry->pred = entry;
-}
-
-/***************************************************************************
- * This function returns true if the list is empty.
+    list_entry_t * pred = root->pred;
+
+        entry->next = root;
+        entry->pred = pred;
+  
+        root->pred = entry;
+        pred->next = entry;
+}
+
+/***************************************************************************
+ * This function must be called by a thread running in local cluster.
+ * It returns true if the list is empty.
  ***************************************************************************
  * @ root    : pointer on the list root
@@ -202 +209 @@
 }
 
-/***************************************************************************
- * This function remove an entry from a rooted double linked list.
+
+/***************************************************************************
+ * This function must be called by a thread running in local cluster.
+ * It removes an entry from the list.
  ***************************************************************************
  * @ entry : pointer on the entry to be removed.
@@ -209 +218 @@
 static inline void list_unlink( list_entry_t * entry )
 {
-        list_entry_t * pred_entry;
-    list_entry_t * next_entry;
-
-        pred_entry = entry->pred;
-        next_entry = entry->next;
-
-        pred_entry->next = entry->next;
-        next_entry->pred = entry->pred;
+        list_entry_t * pred;
+    list_entry_t * next;
+
+        pred = entry->pred;
+        next = entry->next;
+
+        pred->next = next;
+        next->pred = pred;
 }
 
@@ -278 +287 @@
 
 
+
+////////////////////////////////////////////////////////////////////////////
+// These functions and macros can be used by any thread running
+// in any cluster to access a remote local list.
+////////////////////////////////////////////////////////////////////////////
+
+/***************************************************************************
+ * This macro can be used by a thread running in any cluster to access
+ * a remote local list. It returns a local pointer on the first element
+ * of the remote list in the remote cluster.
+ ***************************************************************************
+ * @ cxy     : remote list cluster identifier
+ * @ root    : local pointer on the list root
+ * @ type    : type of the linked element
+ * @ member  : name of the list_entry_t field
+ **************************************************************************/
+
+#define LIST_REMOTE_FIRST( cxy , root , type , member )                       \
+    ({ list_entry_t * __first = hal_remote_lpt( XPTR( cxy , &root->next ) );  \
+           LIST_ELEMENT( __first , type , member ); })
+
+/***************************************************************************
+ * This macro can be used by a thread running in any cluster to access
+ * a remote local list. It traverse the list in forward order.
+ * WARNING : Don't use this macro when you want to remove one or several
+ * item(s) from the traversed list.     
+ ***************************************************************************
+ * @ cxy     : remote list cluster identifier
+ * @ root    : pointer on the root list_entry
+ * @ iter    : pointer on the current list_entry
+ **************************************************************************/
+
+#define LIST_REMOTE_FOREACH( cxy , root , iter )               \
+for( (iter) = hal_remote_lpt( XPTR( cxy , &(root)->next ) ) ;  \
+     (iter) != (root) ;                         \
+     (iter) = hal_remote_lpt( XPTR( cxy , &(iter)->next ) ) ) 
+        
+/***************************************************************************
+ * This function can be called by a thread running in any cluster to access
+ * a remote local list. It returns true if the list is empty.
+ ***************************************************************************
+ * @ cxy     : remote list cluster identifier
+ * @ root    : local pointer on the remote list root
+ **************************************************************************/
+static inline bool_t list_remote_is_empty( cxy_t          cxy,
+                                           list_entry_t * root )
+{
+    list_entry_t * next = hal_remote_lpt( XPTR( cxy , &root->next ) );
+    return( root == next );
+}
+
+/***************************************************************************
+ * This function can be called by a thread running in any cluster to access
+ * a remote local list. It inserts a new entry in first place of the list.
+ ***************************************************************************
+ * @ cxy     : remote list cluster identifier
+ * @ root    : local pointer on the remote list root
+ * @ entry   : local pointer on the remote entry to be inserted
+ **************************************************************************/
+static inline void list_remote_add_first( cxy_t          cxy,
+                                          list_entry_t * root, 
+                                          list_entry_t * entry )
+{
+    list_entry_t * first;    // local pointer on current first entry
+    list_entry_t * next;     // local pointer on current first->next entry
+  
+        first  = hal_remote_lpt( XPTR( cxy , &root->next ) );
+    next   = hal_remote_lpt( XPTR( cxy , &first->next ) );
+        
+        hal_remote_spt( XPTR( cxy , &entry->next ) , first );
+        hal_remote_spt( XPTR( cxy , &entry->pred ) , root );
+  
+        hal_remote_spt( XPTR( cxy , &root->next ) , entry );
+        hal_remote_spt( XPTR( cxy , &next->pred ) , entry );
+}
+
+/***************************************************************************
+ * This function can be called by a thread running in any cluster to access
+ * a remote local list. It inserts a new entry in last place of the list.
+ ***************************************************************************
+ * @ cxy     : remote list cluster identifier
+ * @ root    : local pointer on the remote list root
+ * @ entry   : local pointer on the remote entry to be inserted
+ **************************************************************************/
+static inline void list_remote_add_last( cxy_t          cxy,
+                                         list_entry_t * root, 
+                                         list_entry_t * entry )
+{
+    list_entry_t * last;     // local pointer on current last entry
+    list_entry_t * pred;     // local pointer on current last->pred entry
+  
+        last   = hal_remote_lpt( XPTR( cxy , &root->pred ) );
+    pred   = hal_remote_lpt( XPTR( cxy , &last->pred ) );
+        
+        hal_remote_spt( XPTR( cxy , &entry->next ) , root );
+        hal_remote_spt( XPTR( cxy , &entry->pred ) , pred );
+  
+        hal_remote_spt( XPTR( cxy , &root->pred ) , entry );
+        hal_remote_spt( XPTR( cxy , &pred->next ) , entry );
+}
+
+/***************************************************************************
+ * This function can be called by a thread running in any cluster to access
+ * a remote local list. It removes an entry from the list.
+ ***************************************************************************
+ * @ cxy     : remote list cluster identifier
+ * @ entry   : pointer on the entry to be removed.
+ **************************************************************************/
+static inline void list_remote_unlink( cxy_t          cxy,
+                                       list_entry_t * entry )
+{
+        list_entry_t * pred;
+    list_entry_t * next;
+
+        pred = hal_remote_lpt( XPTR( cxy , &entry->pred ) );
+        next = hal_remote_lpt( XPTR( cxy , &entry->next ) );
+
+        hal_remote_spt( XPTR( cxy , &pred->next ) , next );
+        hal_remote_spt( XPTR( cxy , &next->pred ) , pred );
+}
+
+
+
 #endif  /* _LIST_H_ */

trunk/kernel/libk/remote_barrier.c

@@ -506 +506 @@
                                     uint32_t    nthreads )
 {
-    page_t        * dqt_page;
     xptr_t          dqt_page_xp;     
     page_t        * rpc_page;
@@ -514 +513 @@
     uint32_t        z;             // actual DQT size == max(x_size,y_size)
     uint32_t        levels;        // actual number of DQT levels
-    kmem_req_t      req;           // kmem request
     xptr_t          rpc_xp;        // extended pointer on RPC descriptors array
     rpc_desc_t    * rpc;           // pointer on RPC descriptors array
@@ -522 +520 @@
     uint32_t        y;             // Y coordinate in QDT mesh
     uint32_t        l;             // level coordinate
+    kmem_req_t      req;           // kmem request
 
     // compute size and number of DQT levels
@@ -554 +553 @@
     cxy_t          ref_cxy = GET_CXY( ref_xp );
 
-    // 1. allocate memory for DQT barrier descriptor in reference cluster
-    if( ref_cxy == local_cxy )                    
-     {
-        req.type     = KMEM_PAGE;
-        req.size     = 2;               // 4 pages == 16 Kbytes
-        req.flags    = AF_ZERO;
-        dqt_page     = kmem_alloc( &req );
-        dqt_page_xp  = XPTR( local_cxy , dqt_page );
-    }
-    else                                         
-    {
-        rpc_pmem_get_pages_client( ref_cxy,
-                                   2,
-                                   &dqt_page );
-        dqt_page_xp  = XPTR( ref_cxy , dqt_page );
-    }
-
-    if( dqt_page == NULL ) return NULL;
+    // 1. allocate 4 4 Kbytes pages for DQT barrier descriptor in reference cluster
+    dqt_page_xp = ppm_remote_alloc_pages( ref_cxy , 2 );
+
+    if( dqt_page_xp == XPTR_NULL ) return NULL;
 
     // get pointers on DQT barrier descriptor
@@ -948 +933 @@
 
     // 4. release memory allocated for barrier descriptor 
-    xptr_t   page_xp = ppm_base2page( barrier_xp );
-    page_t * page    = GET_PTR( page_xp );
-
-    if( barrier_cxy == local_cxy )                    
-    {
-        req.type      = KMEM_PAGE;
-        req.ptr       = page;
-        kmem_free( &req );
-    }
-    else                                         
-    {
-        rpc_pmem_release_pages_client( barrier_cxy,
-                                       page );
-    }
+    xptr_t   page_xp  = ppm_base2page( barrier_xp );
+    cxy_t    page_cxy = GET_CXY( page_xp );
+    page_t * page_ptr = GET_PTR( page_xp );
+
+    ppm_remote_free_pages( page_cxy , page_ptr );
 
 #if DEBUG_BARRIER_DESTROY

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.
  *********************************************************************************************

trunk/libs/libpthread/pthread.h

@@ -33 +33 @@
 /********************************************************************************************* 
  * This function creates a new user thread. The <user_attr> argument is a pointer
- * on a structure containing the thread attributes, defined in thread.h file.
+ * on a structure containing the thread attributes, defined in the shared_pthread.h file.
  *********************************************************************************************
  * @ trdid       : [out] buffer for created thread identifier in process.
- * @ user_attr   : [in]  pointer on thread attributes structure.
+ * @ attr        : [in]  pointer on user defined attributes structure.
  * @ start_func  : [in]  pointer on start function.
  * @ start_args  : [in]  pointer on start function arguments.