Changeset 493 for soft/giet_vm/giet_boot/boot_entry.S

Timestamp:

Feb 8, 2015, 12:30:47 PM (10 years ago)

Author:

alain

Message:

1) Introduce a fully parallel procedure for both
page tables ans schedulers initialisation.
2) Introduce support for platforms containing clusters
without processors (as in the tsar_generic_leti).

File:

• soft/giet_vm/giet_boot/boot_entry.S (modified) (4 diffs)

soft/giet_vm/giet_boot/boot_entry.S

@@ -1 +1 @@
 /*
- * file   : boot.S
+ * file   : boot_entry.S
  * date   : 01/17/2014
  * author : Cesar Fuguet & Alain Greiner & Hao Liu
@@ -19 +19 @@
  * to the boot_init() fuction defined in the boot.c file.
  *
- * - each processor[x][y][0] uses a larger stack: 1,25 Kbytes. 
- * - Other processors use a smaller stack:    256 bytes.
- *     => the SEG_BOOT_STACK_SIZE cannot be smaller 512 Kytes.
- *         (256*(1024+256) + (1024 - 256) * 256 = 512 Kbytes = 0x80000)
+ * - each processor P[x,y,0] uses a larger stack: 1,25 Kbytes. 
+ * - Other processors use a smaller stack:        0,25 Kbytes.
+ *     => the SEG_BOOT_STACK_SIZE cannot be smaller than 
+ *        256 * (1024 + 256) + (1024 - 256) * 256 = 512 Kbytes
  */
 
@@ -38 +38 @@
 boot_entry:
 
-
-    /* All processors compute proc_id = (cluster_id * NBPROCS) + lpid             */
-    /* where cluster_id = (x * Y_SIZE) + y                                        */
     /* The (x,y,lpid) values are obtained from the processor CP0 register,        */
-    /* where  proc_xyl == (((x<<4) + y) * NB_PROCS_MAX) + lpid                    */ 
-    /* (proc_id is a "continuous" index, while proc_xyl is a "fixed format" index */
-
+    /* where  proc_id == (((x<<Y_WIDTH) + y)<<P_WIDTH) + lpid (fixed format)      */ 
+    /* The continuous cluster index is computed as cluster_id = (x * Y_SIZE) + y  */
 
     mfc0   k0,      CP0_PROCID
-    andi   k0,      k0,     0xFFF             /* k0 <= proc_xyl                   */
+    andi   k0,      k0,     0xFFF             /* k0 <= proc_id                    */
     andi   t1,      k0,     ((1<<P_WIDTH)-1)  /* t1 <= lpid                       */
     srl    t2,      k0,     P_WIDTH           /* t2 <= cluster_xy                 */
@@ -54 +50 @@
     la     t6,      Y_SIZE                    /* t6 <= Y_SIZE                     */
     multu  t3,      t6
-    mflo   t5
+    mflo   t5                                 /* t5 <= x * Y_SIZE                 */
     addu   t5,      t5,     t4                /* t5 <= cluster_id                 */
-    li     t6,      0x100 * (NB_PROCS_MAX - 1) + 0x500  /* stack size per cluster */
+
+    /* All processors initializes stack pointer, depending on x,y,lpid            */
+    /* Processors P[x,y,0] : stack size = 1,25 Kbytes                             */
+    /* Other processors    : stack size = 0,25 Kbytes 
+    /* In each cluster, the total stack size is NB_PROCS_MAX-1)*0x100 + 0x500     */
+
+    li     t6,      (NB_PROCS_MAX-1) * 0x100 + 0x500  /* t6 <= cluster_size       */
     multu  t6,      t5
-    mflo   t7
-
-    /* All processors initializes stack pointer, depending on proc_id             */
-
-   la      k0,      SEG_BOOT_STACK_BASE
-   addu    k0,      k0,     t7
-   li      k1,      0x500           /* k1 <= local P0 stack size == 1,25 Kbytes            */
-   addu    sp,      k0,     k1      /* P0 stack from base to (base + stack size * cluster_id + 1,25K )         */
-
-   li      k1,      0x100           /* k1 <= Pi stack size == 256 bytes            */
-   multu   k1,      t1              
-   mflo    k0                       /* k0 <= 256 * proc_id                        */
-   addu    sp,      sp,     k0      /* Pi stacks from base + stack size * cluster_id + 1,25K + proc_id*256    */
-
+    mflo   t7                                 /* t7 <= cluster_size * cluster_id  */
+    la     k0,      SEG_BOOT_STACK_BASE
+    addu   k0,      k0,     t7                /* k0 <= stack base in cluster      */
+    li     k1,      0x500                     /* k1 <= 1,25 Kbytes                */
+    addu   sp,      k0,     k1                /* P[x,y,0] stack top               */
+    li     k1,      0x100                     /* k1 <= 0,25 bytes                 */
+    multu  k1,      t1              
+    mflo   k0                                 /* k0 <= 256 * lpid                 */
+    addu   sp,      sp,     k0                /* P[x,y,lpid] stack top            */ 
 
     /* All processors jump to the boot_init function                              */