Changeset 412 for soft/giet_vm

Timestamp:

Sep 29, 2014, 11:59:30 AM (10 years ago)

Author:

alain

Message:

Major evolution: the page table initialisation has been
completely redesigned to support both big pages (2 Mbytes)
and small pages (4 Kbytes) for both kernel and user vsegs.

File:

• soft/giet_vm/giet_boot/boot.c (modified) (50 diffs)

soft/giet_vm/giet_boot/boot.c

@@ -1 @@
-//////////////////////////////////////////////////////////////////////////////////////////
+/////////////////////////////////////////////////////////////////////////////////////////
 // File     : boot.c
 // Date     : 01/11/2013
@@ -10 +10 @@
 // The virtual adresses are on 32 bits and use the (unsigned int) type. The 
 // physicals addresses can have up to 40 bits, and use the  (unsigned long long) type.
-// It natively supports clusterised shared mmemory multi-processors architectures, 
+// It natively supports clusterised shared memory multi-processors architectures, 
 // where each processor is identified by a composite index (cluster_xy, local_id),
 // and where there is one physical memory bank per cluster.
@@ -38 +38 @@
 //    - classical memory protection, when several independant applications compiled
 //      in different virtual spaces are executing on the same hardware platform.
-//    - data placement in NUMA architectures, when we want to control the placement 
-//      of the software objects (virtual segments) on the physical memory banks.
+//    - data placement in NUMA architectures, to control the placement 
+//      of the software objects (vsegs) on the physical memory banks (psegs).
 //
+//    The max number of vspaces (GIET_NB_VSPACE_MAX) is a configuration parameter.
 //    The page table are statically build in the boot phase, and they do not 
-//    change during execution. The GIET uses only 4 Kbytes pages.
-//    As most applications use only a limited number of segments, the number of PT2s 
-//    actually used by a given virtual space is generally smaller than 2048, and is
-//    computed during the boot phase.
-//    The max number of virtual spaces (GIET_NB_VSPACE_MAX) is a configuration parameter.
+//    change during execution. 
+//    The GIET_VM uses both small pages (4 Kbytes), and big pages (2 Mbytes). 
 //
 //    Each page table (one page table per virtual space) is monolithic, and contains 
-//    one PT1 and up to (GIET_NB_PT2_MAX) PT2s. The PT1 is addressed using the ix1 field
-//    (11 bits) of the VPN, and the selected PT2 is addressed using the ix2 field (9 bits).
-//    - PT1[2048] : a first 8K aligned array of unsigned int, indexed by (ix1) field of VPN. 
-//    Each entry in the PT1 contains a 32 bits PTD. The MSB bit PTD[31] is 
-//    the PTD valid bit, and LSB bits PTD[19:0] are the 20 MSB bits of the physical base
-//    address of the selected PT2.
-//    The PT1 contains 2048 PTD of 4 bytes => 8K bytes.
-//    - PT2[1024][GIET_NB_PT2_MAX] : an array of array of unsigned int. 
-//    Each PT2[1024] must be 4K aligned, each entry in a PT2 contains two unsigned int: 
-//    the first word contains the protection flags, and the second word contains the PPN.
-//    Each PT2 contains 512 PTE2 of 8bytes => 4K bytes.
-//    The total size of a page table is finally = 8K + (GIET_NB_PT2_MAX)*4K bytes.
+//    one PT1 (8 Kbytes) and a variable number of PT2s (4 Kbytes each). For each vspace,
+//    the numberof PT2s is defined by the size of the PTAB vobj in the mapping.
+//    The PT1 is indexed by the ix1 field (11 bits) of the VPN. Each entry is 32 bits.
+//    A PT2 is indexed the ix2 field (9 bits) of the VPN. Each entry is a double word. 
+//    The first word contains the flags, the second word contains the PPN.
+//
+//    The page tables can be distributed in all clusters.
 ///////////////////////////////////////////////////////////////////////////////////////
 // Implementation Notes:
@@ -66 +59 @@
 // 1) The cluster_id variable is a linear index in the mapping_info array of clusters. 
 //    We use the cluster_xy variable for the tological index = x << Y_WIDTH + y
+// 
 ///////////////////////////////////////////////////////////////////////////////////////
 
@@ -85 +79 @@
 #include <irq_handler.h>
 #include <vmem.h>
+#include <pmem.h>
 #include <utils.h>
 #include <elf-types.h>
@@ -128 +123 @@
 ////////////////////////////////////////////////////////////////////////////
 //      Global variables for boot code
-// Both the page tables for the various virtual spaces, and the schedulers
-// for the processors are physically distributed on the clusters.
 ////////////////////////////////////////////////////////////////////////////
 
 extern void boot_entry();
 
-// This global variable is allocated in "fat32.c" file
-extern fat32_fs_t fat;
-
-// Page tables virtual base addresses (one per vspace)
+// FAT internal representation for boot code  
 __attribute__((section (".bootdata"))) 
-unsigned int _ptabs_vaddr[GIET_NB_VSPACE_MAX];
-
-// Page tables physical base addresses (one per vspace / one per cluster)
-__attribute__((section (".bootdata"))) 
-paddr_t _ptabs_paddr[GIET_NB_VSPACE_MAX][X_SIZE][Y_SIZE];
-
-// Page table max_pt2 (one per vspace / one per cluster )
-__attribute__((section (".bootdata"))) 
-unsigned int _ptabs_max_pt2[GIET_NB_VSPACE_MAX][X_SIZE][Y_SIZE];
-
-// Page tables pt2 allocators (one per vspace / one per cluster)
-__attribute__((section (".bootdata"))) 
-unsigned int _ptabs_next_pt2[GIET_NB_VSPACE_MAX][X_SIZE][Y_SIZE];
-
-// Scheduler pointers array (virtual addresses)
-// indexed by (x,y,lpid) : (((x << Y_WIDTH) + y) * NB_PROCS_MAX) + lpid
-__attribute__((section (".bootdata"))) 
-static_scheduler_t* _schedulers[1<<X_WIDTH][1<<Y_WIDTH][NB_PROCS_MAX];
+fat32_fs_t             fat   __attribute__((aligned(512)));
 
 // Temporaty buffer used to load one complete .elf file  
 __attribute__((section (".bootdata"))) 
-char boot_elf_buffer[GIET_ELF_BUFFER_SIZE] __attribute__((aligned(512)));
+char                   boot_elf_buffer[GIET_ELF_BUFFER_SIZE] __attribute__((aligned(512)));
+
+// Physical memory allocators array (one per cluster)
+__attribute__((section (".bootdata"))) 
+pmem_alloc_t           boot_pmem_alloc[X_SIZE][Y_SIZE];
+
+// Schedulers virtual base addresses array (one per processor)
+__attribute__((section (".bootdata"))) 
+static_scheduler_t*    _schedulers[X_SIZE][Y_SIZE][NB_PROCS_MAX];
+
+// Page tables virtual base addresses array (one per vspace)
+__attribute__((section (".bootdata"))) 
+unsigned int           _ptabs_vaddr[GIET_NB_VSPACE_MAX][X_SIZE][Y_SIZE];
+
+// Page tables physical base addresses (one per vspace and per cluster)
+__attribute__((section (".bootdata"))) 
+paddr_t                _ptabs_paddr[GIET_NB_VSPACE_MAX][X_SIZE][Y_SIZE];
+
+// Page tables pt2 allocators (one per vspace and per cluster)
+__attribute__((section (".bootdata"))) 
+unsigned int           _ptabs_next_pt2[GIET_NB_VSPACE_MAX][X_SIZE][Y_SIZE];
+
+// Page tables max_pt2  (same value for all page tables)
+__attribute__((section (".bootdata"))) 
+unsigned int           _ptabs_max_pt2;
 
 /////////////////////////////////////////////////////////////////////
@@ -265 +262 @@
 } // end boot_mapping_check()
 
-
 //////////////////////////////////////////////////////////////////////////////
-//     boot_pseg_get() 
-// This function returns the pointer on a physical segment
-// identified  by the pseg index.
+// This function registers a new PTE1 in the page table defined
+// by the vspace_id argument, and the (x,y) coordinates.
+// It updates only the first level PT1.
 //////////////////////////////////////////////////////////////////////////////
-mapping_pseg_t *boot_pseg_get(unsigned int seg_id) 
+void boot_add_pte1( unsigned int vspace_id,
+                    unsigned int x,
+                    unsigned int y,
+                    unsigned int vpn,        // 20 bits right-justified
+                    unsigned int flags,      // 10 bits left-justified 
+                    unsigned int ppn )       // 28 bits right-justified
 {
-    mapping_header_t* header = (mapping_header_t*)SEG_BOOT_MAPPING_BASE;
-    mapping_pseg_t * pseg    = _get_pseg_base(header);
-
-    // checking argument
-    if (seg_id >= header->psegs) 
-    {
-        _puts("\n[BOOT ERROR] : seg_id argument too large\n");
-        _puts("               in function boot_pseg_get()\n");
+    // compute index in PT1
+    unsigned int    ix1 = vpn >> 9;         // 11 bits for ix1
+
+    // get page table physical base address 
+    paddr_t         pt1_pbase = _ptabs_paddr[vspace_id][x][y];
+
+    // check pt1_base
+    if ( pt1_pbase == 0 )
+    {
+        _puts("\n[BOOT ERROR] in boot_add_pte1() : illegal pbase address for PTAB[");
+        _putd( vspace_id );
+        _puts(",");
+        _putd( x );
+        _puts(",");
+        _putd( y );
+        _puts("]\n");
         _exit();
     }
 
-    return &pseg[seg_id];
-}  
+    // compute pte1 : 2 bits V T / 8 bits flags / 3 bits RSVD / 19 bits bppi
+    unsigned int    pte1 = PTE_V |
+                           (flags & 0x3FC00000) |
+                           ((ppn>>9) & 0x0007FFFF);
+
+    // write pte1 in PT1
+    _physical_write( pt1_pbase + 4*ix1, pte1 );
+
+#if (BOOT_DEBUG_PT > 1)
+_puts(" - PTE1 in PTAB[");
+_putd( vspace_id );
+_puts(",");
+_putd( x );
+_puts(",");
+_putd( y );
+_puts("] : vpn = ");
+_putx( vpn );
+_puts(" / ppn = ");
+_putx( ppn );
+_puts(" / flags = ");
+_putx( flags );
+_puts("\n");
+#endif
+
+}   // end boot_add_pte1()
 
 //////////////////////////////////////////////////////////////////////////////
-// boot_add_pte() 
-// This function registers a new PTE in the page table defined
+// This function registers a new PTE2 in the page table defined
 // by the vspace_id argument, and the (x,y) coordinates.
-// It updates both the PT1 and PT2, and a new PT2 is used if required.
+// It updates both the first level PT1 and the second level PT2.
 // As the set of PT2s is implemented as a fixed size array (no dynamic 
 // allocation), this function checks a possible overflow of the PT2 array.
 //////////////////////////////////////////////////////////////////////////////
-void boot_add_pte(unsigned int vspace_id,
-                  unsigned int x,
-                  unsigned int y,
-                  unsigned int vpn, 
-                  unsigned int flags, 
-                  unsigned int ppn,
-                  unsigned int verbose) 
+void boot_add_pte2( unsigned int vspace_id,
+                    unsigned int x,
+                    unsigned int y,
+                    unsigned int vpn,        // 20 bits right-justified
+                    unsigned int flags,      // 10 bits left-justified 
+                    unsigned int ppn )       // 28 bits right-justified
 {
     unsigned int ix1;
     unsigned int ix2;
     paddr_t      pt2_pbase;     // PT2 physical base address
-    paddr_t      pte_paddr;     // PTE physical address
+    paddr_t      pte2_paddr;    // PTE2 physical address
     unsigned int pt2_id;        // PT2 index
     unsigned int ptd;           // PTD : entry in PT1
 
-    ix1 = vpn >> 9;         // 11 bits
-    ix2 = vpn & 0x1FF;      //  9 bits
+    ix1 = vpn >> 9;             // 11 bits for ix1
+    ix2 = vpn & 0x1FF;          //  9 bits for ix2
 
     // get page table physical base address and size
     paddr_t      pt1_pbase = _ptabs_paddr[vspace_id][x][y];
-    unsigned int max_pt2   = _ptabs_max_pt2[vspace_id][x][y];
-
-    if (max_pt2 == 0) 
-    {
-        _puts("Undefined page table for vspace ");
-        _putd(vspace_id);
-        _puts("\n");
+
+    // check pt1_base
+    if ( pt1_pbase == 0 )
+    {
+        _puts("\n[BOOT ERROR] in boot_add_pte2() : PTAB[");
+        _putd( vspace_id );
+        _puts(",");
+        _putd( x );
+        _puts(",");
+        _putd( y );
+        _puts("] undefined\n");
         _exit();
     }
@@ -332 +366 @@
     {
         pt2_id = _ptabs_next_pt2[vspace_id][x][y];
-        if (pt2_id == max_pt2) 
-        {
-            _puts("\n[BOOT ERROR] in boot_add_pte() function\n");
-            _puts("the length of the PTAB vobj is too small\n");
-            _puts(" max_pt2 = ");
-            _putd( max_pt2 );
-            _puts("\n");
-            _puts(" pt2_id  = ");
-            _putd( pt2_id );
-            _puts("\n");
+        if (pt2_id == _ptabs_max_pt2) 
+        {
+            _puts("\n[BOOT ERROR] in boot_add_pte2() : PTAB[");
+            _putd( vspace_id );
+            _puts(",");
+            _putd( x );
+            _puts(",");
+            _putd( y );
+            _puts("] contains not enough PT2s\n");
             _exit();
         }
@@ -347 +380 @@
         pt2_pbase = pt1_pbase + PT1_SIZE + PT2_SIZE * pt2_id;
         ptd = PTE_V | PTE_T | (unsigned int) (pt2_pbase >> 12);
-        _physical_write( pt1_pbase + 4 * ix1, ptd);
+        _physical_write( pt1_pbase + 4*ix1, ptd);
         _ptabs_next_pt2[vspace_id][x][y] = pt2_id + 1;
     }
@@ -356 +389 @@
 
     // set PTE in PT2 : flags & PPN in two 32 bits words
-    pte_paddr = pt2_pbase + 8 * ix2;
-    _physical_write(pte_paddr    , flags);
-    _physical_write(pte_paddr + 4, ppn);
-
-    if (verbose)
-    {
-        _puts(" / vpn = ");
-        _putx( vpn );
-        _puts(" / ix1 = ");
-        _putx( ix1 );
-        _puts(" / ix2 = ");
-        _putx( ix2 );
-        _puts(" / pt1_pbase = ");
-        _putl( pt1_pbase );
-        _puts(" / ptd = ");
-        _putl( ptd );
-        _puts(" / pt2_pbase = ");
-        _putl( pt2_pbase );
-        _puts(" / pte_paddr = ");
-        _putl( pte_paddr );
-        _puts(" / ppn = ");
-        _putx( ppn );
-        _puts("/\n");
-    }
-
-}   // end boot_add_pte()
-
-
-////////////////////////////////////////////////////////////////////////
-// This function build the page table(s) for a given vspace. 
-// It build as many pages tables as the number of vobjs having
-// the PTAB type in the vspace, because page tables can be replicated.
-// The physical base addresses for all vsegs (global and private)
-// must have been previously computed and stored in the mapping.
-//
-// General rule regarding local / shared vsegs:
-// - shared vsegs are mapped in all page tables
-// - local vsegs are mapped only in the "local" page table
-////////////////////////////////////////////////////////////////////////
-void boot_vspace_pt_build(unsigned int vspace_id) 
-{
-    unsigned int ptab_id;       // global index for a vseg containing a PTAB
-    unsigned int priv_id;       // global index for a private vseg in a vspace
-    unsigned int glob_id;       // global index for a global vseg
-    unsigned int npages;
-    unsigned int ppn;
-    unsigned int vpn;
-    unsigned int flags;
-    unsigned int page_id;
-    unsigned int verbose = 0;   // can be used to activate trace in add_pte()
-
-    mapping_header_t  * header  = (mapping_header_t *)SEG_BOOT_MAPPING_BASE;
-    mapping_vspace_t  * vspace  = _get_vspace_base(header);
-    mapping_vseg_t    * vseg    = _get_vseg_base(header);
-    mapping_vobj_t    * vobj    = _get_vobj_base(header);
-    mapping_pseg_t    * pseg    = _get_pseg_base(header);
-    mapping_cluster_t * cluster = _get_cluster_base(header);
-
-    // external loop on private vsegs to find all PTAB vobjs in vspace
-    for (ptab_id = vspace[vspace_id].vseg_offset;
-         ptab_id < (vspace[vspace_id].vseg_offset + vspace[vspace_id].vsegs);
-         ptab_id++) 
-    {
-        // get global index of first vobj in vseg
-        unsigned int vobj_id = vseg[ptab_id].vobj_offset;
-
-        if ( vobj[vobj_id].type == VOBJ_TYPE_PTAB )
-        {
-            // get cluster coordinates for the PTAB
-            unsigned int ptab_pseg_id    = vseg[ptab_id].psegid;
-            unsigned int ptab_cluster_id = pseg[ptab_pseg_id].clusterid;
-            unsigned int x_ptab          = cluster[ptab_cluster_id].x;
-            unsigned int y_ptab          = cluster[ptab_cluster_id].y;
-
-            // internal loop on private vsegs to build 
-            // the (vspace_id, x_ptab, y_ptab) page table
-            for (priv_id = vspace[vspace_id].vseg_offset;
-                 priv_id < (vspace[vspace_id].vseg_offset + vspace[vspace_id].vsegs);
-                 priv_id++) 
-            {
-                // get cluster coordinates for private vseg 
-                unsigned int priv_pseg_id    = vseg[priv_id].psegid;
-                unsigned int priv_cluster_id = pseg[priv_pseg_id].clusterid;
-                unsigned int x_priv          = cluster[priv_cluster_id].x;
-                unsigned int y_priv          = cluster[priv_cluster_id].y;
-
-                // only non local or matching private vsegs must be mapped
-                if ( (vseg[priv_id].local == 0 ) ||
-                     ((x_ptab == x_priv) && (y_ptab == y_priv)) )
-                {
-                    vpn = vseg[priv_id].vbase >> 12;
-                    ppn = (unsigned int) (vseg[priv_id].pbase >> 12);
-                    npages = vseg[priv_id].length >> 12;
-                    if ((vseg[priv_id].length & 0xFFF) != 0) npages++; 
-
-                    flags = PTE_V;
-                    if (vseg[priv_id].mode & C_MODE_MASK) flags |= PTE_C;
-                    if (vseg[priv_id].mode & X_MODE_MASK) flags |= PTE_X;
-                    if (vseg[priv_id].mode & W_MODE_MASK) flags |= PTE_W;
-                    if (vseg[priv_id].mode & U_MODE_MASK) flags |= PTE_U;
-        
-                    // The three flags (Local, Remote and Dirty) are set to 1 to reduce
-                    // latency of TLB miss (L/R) and write (D): Avoid hardware update
-                    // mechanism for these flags because GIET_VM does use these flags.
-
-                    flags |= PTE_L;
-                    flags |= PTE_R;
-                    flags |= PTE_D;
-
-#if BOOT_DEBUG_PT
-_puts(vseg[priv_id].name);
-_puts(" : flags = ");
-_putx(flags);
-_puts(" / npages = ");
-_putd(npages);
-_puts(" / pbase = ");
-_putl(vseg[priv_id].pbase);
-_puts("\n");
-#endif
-                    // loop on 4K pages
-                    for (page_id = 0; page_id < npages; page_id++) 
-                    {
-                        boot_add_pte(vspace_id, x_ptab, y_ptab, vpn, flags, ppn, verbose);
-                        vpn++;
-                        ppn++;
-                    }
-                } 
-            }  // end internal loop on private vsegs
-
-            // internal loop on global vsegs to build the (x_ptab,y_ptab) page table
-            for (glob_id = 0; glob_id < header->globals; glob_id++) 
-            {
-                // get cluster coordinates for global vseg 
-                unsigned int glob_pseg_id    = vseg[glob_id].psegid;
-                unsigned int glob_cluster_id = pseg[glob_pseg_id].clusterid;
-                unsigned int x_glob          = cluster[glob_cluster_id].x;
-                unsigned int y_glob          = cluster[glob_cluster_id].y;
-
-                // only non local or matching global vsegs must be mapped
-                if ( (vseg[glob_id].local == 0 ) ||
-                     ((x_ptab == x_glob) && (y_ptab == y_glob)) )
-                {
-                    vpn = vseg[glob_id].vbase >> 12;
-                    ppn = (unsigned int)(vseg[glob_id].pbase >> 12);
-                    npages = vseg[glob_id].length >> 12;
-                    if ((vseg[glob_id].length & 0xFFF) != 0) npages++;
-
-                    flags = PTE_V;
-                    if (vseg[glob_id].mode & C_MODE_MASK) flags |= PTE_C;
-                    if (vseg[glob_id].mode & X_MODE_MASK) flags |= PTE_X;
-                    if (vseg[glob_id].mode & W_MODE_MASK) flags |= PTE_W;
-                    if (vseg[glob_id].mode & U_MODE_MASK) flags |= PTE_U;
-
-                    // Flags set for optimization (as explained above)
-
-                    flags |= PTE_L;
-                    flags |= PTE_R;
-                    flags |= PTE_D;
-
-#if BOOT_DEBUG_PT
-_puts(vseg[glob_id].name);
-_puts(" : flags = ");
-_putx(flags);
-_puts(" / npages = ");
-_putd(npages);
-_puts(" / pbase = ");
-_putl(vseg[glob_id].pbase);
-_puts("\n");
-#endif
-                    // loop on 4K pages
-                    for (page_id = 0; page_id < npages; page_id++) 
-                    {
-                        boot_add_pte(vspace_id, x_ptab, y_ptab, vpn, flags, ppn, verbose);
-                        vpn++;
-                        ppn++;
-                    }
-                }
-            }   // end internal loop on global vsegs
-
-            _puts("\n[BOOT] Page Table for vspace ");
-            _puts( vspace[vspace_id].name );
-            _puts(" in cluster[");
-            _putd( x_ptab );
-            _puts(",");
-            _putd( y_ptab );
-            _puts("] completed at cycle ");
-            _putd( _get_proctime() );
-            _puts("\n");
-
-#if BOOT_DEBUG_PT
-_puts("vaddr = ");
-_putx( _ptabs_vaddr[vspace_id] );
-_puts(" / paddr = ");
-_putl( _ptabs_paddr[vspace_id][x_ptab][y_ptab] );
-_puts(" / PT2 number = ");
-_putd( _ptabs_next_pt2[vspace_id][x_ptab][y_ptab] );
-_puts("\n");
-#endif
-
-        }  // end if PTAB
-    }  // end first loop on private vsegs
-}   // end boot_vspace_pt_build()
-
-
-///////////////////////////////////////////////////////////////////////////
+    pte2_paddr  = pt2_pbase + 8 * ix2;
+    _physical_write(pte2_paddr     , (PTE_V |flags) );
+    _physical_write(pte2_paddr + 4 , ppn);
+
+#if (BOOT_DEBUG_PT > 1)
+_puts(" - PTE2 in PTAB[");
+_putd( vspace_id );
+_puts(",");
+_putd( x );
+_puts(",");
+_putd( y );
+_puts("] : vpn = ");
+_putx( vpn );
+_puts(" / ppn = ");
+_putx( ppn );
+_puts(" / flags = ");
+_putx( flags );
+_puts("\n");
+#endif
+
+}   // end boot_add_pte2()
+
+////////////////////////////////////////////////////////////////////////////////////
 // Align the value of paddr or vaddr to the required alignement,
 // defined by alignPow2 == L2(alignement).
-///////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////////
 paddr_t paddr_align_to(paddr_t paddr, unsigned int alignPow2) 
 {
@@ -576 +427 @@
 }
 
-///////////////////////////////////////////////////////////////////////////
-// Set pbase for a vseg when identity mapping is required.
-// The length of the vseg must be known.
-// The ordered linked list of vsegs mapped on pseg is updated,
-// and overlap with previously mapped vsegs is checked.
-///////////////////////////////////////////////////////////////////////////
-void boot_vseg_set_paddr_ident(mapping_vseg_t * vseg) 
+/////////////////////////////////////////////////////////////////////////////////////
+// This function map a vseg identified by the vseg pointer.
+//
+// A given vseg can be mapped in Big Physical Pages (BPP: 2 Mbytes) or in a
+// Small Physical Pages (SPP: 4 Kbytes), depending on the "big" attribute of vseg,
+// with the following rules:
+// - SPP : There is only one vseg in a small physical page, but a single vseg
+//   can cover several contiguous small physical pages.
+// - BPP : It can exist several vsegs in a single big physical page, and a single
+//   vseg can cover several contiguous big physical pages.
+//
+// 1) First step: it computes the vseg length, and register it in vseg->length field.
+//    It computes - for each vobj - the actual vbase address, taking into
+//    account the alignment constraints and register it in vobj->vbase field.
+//
+// 2) Second step: it allocates the required number of physical pages, 
+//    computes the physical base address (if the vseg is not identity mapping),
+//    and register it in the vseg pbase field.
+//    Only the 4 vsegs used by the boot code and the peripheral vsegs
+//    can be identity mapping: The first big physical page in cluster[0,0] 
+//    is reserved for the 4 boot vsegs.
+//
+// 3) Third step (only for vseg that have the VOBJ_TYPE_PTAB): all page tables
+//    associated to the various vspaces must be packed in the same vseg.
+//    We divide the vseg in M sub-segments, and compute the vbase and pbase
+//    addresses for each page table, and register it in the _ptabs_paddr
+//    and _ptabs_vaddr arrays.
+//  
+/////////////////////////////////////////////////////////////////////////////////////
+void boot_vseg_map( mapping_vseg_t* vseg )
 {
-    // checking vseg not already mapped
-    if (vseg->mapped != 0) 
-    {
-        _puts("\n[BOOT ERROR] in boot_vseg_set_paddr_ident() : vseg ");
-        _puts( vseg->name );
-        _puts(" already mapped\n");
-        _exit();
-    }
-
-    // computes selected pseg pointer 
-    mapping_pseg_t* pseg = boot_pseg_get( vseg->psegid );
-
-    // computes vseg alignment constraint
-    mapping_header_t* header    = (mapping_header_t*)SEG_BOOT_MAPPING_BASE;
-    mapping_vobj_t*   vobj_base = _get_vobj_base( header );
-    unsigned int      align     = vobj_base[vseg->vobj_offset].align;
-    if ( vobj_base[vseg->vobj_offset].align < 12 ) align = 12;
-
-    // computes required_pbase for identity mapping,
-    paddr_t required_pbase = (paddr_t)vseg->vbase;
-
-    // checks identity constraint against alignment constraint
-    if ( paddr_align_to( required_pbase, align) != required_pbase )
-    {
-        _puts("\n[BOOT ERROR] in boot_vseg_set_paddr_ident() : vseg ");
-        _puts( vseg->name );
-        _puts(" has uncompatible identity and alignment constraints\n");
-        _exit();
-    }
-
-    // We are looking for a contiguous space in target pseg.
-    // If there is vsegs already mapped, we scan the vsegs list to: 
-    // - check overlap with already mapped vsegs,
-    // - try mapping in holes between already mapped vsegs,
-    // - update the ordered linked list if success
-    // We don't enter the loop if no vsegs is already mapped.
-    // implementation note: The next_vseg field is unsigned int,
-    // but we use it to store a MIP32 pointer on a vseg...
-
-    mapping_vseg_t*   curr      = 0;
-    mapping_vseg_t*   prev      = 0;
-    unsigned int      min_pbase = pseg->base;
-
-    for ( curr = (mapping_vseg_t*)pseg->next_vseg ; 
-          (curr != 0) && (vseg->mapped == 0) ; 
-          curr = (mapping_vseg_t*)curr->next_vseg )
-    {
-        // looking before current vseg
-        if( (required_pbase >= min_pbase) && 
-            (curr->pbase >= (required_pbase + vseg->length)) ) // space found
-        {
-            vseg->pbase  = required_pbase;
-            vseg->mapped = 1;
-
-            // update linked list
-            vseg->next_vseg = (unsigned int)curr;
-            if( curr == (mapping_vseg_t*)pseg->next_vseg ) 
-                pseg->next_vseg = (unsigned int)vseg;
-            else
-                prev->next_vseg = (unsigned int)vseg;
-        }
-        else                                         // looking in space after curr
-        {
-            prev = curr;
-            min_pbase = curr->pbase + curr->length;
-        }
-    }
-
-    // no success in the loop
-    if( (vseg->mapped == 0) &&
-        (required_pbase >= min_pbase) && 
-        ((required_pbase + vseg->length) <= (pseg->base + pseg->length)) )
-    {
-        vseg->pbase  = required_pbase;
-        vseg->mapped = 1;
-
-        // update linked list
-        vseg->next_vseg = 0;
-        if ((curr == 0) && (prev == 0)) pseg->next_vseg = (unsigned int)vseg;
-        else                            prev->next_vseg = (unsigned int)vseg;
-    }
-
-    if( vseg->mapped == 0 )
-    {
-        _puts("\n[BOOT ERROR] in boot_vseg_set_paddr_ident() : vseg ");
-        _puts( vseg->name );
-        _puts(" cannot be mapped on pseg ");
-        _puts( pseg->name );
-        _puts("\n");
-        _exit();
-    }
-}  // end boot_vseg_set_paddr_ident()
-
-                
-////////////////////////////////////////////////////////////////////////////
-// Set pbase for a vseg when there is no identity mapping constraint.
-// This is the physical memory allocator (written by Q.Meunier).
-// The length of the vseg must be known.
-// All identity mapping vsegs must be already mapped.
-// We use a linked list of already mapped vsegs, ordered by incresing pbase.
-// We try to place the vseg in the "first fit" hole in this list.
-////////////////////////////////////////////////////////////////////////////
-void boot_vseg_set_paddr(mapping_vseg_t * vseg) 
-{
-    // checking vseg not already mapped
-    if ( vseg->mapped != 0 ) 
-    {
-        _puts("\n[BOOT ERROR] in boot_vseg_set_paddr() : vseg ");
-        _puts( vseg->name );
-        _puts(" already mapped\n");
-        _exit();
-    }
-
-    // computes selected pseg pointer 
-    mapping_pseg_t*   pseg      = boot_pseg_get( vseg->psegid );
-
-    // computes vseg alignment constraint
-    mapping_header_t* header    = (mapping_header_t*)SEG_BOOT_MAPPING_BASE;
-    mapping_vobj_t*   vobj_base = _get_vobj_base( header );
-    unsigned int      align     = vobj_base[vseg->vobj_offset].align;
-    if ( vobj_base[vseg->vobj_offset].align < 12 ) align = 12;
-
-    // initialise physical base address, with alignment constraint
-    paddr_t possible_pbase = paddr_align_to( pseg->base, align );
-
-    // We are looking for a contiguous space in target pseg
-    // If there is vsegs already mapped, we scan the vsegs list to: 
-    // - try mapping in holes between already mapped vsegs,
-    // - update the ordered linked list if success
-    // We don't enter the loop if no vsegs is already mapped.
-    // implementation note: The next_vseg field is unsigned int,
-    // but we use it to store a MIP32 pointer on a vseg...
-
-    mapping_vseg_t*   curr = 0;
-    mapping_vseg_t*   prev = 0;
-
-    for( curr = (mapping_vseg_t*)pseg->next_vseg ; 
-         (curr != 0) && (vseg->mapped == 0) ; 
-         curr = (mapping_vseg_t*)curr->next_vseg )
-    {
-        // looking for space before current vseg
-        if ( (curr->pbase >= possible_pbase + vseg->length) ) // space before curr
-        {
-            vseg->pbase  = possible_pbase;
-            vseg->mapped = 1;
-
-            // update linked list
-            vseg->next_vseg = (unsigned int)curr;
-            if( curr == (mapping_vseg_t*)pseg->next_vseg ) 
-                pseg->next_vseg = (unsigned int)vseg;
-            else
-                prev->next_vseg = (unsigned int)vseg;
-        }
-        else                                            // looking for space after curr
-        {
-            possible_pbase = paddr_align_to( curr->pbase + curr->length, align );
-            prev           = curr;
-        }
-    }
-        
-    // when no space found, try to allocate space after already mapped vsegs
-    if( (vseg->mapped == 0) &&
-        ((possible_pbase + vseg->length) <= (pseg->base + pseg->length)) )
-    {
-        vseg->pbase  = possible_pbase;
-        vseg->mapped = 1;
-
-        // update linked list
-        vseg->next_vseg = 0;
-        if ((curr == 0 ) && (prev == 0)) pseg->next_vseg = (unsigned int)vseg;
-        else                             prev->next_vseg = (unsigned int)vseg;
-    }
-
-    if( vseg->mapped == 0 )
-    {
-        _puts("\n[BOOT ERROR] in boot_vseg_set_paddr() : vseg ");
-        _puts( vseg->name );
-        _puts(" cannot be mapped on pseg ");
-        _puts( pseg->name );
-        _puts(" in cluster[");
-        _putd( pseg->clusterid );
-        _puts("]\n");
-        _exit();
-    }
-}  // end boot_vseg_set_paddr()
-
-///////////////////////////////////////////////////////////////////////////
-// This function computes the physical base address for a vseg
-// as specified in the mapping info data structure.
-// It updates the pbase and the length fields of the vseg.
-// It updates the pbase and vbase fields of all vobjs in the vseg.
-// It updates the _ptabs_paddr[] and _ptabs_vaddr[], _ptabs_max_pt2[],
-// and _ptabs_next_pt2[] arrays. 
-// It is a global vseg if vspace_id = (-1). 
-///////////////////////////////////////////////////////////////////////////
-void boot_vseg_map(mapping_vseg_t * vseg, unsigned int vspace_id) 
-{
-    unsigned int vobj_id;
-    unsigned int cur_vaddr;
-    paddr_t      cur_paddr;
-    paddr_t      cur_length;
-    unsigned int offset;
-
-    mapping_header_t * header = (mapping_header_t *)SEG_BOOT_MAPPING_BASE;
-    mapping_vobj_t   * vobj   = _get_vobj_base(header);
-
-    // first loop on the vobjs contained in vseg to compute 
-    // the vseg length, required for mapping.
-    cur_length = 0;
-    for ( vobj_id = vseg->vobj_offset; 
-          vobj_id < (vseg->vobj_offset + vseg->vobjs); 
+    mapping_header_t*   header  = (mapping_header_t *)SEG_BOOT_MAPPING_BASE;
+    mapping_vobj_t*     vobj    = _get_vobj_base(header);
+    mapping_cluster_t*  cluster = _get_cluster_base(header);
+    mapping_pseg_t*     pseg    = _get_pseg_base(header);
+
+    // compute destination cluster pointer & coordinates
+    pseg    = pseg + vseg->psegid;
+    cluster = cluster + pseg->clusterid;
+    unsigned int        x_dest     = cluster->x;
+    unsigned int        y_dest     = cluster->y;
+
+    // compute the first vobj global index
+    unsigned int        vobj_id = vseg->vobj_offset;
+    
+    // compute the "big" vseg attribute
+    unsigned int        big = vseg->big;
+
+    // compute the "is_ram" vseg attribute
+    unsigned int        is_ram;
+    if ( pseg->type == PSEG_TYPE_RAM )  is_ram = 1;
+    else                                is_ram = 0;
+
+    // compute the "is_ptab" attribute
+    unsigned int        is_ptab;
+    if ( vobj[vobj_id].type == VOBJ_TYPE_PTAB ) is_ptab = 1;
+    else                                        is_ptab = 0;
+
+    //////////// First step : compute vseg length and vobj(s) vbase
+
+    unsigned int vobj_vbase = vseg->vbase;   // min vbase for first vobj
+
+    for ( vobj_id = vseg->vobj_offset ;
+          vobj_id < (vseg->vobj_offset + vseg->vobjs) ; 
           vobj_id++ ) 
     {
-        if (vobj[vobj_id].align)
-        {
-            cur_length = vaddr_align_to(cur_length, vobj[vobj_id].align);
-        }
-        cur_length += vobj[vobj_id].length;
-    }
-    vseg->length = paddr_align_to(cur_length, 12);
-
-    // mapping: computes vseg pbase address
-    if (vseg->ident != 0)                         // identity mapping 
-    {
-        boot_vseg_set_paddr_ident( vseg );
-    }
-    else                                          // unconstrained mapping
-    {
-        boot_vseg_set_paddr( vseg );
-    }
-
-    // second loop on vobjs contained in vseg to :
-    // initialize the vaddr and paddr fields of all vobjs,
-    // and initialize the page table pointers arrays 
-
-    cur_vaddr = vseg->vbase;
-    cur_paddr = vseg->pbase;
-
-    for (vobj_id = vseg->vobj_offset; 
-         vobj_id < (vseg->vobj_offset + vseg->vobjs); vobj_id++) 
-    {
-        if (vobj[vobj_id].align) 
-        {
-            cur_paddr = paddr_align_to(cur_paddr, vobj[vobj_id].align);
-            cur_vaddr = vaddr_align_to(cur_vaddr, vobj[vobj_id].align);
-        }
-        // set vaddr/paddr for current vobj
-        vobj[vobj_id].vaddr = cur_vaddr;
-        vobj[vobj_id].paddr = cur_paddr;
-        
-        // initialize _ptabs_vaddr[] , _ptabs-paddr[] , _ptabs_max_pt2[] if PTAB
-        if (vobj[vobj_id].type == VOBJ_TYPE_PTAB) 
-        {
-            if (vspace_id == ((unsigned int) -1))    // global vseg
-            {
-                _puts("\n[BOOT ERROR] in boot_vseg_map() function: ");
-                _puts("a PTAB vobj cannot be global");
-                _exit();
+        // compute and register vobj vbase
+        vobj[vobj_id].vbase = vaddr_align_to( vobj_vbase, vobj[vobj_id].align );
+   
+        // compute min vbase for next vobj
+        vobj_vbase = vobj[vobj_id].vbase + vobj[vobj_id].length;
+    }
+
+    // compute and register vseg length (multiple of 4 Kbytes)
+    vseg->length = vaddr_align_to( vobj_vbase - vseg->vbase, 12 );
+    
+    //////////// Second step : compute ppn and npages  
+    //////////// - if identity mapping :  ppn <= vpn 
+    //////////// - if vseg is periph   :  ppn <= pseg.base >> 12
+    //////////// - if vseg is ram      :  ppn <= physical memory allocator
+
+    unsigned int ppn;          // first physical page index ( 28 bits = |x|y|bppi|sppi| ) 
+    unsigned int vpn;          // first virtual page index  ( 20 bits = |ix1|ix2| )
+    unsigned int vpn_max;      // last  virtual page index  ( 20 bits = |ix1|ix2| )
+
+    vpn     = vseg->vbase >> 12;
+    vpn_max = (vseg->vbase + vseg->length - 1) >> 12;
+
+    // compute npages
+    unsigned int npages;       // number of required (big or small) pages
+    if ( big == 0 ) npages  = vpn_max - vpn + 1;            // number of small pages
+    else            npages  = (vpn_max>>9) - (vpn>>9) + 1;  // number of big pages
+
+    // compute ppn
+    if ( vseg->ident )           // identity mapping
+    {
+        ppn = vpn;
+    }
+    else                         // not identity mapping
+    {
+        if ( is_ram )            // RAM : physical memory allocation required
+        {
+            // compute pointer on physical memory allocator in dest cluster
+            pmem_alloc_t*     palloc = &boot_pmem_alloc[x_dest][y_dest];
+
+            if ( big == 0 )             // SPP : small physical pages
+            {
+                // allocate contiguous small physical pages
+                ppn = _get_small_ppn( palloc, npages );
             }
-            // we need at least one PT2
-            if (vobj[vobj_id].length < (PT1_SIZE + PT2_SIZE)) 
-            {
-                _puts("\n[BOOT ERROR] in boot_vseg_map() function, ");
-                _puts("PTAB too small, minumum size is: ");
-                _putx(PT1_SIZE + PT2_SIZE);
-                _exit();
-            }
-            // get cluster coordinates for PTAB
-            unsigned int cluster_xy = (unsigned int)(cur_paddr>>32);
-            unsigned int x          = cluster_xy >> Y_WIDTH;
-            unsigned int y          = cluster_xy & ((1<<Y_WIDTH)-1);
-
-            // register physical and virtual page table addresses, size, and next PT2
-            _ptabs_vaddr[vspace_id]          = vobj[vobj_id].vaddr;
-            _ptabs_paddr[vspace_id][x][y]    = vobj[vobj_id].paddr;
-            _ptabs_max_pt2[vspace_id][x][y]  = (vobj[vobj_id].length - PT1_SIZE) / PT2_SIZE;
-            _ptabs_next_pt2[vspace_id][x][y] = 0;
-            
-            // reset all valid bits in PT1
-            for ( offset = 0 ; offset < 8192 ; offset = offset + 4)
-            {
-                _physical_write(cur_paddr + offset, 0);
+            else                            // BPP : big physical pages
+            {
+ 
+                // one big page can be shared by several vsegs 
+                // we must chek if BPP already allocated 
+                if ( is_ptab )   // It cannot be mapped
+                {
+                    ppn = _get_big_ppn( palloc, npages ); 
+                }
+                else             // It can be mapped
+                {
+                    unsigned int ix1   = vpn >> 9;   // 11 bits
+                    paddr_t      paddr = _ptabs_paddr[0][x_dest][y_dest] + (ix1<<2);
+                    unsigned int pte1  = _physical_read( paddr );
+                    if ( (pte1 & PTE_V) == 0 )     // BPP not allocated yet
+                    {
+                        // allocate contiguous big physical pages 
+                        ppn = _get_big_ppn( palloc, npages ); 
+                    }
+                    else                           // BPP already allocated
+                    {
+                        ppn = ((pte1 << 9) & 0x0FFFFE00);
+                    }
+                }
+                ppn = ppn | (vpn & 0x1FF);
             }
         }
-
-        // set next vaddr/paddr
-        cur_vaddr = cur_vaddr + vobj[vobj_id].length;
-        cur_paddr = cur_paddr + vobj[vobj_id].length;
-    } // end for vobjs
-
-}    // end boot_vseg_map()
-
-///////////////////////////////////////////////////////////////////////////
-// This function builds the page tables for all virtual spaces 
-// defined in the mapping_info data structure, in three steps:
-// - step 1 : It computes the physical base address for global vsegs
-//            and for all associated vobjs.
-// - step 2 : It computes the physical base address for all private 
-//            vsegs and all vobjs in each virtual space.
-// - step 3 : It actually fill the page table(s) for each vspace.
+        else                    // PERI : no memory allocation required
+        {
+            ppn = pseg->base >> 12;
+        }
+    }
+
+    // update vseg.pbase field and update vsegs chaining
+    vseg->pbase     = ((paddr_t)ppn) << 12;
+    vseg->next_vseg = pseg->next_vseg;
+    pseg->next_vseg = (unsigned int)vseg;
+
+
+    //////////// Third step : (only if the vseg is a page table)
+    //////////// - compute the physical & virtual base address for each vspace
+    ////////////   by dividing the vseg in several sub-segments.
+    //////////// - register it in _ptabs_vaddr & _ptabs_paddr arrays,
+    ////////////   and initialize the max_pt2 and next_pt2 allocators.
+    
+    if ( is_ptab )
+    {
+        unsigned int   vs;        // vspace index
+        unsigned int   nspaces;   // number of vspaces
+        unsigned int   nsp;       // number of small pages for one PTAB
+        unsigned int   offset;    // address offset for current PTAB
+
+        nspaces = header->vspaces;
+        offset  = 0;
+
+        // each PTAB must be aligned on a 8 Kbytes boundary
+        nsp = ( vseg->length << 12 ) / nspaces;
+        if ( (nsp & 0x1) == 0x1 ) nsp = nsp - 1;
+
+        // compute max_pt2
+        _ptabs_max_pt2 = ((nsp<<12) - PT1_SIZE) / PT2_SIZE;
+        
+        for ( vs = 0 ; vs < nspaces ; vs++ )
+        {
+            offset += nsp;
+            _ptabs_vaddr   [vs][x_dest][y_dest] = (vpn + offset) << 12;  
+            _ptabs_paddr   [vs][x_dest][y_dest] = ((paddr_t)(ppn + offset)) << 12;
+            _ptabs_next_pt2[vs][x_dest][y_dest] = 0;
+        }
+    }
+
+#if BOOT_DEBUG_PT
+_puts("[BOOT DEBUG] ");
+_puts( vseg->name ); 
+_puts(" in cluster[");
+_putd( x_dest );
+_puts(",");
+_putd( y_dest );
+_puts("] : vbase = ");
+_putx( vseg->vbase );
+_puts(" / length = ");
+_putx( vseg->length );
+if ( big ) _puts(" / BIG   / npages = ");
+else       _puts(" / SMALL / npages = ");
+_putd( npages );
+_puts(" / pbase = ");
+_putl( vseg->pbase );
+_puts("\n");
+#endif
+
+} // end boot_vseg_map()
+
+/////////////////////////////////////////////////////////////////////////////////////
+// For the vseg defined by the vseg pointer, this function register all PTEs
+// in one or several page tables.
+// It is a global vseg (system vseg) if (vspace_id == 0xFFFFFFFF).
+// The number of involved PTABs depends on the "local" and "global" attributes:
+//  - PTEs are replicated in all vspaces for a global vseg.
+//  - PTEs are replicated in all clusters for a non local vseg.
+/////////////////////////////////////////////////////////////////////////////////////
+void boot_vseg_pte_init( mapping_vseg_t*  vseg,
+                         unsigned int     vspace_id )
+{
+    // compute the "global" vseg attribute and actual vspace index
+    unsigned int        global;
+    unsigned int        vsid;    
+    if ( vspace_id == 0xFFFFFFFF )
+    {
+        global = 1;
+        vsid   = 0;
+    }
+    else
+    {
+        global = 0;
+        vsid   = vspace_id;
+    }
+
+    // compute the "local" and "big" attributes 
+    unsigned int        local  = vseg->local;
+    unsigned int        big    = vseg->big;
+
+    // compute vseg flags
+    // The three flags (Local, Remote and Dirty) are set to 1 to reduce
+    // latency of TLB miss (L/R) and write (D): Avoid hardware update
+    // mechanism for these flags because GIET_VM does use these flags.
+    unsigned int flags = 0;
+    if (vseg->mode & C_MODE_MASK) flags |= PTE_C;
+    if (vseg->mode & X_MODE_MASK) flags |= PTE_X;
+    if (vseg->mode & W_MODE_MASK) flags |= PTE_W;
+    if (vseg->mode & U_MODE_MASK) flags |= PTE_U;
+    if ( global )                 flags |= PTE_G;
+                                  flags |= PTE_L;
+                                  flags |= PTE_R;
+                                  flags |= PTE_D;
+
+    // compute VPN, PPN and number of pages (big or small) 
+    unsigned int vpn     = vseg->vbase >> 12;
+    unsigned int vpn_max = (vseg->vbase + vseg->length - 1) >> 12;
+    unsigned int ppn     = (unsigned int)(vseg->pbase >> 12);
+    unsigned int npages;
+    if ( big == 0 ) npages  = vpn_max - vpn + 1;            
+    else            npages  = (vpn_max>>9) - (vpn>>9) + 1; 
+
+    // compute destination cluster coordinates
+    unsigned int        x_dest;
+    unsigned int        y_dest;
+    mapping_header_t*   header  = (mapping_header_t *)SEG_BOOT_MAPPING_BASE;
+    mapping_cluster_t*  cluster = _get_cluster_base(header);
+    mapping_pseg_t*     pseg    = _get_pseg_base(header);
+    pseg     = pseg + vseg->psegid;
+    cluster  = cluster + pseg->clusterid;
+    x_dest   = cluster->x;
+    y_dest   = cluster->y;
+
+    unsigned int p;     // iterator for physical page index
+    unsigned int x;     // iterator for cluster x coordinate  
+    unsigned int y;     // iterator for cluster y coordinate  
+    unsigned int v;     // iterator for vspace index 
+
+    // loop on PTEs
+    for ( p = 0 ; p < npages ; p++ )
+    { 
+        if  ( (local != 0) && (global == 0) )         // one cluster  / one vspace
+        {
+            if ( big )   // big pages => PTE1s
+            {
+                boot_add_pte1( vsid,
+                               x_dest,
+                               y_dest,
+                               vpn + (p<<9),
+                               flags, 
+                               ppn + (p<<9) );
+            }
+            else         // small pages => PTE2s
+            {
+                boot_add_pte2( vsid,
+                               x_dest,
+                               y_dest,
+                               vpn + p,      
+                               flags, 
+                               ppn + p );
+            }
+        }
+        else if ( (local == 0) && (global == 0) )     // all clusters / one vspace
+        {
+            for ( x = 0 ; x < X_SIZE ; x++ )
+            {
+                for ( y = 0 ; y < Y_SIZE ; y++ )
+                {
+                    if ( big )   // big pages => PTE1s
+                    {
+                        boot_add_pte1( vsid,
+                                       x,
+                                       y,
+                                       vpn + (p<<9),
+                                       flags, 
+                                       ppn + (p<<9) );
+                    }
+                    else         // small pages => PTE2s
+                    {
+                        boot_add_pte2( vsid,
+                                       x,
+                                       y,
+                                       vpn + p,
+                                       flags, 
+                                       ppn + p );
+                    }
+                }
+            }
+        }
+        else if ( (local != 0) && (global != 0) )     // one cluster  / all vspaces 
+        {
+            for ( v = 0 ; v < header->vspaces ; v++ )
+            {
+                if ( big )   // big pages => PTE1s
+                {
+                    boot_add_pte1( v,
+                                   x_dest,
+                                   y_dest,
+                                   vpn + (p<<9),
+                                   flags, 
+                                   ppn + (p<<9) );
+                }
+                else         // small pages = PTE2s
+                { 
+                    boot_add_pte2( v,
+                                   x_dest,
+                                   y_dest,
+                                   vpn + p,
+                                   flags, 
+                                   ppn + p );
+                }
+            }
+        }
+        else if ( (local == 0) && (global != 0) )     // all clusters / all vspaces
+        {
+            for ( x = 0 ; x < X_SIZE ; x++ )
+            {
+                for ( y = 0 ; y < Y_SIZE ; y++ )
+                {
+                    for ( v = 0 ; v < header->vspaces ; v++ )
+                    {
+                        if ( big )  // big pages => PTE1s
+                        {
+                            boot_add_pte1( v,
+                                           x,
+                                           y,
+                                           vpn + (p<<9),
+                                           flags, 
+                                           ppn + (p<<9) );
+                        }
+                        else        // small pages -> PTE2s
+                        {
+                            boot_add_pte2( v,
+                                           x,
+                                           y,
+                                           vpn + p,
+                                           flags, 
+                                           ppn + p );
+                        }
+                    }
+                }
+            }
+        }
+    }  // end for pages
+}  // end boot_vseg_pte_init()
+
+///////////////////////////////////////////////////////////////////////////////
+// This function initialises the page tables for all vspaces defined 
+// in the mapping_info data structure.
+// For each vspace, there is one page table per cluster.
+// In each cluster all page tables for the different vspaces must be
+// packed in one vseg occupying one single BPP (Big Physical Page).
 //
-// It must exist at least one vspace in the mapping.
-// For each vspace, it can exist one page table per cluster.
-///////////////////////////////////////////////////////////////////////////
-void boot_pt_init() 
+// For each vseg, the mapping is done in two steps:
+//
+// A) mapping : the boot_vseg_map() function allocates contiguous BPPs 
+//    or SPPs (if the vseg is not associated to a peripheral), and register
+//    the physical base address in the vseg pbase field. It initialises the
+//    _ptabs_vaddr and _ptabs_paddr arrays if the vseg is a PTAB.
+//
+// B) page table initialisation : the boot_vseg_pte_init() function initialise 
+//    the PTEs (both PTE1 and PTE2) in one or several page tables:
+//    - PTEs are replicated in all vspaces for a global vseg.
+//    - PTEs are replicated in all clusters for a non local vseg.
+//
+// We must handle vsegs in the following order
+//   1) all global vsegs containing a page table,
+//   2) all global vsegs occupying more than one BPP, 
+//   3) all others global vsegs
+//   4) all private vsegs in user space.
+///////////////////////////////////////////////////////////////////////////////
+void _ptabs_init() 
 {
-    mapping_header_t * header = (mapping_header_t *)SEG_BOOT_MAPPING_BASE;
-    mapping_vspace_t * vspace = _get_vspace_base(header);
-    mapping_vseg_t   * vseg   = _get_vseg_base(header);
+    mapping_header_t*   header = (mapping_header_t *)SEG_BOOT_MAPPING_BASE;
+    mapping_vspace_t*   vspace = _get_vspace_base(header);
+    mapping_vseg_t*     vseg   = _get_vseg_base(header);
+    mapping_vobj_t*     vobj   = _get_vobj_base(header);
 
     unsigned int vspace_id;
@@ -899 +841 @@
     if (header->vspaces == 0 )
     {
-        _puts("\n[BOOT ERROR] in boot_pt_init() : mapping ");
+        _puts("\n[BOOT ERROR] in _ptabs_init() : mapping ");
         _puts( header->name );
         _puts(" contains no vspace\n");
@@ -905 +847 @@
     }
 
+    ///////// Phase 1 : global vsegs containing a PTAB (two loops required)
+
 #if BOOT_DEBUG_PT
-_puts("\n[BOOT DEBUG] ****** mapping global vsegs ******\n");
-#endif
-
-    //////////////////////////////////
-    // step 1 : loop on global vsegs 
-
-    // vsegs with identity mapping constraint first
+_puts("\n[BOOT DEBUG] map PTAB global vsegs\n");
+#endif
+
     for (vseg_id = 0; vseg_id < header->globals; vseg_id++) 
     {
-        if (vseg[vseg_id].ident == 1) 
-            boot_vseg_map(&vseg[vseg_id], ((unsigned int) (-1)));
-    }
-
-    // unconstrained vsegs second
+        unsigned int vobj_id = vseg[vseg_id].vobj_offset;
+        if ( (vobj[vobj_id].type == VOBJ_TYPE_PTAB) )
+        {
+            boot_vseg_map( &vseg[vseg_id] );
+            vseg[vseg_id].mapped = 1;
+        }
+    }
+
     for (vseg_id = 0; vseg_id < header->globals; vseg_id++) 
     {
-        if (vseg[vseg_id].ident == 0) 
-            boot_vseg_map(&vseg[vseg_id], ((unsigned int) (-1)));
-    }
-
-    ////////////////////////////////////////////////////////////
-    // step 2 : loop on virtual vspaces to map private vsegs
+        unsigned int vobj_id = vseg[vseg_id].vobj_offset;
+        if ( (vobj[vobj_id].type == VOBJ_TYPE_PTAB) )
+        {
+            boot_vseg_pte_init( &vseg[vseg_id], 0xFFFFFFFF );
+            vseg[vseg_id].mapped = 1;
+        }
+    }
+
+    ///////// Phase 2 : global vsegs occupying more than one BPP (one loop)
+
+#if BOOT_DEBUG_PT
+_puts("\n[BOOT DEBUG] map all multi-BPP global vsegs\n");
+#endif
+
+    for (vseg_id = 0; vseg_id < header->globals; vseg_id++) 
+    {
+        unsigned int vobj_id = vseg[vseg_id].vobj_offset;
+        if ( (vobj[vobj_id].length > 0x200000) &&
+             (vseg[vseg_id].mapped == 0) )
+        {
+            boot_vseg_map( &vseg[vseg_id] );
+            vseg[vseg_id].mapped = 1;
+            boot_vseg_pte_init( &vseg[vseg_id], 0xFFFFFFFF );
+        }
+    }
+
+    ///////// Phase 3 : all others global vsegs (one loop)
+
+#if BOOT_DEBUG_PT
+_puts("\n[BOOT DEBUG] map all others global vsegs\n");
+#endif
+
+    for (vseg_id = 0; vseg_id < header->globals; vseg_id++) 
+    {
+        if ( vseg[vseg_id].mapped == 0 )
+        {
+            boot_vseg_map( &vseg[vseg_id] );
+            vseg[vseg_id].mapped = 1;
+            boot_vseg_pte_init( &vseg[vseg_id], 0xFFFFFFFF );
+        }
+    }
+
+    ///////// Phase 4 : all private vsegs (two nested loops)
 
     for (vspace_id = 0; vspace_id < header->vspaces; vspace_id++) 
@@ -933 +913 @@
 
 #if BOOT_DEBUG_PT
-_puts("\n[BOOT DEBUG] ****** mapping private vsegs in vspace ");
-_puts(vspace[vspace_id].name);
-_puts(" ******\n");
+_puts("\n[BOOT DEBUG] map private vsegs for vspace ");
+_puts( vspace[vspace_id].name );
+_puts("\n");
 #endif
 
@@ -942 +922 @@
              vseg_id++) 
         {
-            // private vsegs cannot be identity mapping
-            if (vseg[vseg_id].ident != 0) 
-            {
-                _puts("\n[BOOT ERROR] in boot_pt_init() : vspace ");
-                _puts( vspace[vspace_id].name );
-                _puts(" contains vseg with identity mapping\n");
-                _exit();
-            }
-
-            boot_vseg_map(&vseg[vseg_id], vspace_id);
+            boot_vseg_map( &vseg[vseg_id] );
+            vseg[vseg_id].mapped = 1;
+            boot_vseg_pte_init( &vseg[vseg_id], vspace_id );
         }
     }
 
-#if BOOT_DEBUG_PT
+#if (BOOT_DEBUG_PT > 1) 
 mapping_vseg_t*    curr;
 mapping_pseg_t*    pseg    = _get_pseg_base(header);
@@ -963 +936 @@
 {
     unsigned int cluster_id = pseg[pseg_id].clusterid;
-    _puts("\n[BOOT DEBUG] ****** vsegs mapped on pseg ");
+    _puts("\n[BOOT DEBUG] vsegs mapped on pseg ");
     _puts( pseg[pseg_id].name );
     _puts(" in cluster[");
@@ -969 +942 @@
     _puts(",");
     _putd( cluster[cluster_id].y );
-    _puts("] ******\n");
+    _puts("]\n");
     for( curr = (mapping_vseg_t*)pseg[pseg_id].next_vseg ;
          curr != 0 ;
@@ -987 +960 @@
 #endif
 
-    /////////////////////////////////////////////////////////////
-    // step 3 : loop on the vspaces to build the page tables
-    for (vspace_id = 0; vspace_id < header->vspaces; vspace_id++) 
-    {
-
-#if BOOT_DEBUG_PT
-_puts("\n[BOOT DEBUG] ****** building page table for vspace ");
-_puts(vspace[vspace_id].name);
-_puts(" ******\n");
-#endif
-
-        boot_vspace_pt_build(vspace_id);
-
-    }
-} // end boot_pt_init()
+} // end boot_ptabs_init()
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -1030 +989 @@
         _set_mmu_ptpr( (unsigned int)(_ptabs_paddr[vspace_id][0][0] >> 13) );
 
-        unsigned int ptab_found = 0;
-
         // loop on the vobjs
         for (vobj_id = vspace[vspace_id].vobj_offset;
@@ -1052 +1009 @@
 _puts("\n");
 #endif
-                    mwmr_channel_t* mwmr = (mwmr_channel_t *) (vobj[vobj_id].vaddr);
+                    mwmr_channel_t* mwmr = (mwmr_channel_t *) (vobj[vobj_id].vbase);
                     mwmr->ptw = 0;
                     mwmr->ptr = 0;
@@ -1111 +1068 @@
 _puts("\n");
 #endif
-                    giet_barrier_t* barrier = (giet_barrier_t *) (vobj[vobj_id].vaddr);
+                    giet_barrier_t* barrier = (giet_barrier_t *) (vobj[vobj_id].vbase);
                     barrier->count  = vobj[vobj_id].init;
                     barrier->ntasks = vobj[vobj_id].init;
@@ -1135 +1092 @@
 _puts("\n");
 #endif
-                    unsigned int* lock = (unsigned int *) (vobj[vobj_id].vaddr);
+                    unsigned int* lock = (unsigned int *) (vobj[vobj_id].vbase);
                     *lock = 0;
                     break;
@@ -1167 +1124 @@
 _puts("\n");
 #endif
-                    giet_memspace_t* memspace = (giet_memspace_t *) vobj[vobj_id].vaddr;
-                    memspace->buffer = (void *) vobj[vobj_id].vaddr + 8;
+                    giet_memspace_t* memspace = (giet_memspace_t *) vobj[vobj_id].vbase;
+                    memspace->buffer = (void *) vobj[vobj_id].vbase + 8;
                     memspace->size = vobj[vobj_id].length - 8;
 #if BOOT_DEBUG_VOBJS
@@ -1177 +1134 @@
 _puts("\n");
 #endif
-                    break;
-                }
-                case VOBJ_TYPE_PTAB:    // nothing to initialize
-                {
-#if BOOT_DEBUG_VOBJS
-_puts("PTAB    : ");
-_puts(vobj[vobj_id].name);
-_puts(" / vaddr = ");
-_putx(vobj[vobj_id].vaddr);
-_puts(" / paddr = ");
-_putl(vobj[vobj_id].paddr);
-_puts(" / length = ");
-_putx(vobj[vobj_id].length);
-_puts("\n");
-#endif
-                    ptab_found = 1;
                     break;
                 }
@@ -1210 +1151 @@
 _puts("\n");
 #endif
-                    unsigned int* addr = (unsigned int *) vobj[vobj_id].vaddr;
+                    unsigned int* addr = (unsigned int *) vobj[vobj_id].vbase;
                     *addr = vobj[vobj_id].init;
 
@@ -1222 +1163 @@
                 default:
                 {
-                    _puts("\n[BOOT ERROR] illegal vobj type: ");
-                    _putd(vobj[vobj_id].type);
+                    _puts("\n[BOOT ERROR] in boot_vobjs_init() : Illegal vobj type ");
+                    _putd( vobj[vobj_id].type );
+                    _puts(" in vspace ");
+                    _puts( vspace[vspace_id].name );
                     _puts("\n");
                     _exit();
                 }
             }            // end switch type
-        }            // end loop on vobjs
-        if (ptab_found == 0) 
-        {
-            _puts("\n[BOOT ERROR] Missing PTAB for vspace ");
-            _putd(vspace_id);
-            _exit();
-        }
-    } // end loop on vspaces
-
+        }          // end loop on vobjs
+    }        // end loop on vspaces
 } // end boot_vobjs_init()
 
@@ -1281 +1217 @@
 // This function initialises all processors schedulers.
 // This is done by processor 0, and the MMU must be activated.
-// - In Step 1, it initialises the _schedulers[] pointers array, and scan
-//              the processors to initialise the schedulers, including the
-//              idle_task context, and the HWI / SWI / PTI vectors. 
+// - In Step 1, it initialises the _schedulers[x][y][l] pointers array, and scan
+//              the processors for a first initialisation of the schedulers:
+//              idle_task context, and HWI / SWI / PTI vectors. 
 // - In Step 2, it scan all tasks in all vspaces to complete the tasks contexts, 
 //              initialisation as specified in the mapping_info data structure. 
@@ -1324 +1260 @@
     mapping_periph_t*  pic = NULL;
 
-    // schedulers array base address in a cluster
-    unsigned int          sched_vbase;  
-    unsigned int          sched_length;  
-    static_scheduler_t*   psched;  
+    unsigned int          sched_vbase;  // schedulers array vbase address in a cluster
+    unsigned int          sched_length; // schedulers array length
+    static_scheduler_t*   psched;       // pointer on processor scheduler
 
     /////////////////////////////////////////////////////////////////////////
     // Step 1 : loop on the clusters and on the processors 
     //          to initialize the schedulers[] array of pointers,
-    //          and the interrupt vectors.
+    //          idle task context and interrupt vectors.
     // Implementation note:
     // We need to use both (proc_id) to scan the mapping info structure,
@@ -1366 +1301 @@
         if ( cluster[cluster_id].procs > 0 )
         {
-            // get scheduler array virtual base address from mapping
+            // get scheduler array virtual base address in cluster[cluster_id]
             boot_get_sched_vaddr( cluster_id, &sched_vbase, &sched_length );
 
-            if ( sched_length < (cluster[cluster_id].procs<<12) ) // 4 Kbytes per scheduler
+            if ( sched_length < (cluster[cluster_id].procs<<13) ) // 8 Kbytes per scheduler
             {
                 _puts("\n[BOOT ERROR] Schedulers segment too small in cluster[");
@@ -1378 +1313 @@
                 _exit();
             }
-
-            psched = (static_scheduler_t*)sched_vbase;
 
             // scan peripherals to find the ICU/XCU and the PIC component
@@ -1418 +1351 @@
             }
 
-            // loop on processors for sechedulers default values
+            // loop on processors for schedulers default values
             // initialisation, including WTI and PTI vectors
             for ( lpid = 0 ; lpid < cluster[cluster_id].procs ; lpid++ )
             {
-                // set the schedulers pointers array
-                _schedulers[x][y][lpid] = (static_scheduler_t*)&psched[lpid];
+                // pointer on processor scheduler
+                psched = (static_scheduler_t*)(sched_vbase + (lpid<<13));
+
+                // initialise the schedulers pointers array
+                _schedulers[x][y][lpid] = psched;
 
 #if BOOT_DEBUG_SCHED
+unsigned int   sched_vbase = (unsigned int)_schedulers[x][y][lpid];
+unsigned int   sched_ppn;
+unsigned int   sched_flags;
+paddr_t        sched_pbase;
+
+page_table_t* ptab = (page_table_t*)(_ptabs_vaddr[0][x][y]);
+_v2p_translate( ptab, sched_vbase>>12, &sched_ppn, &sched_flags );
+sched_pbase = ((paddr_t)sched_ppn)<<12;
+
 _puts("\nProc[");
 _putd( x );
@@ -1432 +1377 @@
 _puts(",");
 _putd( lpid );
-_puts("] : scheduler virtual base address = ");
-_putx( (unsigned int)&psched[lpid] );
+_puts("] : scheduler vbase = ");
+_putx( sched_vbase );
+_puts(" : scheduler pbase = ");
+_putl( sched_pbase );
 _puts("\n");
 #endif
                 // initialise the "tasks" and "current" variables default values
-                psched[lpid].tasks   = 0;
-                psched[lpid].current = IDLE_TASK_INDEX;
+                psched->tasks   = 0;
+                psched->current = IDLE_TASK_INDEX;
 
                 // default values for HWI / PTI / SWI vectors (valid bit = 0)
@@ -1444 +1391 @@
                 for (slot = 0; slot < 32; slot++)
                 {
-                    psched[lpid].hwi_vector[slot] = 0;
-                    psched[lpid].pti_vector[slot] = 0;
-                    psched[lpid].wti_vector[slot] = 0;
+                    psched->hwi_vector[slot] = 0;
+                    psched->pti_vector[slot] = 0;
+                    psched->wti_vector[slot] = 0;
                 }
 
                 // WTI[lpid] <= ISR_WAKUP / PTI[lpid] <= ISR_TICK 
-                psched[lpid].wti_vector[lpid] = ISR_WAKUP | 0x80000000;
-                psched[lpid].pti_vector[lpid] = ISR_TICK  | 0x80000000;
+                psched->wti_vector[lpid] = ISR_WAKUP | 0x80000000;
+                psched->pti_vector[lpid] = ISR_TICK  | 0x80000000;
 
                 // initializes the idle_task context in scheduler:
@@ -1460 +1407 @@
                 //   must be initialised by kernel_init()
 
-                psched[lpid].context[IDLE_TASK_INDEX][CTX_CR_ID]    = 0;
-                psched[lpid].context[IDLE_TASK_INDEX][CTX_SR_ID]    = 0xFF03;
-                psched[lpid].context[IDLE_TASK_INDEX][CTX_PTPR_ID]  = _ptabs_paddr[0][x][y]>>13;
-                psched[lpid].context[IDLE_TASK_INDEX][CTX_PTAB_ID]  = _ptabs_vaddr[0];
-                psched[lpid].context[IDLE_TASK_INDEX][CTX_TTY_ID]   = 0;
-                psched[lpid].context[IDLE_TASK_INDEX][CTX_LTID_ID]  = IDLE_TASK_INDEX;
-                psched[lpid].context[IDLE_TASK_INDEX][CTX_VSID_ID]  = 0;
-                psched[lpid].context[IDLE_TASK_INDEX][CTX_RUN_ID]   = 1;
+                psched->context[IDLE_TASK_INDEX][CTX_CR_ID]   = 0;
+                psched->context[IDLE_TASK_INDEX][CTX_SR_ID]   = 0xFF03;
+                psched->context[IDLE_TASK_INDEX][CTX_PTPR_ID] = _ptabs_paddr[0][x][y]>>13;
+                psched->context[IDLE_TASK_INDEX][CTX_PTAB_ID] = _ptabs_vaddr[0][x][y];
+                psched->context[IDLE_TASK_INDEX][CTX_TTY_ID]  = 0;
+                psched->context[IDLE_TASK_INDEX][CTX_LTID_ID] = IDLE_TASK_INDEX;
+                psched->context[IDLE_TASK_INDEX][CTX_VSID_ID] = 0;
+                psched->context[IDLE_TASK_INDEX][CTX_RUN_ID]  = 1;
+
             }  // end for processors
 
@@ -1492 +1440 @@
                 }
 
-                psched[lpid].hwi_vector[srcid] = isr | channel | 0x80000000;
+                _schedulers[x][y][lpid]->hwi_vector[srcid] = isr | channel | 0x80000000;
                 lpid = (lpid + 1) % cluster[cluster_id].procs; 
 
@@ -1546 +1494 @@
             unsigned int y          = cluster[cluster_id].y;
             unsigned int cluster_xy = (x<<Y_WIDTH) + y;
-            psched                  = _schedulers[x][y][0];
+            psched                  = _schedulers[x][y][lpid];
 
             // update WTI vector for scheduler[cluster_id][lpid]
-            unsigned int index = alloc_wti_channel[cluster_id];
-            psched[lpid].wti_vector[index] = isr | channel | 0x80000000;
+            unsigned int index            = alloc_wti_channel[cluster_id];
+            psched->wti_vector[index]     = isr | channel | 0x80000000;
             alloc_wti_channel[cluster_id] = index + 1;
-            lpid = lpid + 1;
+            lpid                          = lpid + 1;
 
             // update IRQ fields in mapping for PIC initialisation
@@ -1566 +1514 @@
     unsigned int x          = cluster[cluster_id].x;
     unsigned int y          = cluster[cluster_id].y;
-    psched                  = _schedulers[x][y][0];
     unsigned int slot;
     unsigned int entry;
     for ( lpid = 0 ; lpid < cluster[cluster_id].procs ; lpid++ )
     {
+        psched = _schedulers[x][y][lpid];
+        
         _puts("\n*** IRQS for proc[");
         _putd( x );
@@ -1580 +1529 @@
         for ( slot = 0 ; slot < 32 ; slot++ )
         {
-            entry = psched[lpid].hwi_vector[slot];
+            entry = psched->hwi_vector[slot];
             if ( entry & 0x80000000 ) 
             {
@@ -1594 +1543 @@
         for ( slot = 0 ; slot < 32 ; slot++ )
         {
-            entry = psched[lpid].wti_vector[slot];
+            entry = psched->wti_vector[slot];
             if ( entry & 0x80000000 ) 
             {
@@ -1608 +1557 @@
         for ( slot = 0 ; slot < 32 ; slot++ )
         {
-            entry = psched[lpid].pti_vector[slot];
+            entry = psched->pti_vector[slot];
             if ( entry & 0x80000000 ) 
             {
@@ -1634 +1583 @@
         _set_mmu_ptpr( (unsigned int)(_ptabs_paddr[vspace_id][0][0] >> 13) );
 
-        // loop on the tasks in vspace (task_id is the global index)
+        // loop on the tasks in vspace (task_id is the global index in mapping)
         for (task_id = vspace[vspace_id].task_offset;
              task_id < (vspace[vspace_id].task_offset + vspace[vspace_id].tasks);
@@ -1663 +1612 @@
 
             // ctx_ptab : page_table virtual base address
-            unsigned int ctx_ptab = _ptabs_vaddr[vspace_id];
+            unsigned int ctx_ptab = _ptabs_vaddr[vspace_id][x][y];
 
             // ctx_tty : TTY terminal global index provided by the global allocator
@@ -1763 +1712 @@
             // segment and we must wait the .elf loading to get the entry point value...
             vobj_id = vspace[vspace_id].start_vobj_id;     
-            unsigned int ctx_epc = vobj[vobj_id].vaddr + (task[task_id].startid)*4;
+            unsigned int ctx_epc = vobj[vobj_id].vbase + (task[task_id].startid)*4;
 
             // ctx_sp :  Get the vobj containing the stack 
             vobj_id = task[task_id].stack_vobj_id;
-            unsigned int ctx_sp = vobj[vobj_id].vaddr + vobj[vobj_id].length;
+            unsigned int ctx_sp = vobj[vobj_id].vbase + vobj[vobj_id].length;
 
             // get local task index in scheduler
@@ -1853 +1802 @@
         } // end loop on tasks
     } // end loop on vspaces
-} // end _schedulers_init()
+} // end boot_schedulers_init()
 
 //////////////////////////////////////////////////////////////////////////////////
 // This function loads the map.bin file from block device.
-// The fat global varible is defined in fat32.c file.
 //////////////////////////////////////////////////////////////////////////////////
 void boot_mapping_init()
@@ -1880 +1828 @@
 #endif
 
-    // get "map.bin" file size (from fat32) and check it
+    // get "map.bin" file size (from fat) and check it
     unsigned int size    = fat.fd[fd_id].file_size;
 
@@ -2365 +2313 @@
 
                         _xcu_get_wti_address( wti_id, &vaddr );
-
                         _pic_init( hwi_id, vaddr, cluster_xy ); 
+
 #if BOOT_DEBUG_PERI
+unsigned int address = _pic_get_register( channel_id, IOPIC_ADDRESS );
+unsigned int extend  = _pic_get_register( channel_id, IOPIC_EXTEND  );
 _puts("    hwi_index = ");
 _putd( hwi_id );
@@ -2378 +2328 @@
 _puts(",");
 _putd( cluster_xy & ((1<<Y_WIDTH)-1) );
-_puts("]\n");
+_puts("] / checked_xcu_paddr = ");
+_putl( (paddr_t)address + (((paddr_t)extend)<<32) );
+_puts("\n");
 #endif
                     }
@@ -2412 +2364 @@
                   cp_port_id++ ) 
             {
-                // Get global index of associted vobj
+                // get global index of associted vobj
                 unsigned int vobj_id   = cp_port[cp_port_id].mwmr_vobj_id; 
 
-                // Get MWMR channel base address 
-                paddr_t mwmr_channel_pbase = vobj[vobj_id].paddr;
-
+                // get MWMR channel base address 
+                page_table_t* ptab  = (page_table_t*)_ptabs_vaddr[0][x][y];
+                unsigned int  vbase = vobj[vobj_id].vbase;
+                unsigned int  ppn;
+                unsigned int  flags;
+                paddr_t       pbase;
+
+                _v2p_translate( ptab, 
+                                vbase>>12 , 
+                                &ppn, 
+                                &flags );
+
+                pbase = ((paddr_t)ppn)<<12;
+
+                // initialise cp_port
                 _mwr_hw_init( cluster_xy,
                               cp_port_id, 
                               cp_port[cp_port_id].direction, 
-                              mwmr_channel_pbase );
+                              pbase );
 #if BOOT_DEBUG_PERI
 _puts("     port direction: ");
 _putd( (unsigned int)cp_port[cp_port_id].direction );
 _puts(" / mwmr_channel_pbase = ");
-_putl( mwmr_channel_pbase );
+_putl( pbase );
 _puts(" / name = ");
 _puts(vobj[vobj_id].name);
@@ -2436 +2400 @@
 } // end boot_peripherals_init()
 
+/////////////////////////////////////////////////////////////////////////
+// This function initialises the physical memory allocators in each
+// cluster containing a RAM pseg.
+/////////////////////////////////////////////////////////////////////////
+void boot_pmem_init() 
+{
+    mapping_header_t*  header     = (mapping_header_t *)SEG_BOOT_MAPPING_BASE;
+    mapping_cluster_t* cluster    = _get_cluster_base(header);
+    mapping_pseg_t*    pseg       = _get_pseg_base(header);
+
+    unsigned int cluster_id;
+    unsigned int pseg_id;
+
+    // scan all clusters
+    for ( cluster_id = 0 ; cluster_id < X_SIZE*Y_SIZE ; cluster_id++ ) 
+    {
+        // scan the psegs in cluster to find first pseg of type RAM
+        unsigned int pseg_min = cluster[cluster_id].pseg_offset;
+        unsigned int pseg_max = pseg_min + cluster[cluster_id].psegs;
+        for ( pseg_id = pseg_min ; pseg_id < pseg_max ; pseg_id++ )
+        {
+            if ( pseg[pseg_id].type == PSEG_TYPE_RAM )
+            {
+                unsigned int x    = cluster[cluster_id].x;
+                unsigned int y    = cluster[cluster_id].y;
+                unsigned int base = (unsigned int)pseg[pseg_id].base;
+                unsigned int size = (unsigned int)pseg[pseg_id].length;
+                _pmem_alloc_init( x, y, base, size );
+
+#if BOOT_DEBUG_PT
+_puts("\n[BOOT DEBUG] pmem allocator initialised in cluster[");
+_putd( x );
+_puts(",");
+_putd( y );
+_puts("] base = ");
+_putx( base );
+_puts(" / size = ");
+_putx( size );
+_puts("\n");
+#endif
+               break;
+            }
+        }
+    }
+} // end boot_pmem_init()
+ 
 /////////////////////////////////////////////////////////////////////////
 // This function is the entry point of the boot code for all processors.
@@ -2461 +2471 @@
         _puts("\n");
 
+        // Initializes the physical memory allocators
+        boot_pmem_init();
+
+        _puts("\n[BOOT] Physical memory allocators initialised at cycle ");
+        _putd(_get_proctime());
+        _puts("\n");
+
         // Build page tables
-        boot_pt_init();
+        _ptabs_init();
+
+        _puts("\n[BOOT] Page tables initialised at cycle ");
+        _putd(_get_proctime());
+        _puts("\n");
 
         // Activate MMU for proc [0,0,0]