Changeset 19 for trunk

Timestamp:

Jun 3, 2017, 4:46:59 PM (8 years ago)

Author:

max@…

Message:

cosmetic, and a few typos

Location:

trunk/kernel/kern

Files:

• cluster.c (modified) (25 diffs)
• cluster.h (modified) (14 diffs)
• core.c (modified) (12 diffs)
• core.h (modified) (10 diffs)
• dqdt.c (modified) (11 diffs)
• dqdt.h (modified) (6 diffs)
• kernel_init.c (modified) (9 diffs)

trunk/kernel/kern/cluster.c

@@ -1 +1 @@
 /*
  * cluster.c - Cluster-Manager related operations
- * 
+ *
  * Author  Ghassan Almaless (2008,2009,2010,2011,2012)
  *         Mohamed Lamine Karaoui (2015)
@@ -68 +68 @@
 
     // initialize cluster global parameters
-        cluster->paddr_width     = info->paddr_width; 
+        cluster->paddr_width     = info->paddr_width;
         cluster->x_width         = info->x_width;
         cluster->y_width         = info->y_width;
@@ -77 +77 @@
     // initialize cluster local parameters
         cluster->cores_nr        = info->cores_nr;
-    cluster->cores_in_kernel = info->cores_nr;   // all cpus start in kernel mode
-
-    // initialize the lock protectig the embedded kcm allocator
+    cluster->cores_in_kernel = info->cores_nr; // all cpus start in kernel mode
+
+    // initialize the lock protecting the embedded kcm allocator
         spinlock_init( &cluster->kcm_lock );
 
-    // initialises DQDT 
-    cluster->dqdt_root_level = dqdt_init( info->x_size, 
-                                          info->y_size, 
+    // initialises DQDT
+    cluster->dqdt_root_level = dqdt_init( info->x_size,
+                                          info->y_size,
                                           info->y_width );
     cluster->threads_var = 0;
@@ -96 +96 @@
     // initialises embedded KHM
         khm_init( &cluster->khm );
-  
-    // initialises embedded KCM 
+
+    // initialises embedded KCM
         kcm_init( &cluster->kcm , KMEM_KCM );
 
@@ -107 +107 @@
                        info->core[lid].gid );      // gid from boot_info_t
         }
-        
+
     // initialises RPC fifo
         rpc_fifo_init( &cluster->rpc_fifo );
@@ -114 +114 @@
         spinlock_init( &cluster->pmgr.pref_lock );
     cluster->pmgr.pref_nr = 0;
-    cluster->pmgr.pref_tbl[0] = XPTR( local_cxy , &process_zero );   
+    cluster->pmgr.pref_tbl[0] = XPTR( local_cxy , &process_zero );
     for( lpid = 1 ; lpid < CONFIG_MAX_PROCESS_PER_CLUSTER ; lpid++ )
     {
@@ -131 +131 @@
         cluster->pmgr.copies_nr[lpid] = 0;
         xlist_root_init( XPTR( local_cxy , &cluster->pmgr.copies_root[lpid] ) );
-    }    
+    }
 
     hal_wbflush();
@@ -148 +148 @@
     uint32_t y = cxy & ((1<<y_width)-1);
 
-    if( x >= cluster->x_size ) return true;  
-    if( y >= cluster->y_size ) return true;  
+    if( x >= cluster->x_size ) return true;
+    if( y >= cluster->y_size ) return true;
 
     return false;
@@ -188 +188 @@
             sel = lid;
         }
-    } 
+    }
     return sel;
 }
@@ -198 +198 @@
 //////////////////////////////////////////////////////////
 xptr_t cluster_get_reference_process_from_pid( pid_t pid )
-{ 
+{
     xptr_t xp;   // extended pointer on process descriptor
 
@@ -207 +207 @@
     lpid_t lpid      = LPID_FROM_PID( pid );
 
-    // Check valid PID 
+    // Check valid PID
     if( lpid >= CONFIG_MAX_PROCESS_PER_CLUSTER )
     {
@@ -215 +215 @@
 
     if( local_cxy == owner_cxy )   // local cluster is owner cluster
-    { 
+    {
         xp = cluster->pmgr.pref_tbl[lpid];
     }
@@ -264 +264 @@
     {
         error = EAGAIN;
-    }   
+    }
 
     // release the processs_manager lock
@@ -307 +307 @@
     list_entry_t * iter;
     process_t    * process;
-    
+
     LIST_FOREACH( root , iter )
     {
@@ -370 +370 @@
     xptr_t copies_entry = XPTR( local_cxy , &process->copies_list );
 
-    // get lock protecting copies_list[lpid] 
+    // get lock protecting copies_list[lpid]
     remote_spinlock_lock( copies_lock );
 
@@ -376 +376 @@
     hal_remote_atomic_add( XPTR( owner_cxy , &pm->copies_nr[lpid] ) , 1 );
 
-    // release lock protecting copies_list[lpid] 
+    // release lock protecting copies_list[lpid]
     remote_spinlock_unlock( copies_lock );
 }
@@ -396 +396 @@
     xptr_t copies_entry = XPTR( local_cxy , &process->copies_list );
 
-    // get lock protecting copies_list[lpid] 
+    // get lock protecting copies_list[lpid]
     remote_spinlock_lock( copies_lock );
 
@@ -402 +402 @@
     hal_remote_atomic_add( XPTR( owner_cxy , &pm->copies_nr[lpid] ) , -1 );
 
-    // release lock protecting copies_list[lpid] 
+    // release lock protecting copies_list[lpid]
     remote_spinlock_unlock( copies_lock );
 }
@@ -408 +408 @@
 ////////////////////////////////////////////////////////////////////////////////////////
 // TODO Il me semble que la seule chose que fait ce kernel thread à chaque réveil
-// est de mettre à jour la DQDT, et de se rendormir... A-t-on besoin d'un thread ? [AG] 
+// est de mettre à jour la DQDT, et de se rendormir... A-t-on besoin d'un thread ? [AG]
 //////////////////////////////////////////////////////////////////////////////////////////
 
@@ -437 +437 @@
         isRootMgr = (cluster == root_home) ? true : false;
         cntr      = 0;
-        period    = (isRootMgr) ? 
-                CONFIG_DQDT_ROOTMGR_PERIOD * MSEC_PER_TICK : 
+        period    = (isRootMgr) ?
+                CONFIG_DQDT_ROOTMGR_PERIOD * MSEC_PER_TICK :
                 CONFIG_DQDT_MGR_PERIOD * MSEC_PER_TICK;
 
@@ -444 +444 @@
         event_set_priority(&event, E_CHR);
         event_set_handler(&event, &manager_alarm_event_handler);
-  
+
         info.event = &event;
         thread_preempt_disable(CURRENT_THREAD);
@@ -459 +459 @@
                         if((cntr % 10) == 0)
                         {
-                                printk(INFO, "INFO: cpu %d, DQDT update ended [ %u - %u ]\n", 
-                                       cpu_id, 
-                                       tm_end, 
+                                printk(INFO, "INFO: cpu %d, DQDT update ended [ %u - %u ]\n",
+                                       cpu_id,
+                                       tm_end,
                                        tm_end - tm_start);
 
@@ -480 +480 @@
 {
         struct thread_s *manager;
- 
+
         manager = event_get_senderId(event);
- 
+
         thread_preempt_disable(CURRENT_THREAD);
 
@@ -488 +488 @@
 
         sched_wakeup(manager);
-  
+
         thread_preempt_enable(CURRENT_THREAD);
 
@@ -513 +513 @@
         {
                 ckey->val = key;
-                cluster->keys_tbl[key] = (void *) 0x1; // Reserved 
+                cluster->keys_tbl[key] = (void *) 0x1; // Reserved
                 cluster->next_key = key;
                 event_set_error(event, 0);

trunk/kernel/kern/cluster.h

@@ -1 +1 @@
 /*
  * cluster.h - Cluster-Manager definition
- * 
+ *
  * authors  Ghassan Almaless (2008,2009,2010,2011,2012)
  *          Mohamed Lamine Karaoui (2015)
@@ -55 +55 @@
  * This structure defines the process manager, that is part of the cluster manager.
  * For any process P, the process descriptor is replicated in all clusters containing
- * at least one thread of process P, but only the "reference" cluster descriptor contains 
+ * at least one thread of process P, but only the "reference" cluster descriptor contains
  * the reference (complete) structures such as the GPT, the VSL, or the FDT.
- * The "owner" cluster is in charge to allocate a lpid (local process index), 
+ * The "owner" cluster is in charge to allocate a lpid (local process index),
  * for all process owned by a cluster K, and to register the "reference" cluster for
- * all process owned by K. 
- *
- * Warning : the "owner" cluster, and the "reference" cluster can be different clusters. 
+ * all process owned by K.
+ *
+ * Warning : the "owner" cluster, and the "reference" cluster can be different clusters.
  *
  * The process manager of a cluster K maintains three structures:
@@ -69 +69 @@
  *    A process descriptor P is present in K, as soon as P has a thread in cluster K.
  * 3) The copies_root[] array is indexed by lpid. Each entry contains the root of
- *    the xlist of copies for a given process owned by cluster K.   
+ *    the xlist of copies for a given process owned by cluster K.
  ******************************************************************************************/
 
@@ -82 +82 @@
     uint32_t          local_nr;               /*! number of process in cluster            */
 
-    xlist_entry_t     copies_root[CONFIG_MAX_PROCESS_PER_CLUSTER];  /*! roots of lists    */ 
+    xlist_entry_t     copies_root[CONFIG_MAX_PROCESS_PER_CLUSTER];  /*! roots of lists    */
     remote_spinlock_t copies_lock[CONFIG_MAX_PROCESS_PER_CLUSTER];  /*! one lock per list */
     uint32_t          copies_nr[CONFIG_MAX_PROCESS_PER_CLUSTER];    /*! number of copies  */
@@ -90 +90 @@
 /*******************************************************************************************
  * This structure defines a cluster manager.
- * It contains both global platform informations, and cluster specific ressources
+ * It contains both global platform information, and cluster specific resources
  * managed by the local kernel instance.
  ******************************************************************************************/
@@ -135 +135 @@
     pmgr_t            pmgr;               /*! embedded process manager                    */
 
-        char              name[CONFIG_SYSFS_NAME_LEN];  
+        char              name[CONFIG_SYSFS_NAME_LEN];
 
 //      sysfs_entry_t     node;
-} 
+}
 cluster_t;
 
 /******************************************************************************************
  * This global variable is allocated in the kernel_init.c file.
- * There is one cluster_manager per cluster, with the same local address, 
- * but different content, in all clusters containing a kernel instance. 
+ * There is one cluster_manager per cluster, with the same local address,
+ * but different content, in all clusters containing a kernel instance.
  *****************************************************************************************/
 
@@ -156 +156 @@
 
 /******************************************************************************************
- * This generic function initialises the local cluster manager from informations found
+ * This generic function initialises the local cluster manager from information found
  * in the local boot-info structure. It initializes the following local resources:
  * - the global platform parameters,
@@ -170 +170 @@
  * @ info : pointer on the local boot_info_t structure build by the bootloader.
  *****************************************************************************************/
-error_t cluster_init( boot_info_t * info );         
-
-/******************************************************************************************
- * This function cheks the validity of a cluster identifier. TODO useful ??? [AG]
+error_t cluster_init( boot_info_t * info );
+
+/******************************************************************************************
+ * This function checks the validity of a cluster identifier. TODO useful ??? [AG]
  ******************************************************************************************
  * @ cxy    : cluster identifier to be checked.
@@ -200 +200 @@
 xptr_t cluster_get_reference_process_from_pid( pid_t pid );
 
-/****************************************************************************************** 
+/******************************************************************************************
  * This function allocates a new PID in local cluster, that becomes the process owner.
- * It register the process descriptor extended pointer in the local processs manager 
+ * It registers the process descriptor extended pointer in the local processs manager
  * pref_tbl[] array. This function is called by the rpc_process_alloc_pid() function for
  * remote registration, or by the process_init_create() function for local registration.
@@ -208 +208 @@
  * @ process    : [in]  extended pointer on the process descriptor.
  * @ pid        : [out] allocated PID.
- * @ return 0 if success / return EAGAIN if no PID slot available 
+ * @ return 0 if success / return EAGAIN if no PID slot available
  *****************************************************************************************/
 error_t cluster_pid_alloc( xptr_t    process_xp,
                            pid_t   * pid );
 
-/****************************************************************************************** 
+/******************************************************************************************
  * This function removes a PID from the local process manager pref_tbl[] array.
  * It checks that removed process is owned by the local cluster and the lpid is legal.
@@ -237 +237 @@
  * @ process     : pointer on local process descriptor.
  *****************************************************************************************/
-void cluster_process_local_link( struct process_s * process ); 
+void cluster_process_local_link( struct process_s * process );
 
 /******************************************************************************************
@@ -244 +244 @@
  * @ process     : pointer on local process descriptor.
  *****************************************************************************************/
-void cluster_process_local_unlink( struct process_s * process ); 
+void cluster_process_local_unlink( struct process_s * process );
 
 /******************************************************************************************
@@ -252 +252 @@
  * @ process     : pointer on local process descriptor.
  *****************************************************************************************/
-void cluster_process_copies_link( struct process_s * process ); 
+void cluster_process_copies_link( struct process_s * process );
 
 /******************************************************************************************
@@ -260 +260 @@
  * @ process     : pointer on local process descriptor.
  *****************************************************************************************/
-void cluster_process_copies_unlink( struct process_s * process ); 
+void cluster_process_copies_unlink( struct process_s * process );
 
 

trunk/kernel/kern/core.c

@@ -1 +1 @@
 /*
  * core.c - core descriptor access function.
- * 
+ *
  * Author  Ghassan Almaless (2008,2009,2010,2011,2012)
  *         Mohamed Lamine Karaoui (2015)
@@ -41 +41 @@
 
 /////////////////////////////////
-void core_init( core_t    * core, 
-                lid_t       lid, 
+void core_init( core_t    * core,
+                lid_t       lid,
                 gid_t       gid )
 {
@@ -53 +53 @@
         core->usage             = 0;
         core->spurious_irqs     = 0;
-    core->rpc_threads       = 0;
+        core->rpc_threads       = 0;
 
         rpc_fifo_init( &core->rpc_fifo );
 
-    list_root_init( &core->rpc_free_list );
-
-    core->thread_rpc        = NULL;
-    core->thread_idle       = NULL;
-    core->fpu_owner         = NULL;
+        list_root_init( &core->rpc_free_list );
+
+        core->thread_rpc        = NULL;
+        core->thread_idle       = NULL;
+        core->fpu_owner         = NULL;
         core->rand_last         =  hal_time_stamp() & 0xFFF;
 
@@ -70 +70 @@
 inline uint32_t core_get_rand( core_t * core )
 {
-    uint32_t value  = ((core->rand_last * CONFIG_RDNG_PARAM_A) +
-                        CONFIG_RDNG_PARAM_C) ^ (hal_time_stamp() & 0xFFF);
-    core->rand_last = value;
-    return value;
+        uint32_t value  = ((core->rand_last * CONFIG_RDNG_PARAM_A) +
+                            CONFIG_RDNG_PARAM_C) ^ (hal_time_stamp() & 0xFFF);
+        core->rand_last = value;
+        return value;
 }
 
@@ -79 +79 @@
 inline uint64_t core_get_cycles( core_t * core )
 {
-    uint32_t elapsed;
-    uint64_t cycles;
+        uint32_t elapsed;
+        uint64_t cycles;
         uint32_t time_stamp = core->time_stamp;
         uint32_t time_now   = hal_time_stamp();
-        
+
         // compute number of elapsed cycles, taking into account 32 bits register wrap
         if(time_now < time_stamp) elapsed = (0xFFFFFFFF - time_stamp) + time_now;
         else                      elapsed = (time_now - time_stamp);
 
-    cycles = core->cycles + elapsed;
-
-    // update core time
-    core->time_stamp = time_now;
-    core->cycles     = cycles;
+        cycles = core->cycles + elapsed;
+
+        // update core time
+        core->time_stamp = time_now;
+        core->cycles     = cycles;
         hal_wbflush();
 
@@ -100 +100 @@
 ////////////////////////////////////
 void core_get_time( core_t   * core,
-                    uint32_t * tm_ms, 
+                    uint32_t * tm_ms,
                     uint32_t * tm_us )
 {
         // uint64_t cycles = core_get_cycles( core );
 
-    // TODO ces deux ligne ne compilent pas : "undefined referenc to __udivdi3"
+        // TODO ces deux ligne ne compilent pas : "undefined referenc to __udivdi3"
 
         // *tm_ms = (cycles / CONFIG_CYCLES_PER_MS);
         // *tm_us = (cycles % CONFIG_CYCLES_PER_MS) / (CONFIG_CYCLES_PER_MS / 1000000);
 
-    printk("\n[PANIC] in %s : not implemented yet\n", __FUNCTION__ );
+        printk("\n[PANIC] in %s : not implemented yet\n", __FUNCTION__ );
 }
 
@@ -116 +116 @@
 void core_time_update( core_t * core )
 {
-    uint32_t elapsed;
+        uint32_t elapsed;
         uint32_t ticks_nr   = core->ticks_nr;
         uint64_t cycles     = core->cycles;
@@ -122 +122 @@
         uint32_t time_now   = hal_time_stamp();
 
-    // compute number of elapsed cycles taking into account 32 bits register wrap 
+        // compute number of elapsed cycles taking into account 32 bits register wrap
         if( time_now < time_stamp ) elapsed = (0xFFFFFFFF - time_stamp) + time_now;
         else                        elapsed = time_now - time_stamp;
-    
+
         cycles  += elapsed;
         ticks_nr = elapsed / core->ticks_period;
@@ -140 +140 @@
         uint32_t ticks;
 
-    // update cycles and ticks counter
+        // update cycles and ticks counter
         core_time_update( core );
 
-    // get current ticks number
+        // get current ticks number
         ticks = core->ticks_nr;
 
-    // handle pending alarms TODO ??? [AG]
+        // handle pending alarms TODO ??? [AG]
         // alarm_clock( &core->alarm_mgr , ticks );
 
-    // handle scheduler TODO  improve the scheduling condition ... AG
-    if( (ticks % 10) == 0 ) sched_yield();
-        
-    // update DQDT TODO  This update should depend on the cluster identifier,
-    // to avoid simultaneous updates from various clusters ... AG
+        // handle scheduler TODO  improve the scheduling condition ... AG
+        if( (ticks % 10) == 0 ) sched_yield();
+
+        // update DQDT TODO  This update should depend on the cluster identifier,
+        // to avoid simultaneous updates from various clusters ... AG
         if( ((ticks % CONFIG_DQDT_PERIOD) == 0) && (core->lid == 0) ) dqdt_global_update();
 }
 
 ////////////////////////////////////////
-void core_compute_stats( core_t * core ) 
+void core_compute_stats( core_t * core )
 {
         thread_t * idle  = core->thread_idle;
@@ -167 +167 @@
         uint32_t   usage;
 
-    // compute cumulated usage       
+        // compute cumulated usage
         ticks         = (ticks) ? ticks : 1;
         idle_percent  = (idle->ticks_nr * 100) / ticks;
@@ -174 +174 @@
         usage         = (busy_percent + core->usage) / 2;
 
-    // update core descriptor
+        // update core descriptor
         core->usage = usage;
         hal_wbflush();
@@ -204 +204 @@
                                 chdev_t  * chdev )
 {
-    if     ( irq_type == WTI_TYPE ) core->wti_vector[irq_id] = chdev;
-    else if( irq_type == HWI_TYPE ) core->hwi_vector[irq_id] = chdev;
-    else                            core->pti_vector[irq_id] = chdev;
-}
+        if     ( irq_type == WTI_TYPE ) core->wti_vector[irq_id] = chdev;
+        else if( irq_type == HWI_TYPE ) core->hwi_vector[irq_id] = chdev;
+        else                            core->pti_vector[irq_id] = chdev;
+}

trunk/kernel/kern/core.h

@@ -1 +1 @@
 /*
  * core.h - core descriptor and associated access functions définition
- * 
+ *
  * Authors  Ghassan Almaless (2008,2009,2010,2011,2012)
  *          Mohamed Lamine Karaoui (2015)
@@ -49 +49 @@
 {
         lid_t               lid;            /*! core local index in cluster                */
-        gid_t               gid;            /*! core global identifier (hardware index)    */   
+        gid_t               gid;            /*! core global identifier (hardware index)    */
         uint64_t            cycles;         /*! total number of cycles (from hard reset)   */
         uint32_t            time_stamp;     /*! previous time stamp (read from register)   */
@@ -58 +58 @@
         struct thread_s   * thread_rpc;     /*! pointer on current RPC thread descriptor   */
         struct thread_s   * thread_idle;    /*! pointer on idle thread descriptor          */
-        struct thread_s   * fpu_owner;      /*! pointer on current FPU owner thread        */ 
+        struct thread_s   * fpu_owner;      /*! pointer on current FPU owner thread        */
     uint32_t            rand_last;      /*! last computed random value                 */
         uint32_t            rpc_threads;    /*! total number of RPC threads for this core  */
@@ -71 +71 @@
 
 //      sysfs_entry_t       node;
-} 
+}
 core_t;
 
@@ -87 +87 @@
  ***************************************************************************************
  * @ core      : pointer on core descriptor to initialise.
- * @ lid       : local core index 
+ * @ lid       : local core index
  * @ gid       : global core identifier (hardware index)
  **************************************************************************************/
-void core_init( core_t   * core, 
-                lid_t      lid, 
+void core_init( core_t   * core,
+                lid_t      lid,
                 gid_t      gid );
 
@@ -104 +104 @@
 
 /***************************************************************************************
- * This function returns the current date (cycles) from both 
- * the hardware 32 bits cycles counter and the core descriptor cycles counter, 
+ * This function returns the current date (cycles) from both
+ * the hardware 32 bits cycles counter and the core descriptor cycles counter,
  * taking into account the 32 bits hardware register overflow.
  * The core descriptor time is updated.
@@ -116 +116 @@
 /***************************************************************************************
  * This function returns the current date (seconds & micro-seconds) from both
- * the hardware 32 bits cycles counter and the core descriptor cycles counter, 
+ * the hardware 32 bits cycles counter and the core descriptor cycles counter,
  * taking into account the 32 bits hardware register overflow.
  * The core descriptor time is updated.
@@ -132 +132 @@
  * It updates the  cycles and ticks counter in the calling core descriptor.
  * It handles all pending alarms depending on the ticks counter value.
- * It handles the scheduling, depending on the ticks counter value. 
+ * It handles the scheduling, depending on the ticks counter value.
  * It handles the global DQDT update, depending on the ticks counter vakue.
  ***************************************************************************************
@@ -140 +140 @@
 
 /***************************************************************************************
- * This function updates the usage statistics for the calling core descriptor, 
+ * This function updates the usage statistics for the calling core descriptor,
  * based on the ratio between the idle_ticks and total_ticks.
  ***************************************************************************************
@@ -157 +157 @@
  * This function set/reset a selected entry in one interrupt vector for a remote core.
  * The written value is an extended pointer on the "source" device (or the XPTR_NULL
- * value in case of reset). As it uses remote access, this function can be called by 
+ * value in case of reset). As it uses remote access, this function can be called by
  * any thread in any cluster.
  ***************************************************************************************

trunk/kernel/kern/dqdt.c

@@ -1 +1 @@
 /*
  * dqdt.c - Distributed Quaternary Decision Tree implementation.
- * 
+ *
  * Author : Alain Greiner (2016)
  *
@@ -63 +63 @@
         }
     }
-}  
-    
+}
+
 ////////////////////////////////////
 uint32_t dqdt_init( uint32_t x_size,
@@ -113 +113 @@
         node->children[2] = XPTR_NULL;
         node->children[3] = XPTR_NULL;
- 
+
         // compute masks depending on level : 0x1, 0x3, 0x7, 0xF, 0x1F etc.
         mask  = (1<<level)-1;
@@ -121 +121 @@
         if( ((x & mask) == 0) && ((y & mask) == 0) );
         {
-            // set parent extended pointer 
+            // set parent extended pointer
             p_cxy = ((x & ~pmask)<<y_width) + (y & ~pmask);
             node->parent = XPTR( p_cxy , &cluster->dqdt_tbl[level+1] );
 
-            // set child[0] extended pointer (same [x,y] coordinates) 
+            // set child[0] extended pointer (same [x,y] coordinates)
             if ( level > 0 )
             {
@@ -188 +188 @@
     if ( parent != XPTR_NULL )
     {
-        dqdt_propagate( parent, threads_var, pages_var );          
+        dqdt_propagate( parent, threads_var, pages_var );
     }
 }
@@ -217 +217 @@
 {
         cluster_t * cluster = LOCAL_CLUSTER;
-    
-    // register change for future propagation in DQDT 
+
+    // register change for future propagation in DQDT
     hal_atomic_add( &cluster->threads_var , increment );
 
@@ -229 +229 @@
 {
         cluster_t * cluster = LOCAL_CLUSTER;
-    
-    // register change for future propagation in DQDT 
+
+    // register change for future propagation in DQDT
     hal_atomic_add( &cluster->pages_var , increment );
 
@@ -270 +270 @@
         {
             cxy  = (cxy_t)GET_CXY( child );
-            ptr  = (dqdt_node_t *)GET_PTR( child ); 
+            ptr  = (dqdt_node_t *)GET_PTR( child );
             if( for_memory ) load = hal_remote_lw( XPTR( cxy , &ptr->pages ) );
             else             load = hal_remote_lw( XPTR( cxy , &ptr->threads ) );
@@ -276 +276 @@
             {
                 load_min = load;
-                select   = i; 
-            }      
+                select   = i;
+            }
         }
     }
 
     // select the child with the lowest load
-    return dqdt_select_cluster( node_copy.children[select], for_memory ); 
+    return dqdt_select_cluster( node_copy.children[select], for_memory );
 }
 
@@ -294 +294 @@
 
     // call recursive function
-    return dqdt_select_cluster( root , false ); 
+    return dqdt_select_cluster( root , false );
 }
 
@@ -306 +306 @@
 
     // call recursive function
-    return dqdt_select_cluster( root , true ); 
-}
-
+    return dqdt_select_cluster( root , true );
+}
+

trunk/kernel/kern/dqdt.h

@@ -1 +1 @@
 /*
  * kern/dqdt.h - Distributed Quad Decision Tree
- * 
+ *
  * Author : Alain Greiner (2016)
  *
@@ -35 +35 @@
  * - If X_SIZE or Y_SIZE are equal to 1, it makes the assumption that the cluster
  *   topology is a one dimensionnal vector, an build the smallest one-dimensionnal
- *   quad-tree covering this one-dimensionnal vector. If the number of clusters 
+ *   quad-tree covering this one-dimensionnal vector. If the number of clusters
  *   is not a power of 4, the tree is truncated as required.
  *   TODO : the mapping for the one dimensionnal topology is not implemented yet [AG].
- * 
- * - If both Y_SIZE and Y_SIZE are larger than 1, it makes the assumption that 
- *   the cluster topology is a 2D mesh. The [X,Y] coordinates of a cluster are 
- *   obtained from the CXY identifier using the following rules :  
+ *
+ * - If both Y_SIZE and Y_SIZE are larger than 1, it makes the assumption that
+ *   the cluster topology is a 2D mesh. The [X,Y] coordinates of a cluster are
+ *   obtained from the CXY identifier using the following rules :
  *      X = CXY >> Y_WIDTH   /  Y = CXY & ((1<<Y_WIDTH)-1)
- *   If the mesh X_SIZE and Y_SIZE dimensions are not equal, or are not power of 2, 
+ *   If the mesh X_SIZE and Y_SIZE dimensions are not equal, or are not power of 2,
  *   we build the smallest two dimensionnal quad-tree covering all clusters,
  *   and this tree is truncated as required.
  *   The root node is always implemented in cluster [0,0]
  *   The mesh size is supposed to contain at most 32 * 32 clusters.
- *   There are at most 6 DQDT nodes in a cluster 
+ *   There are at most 6 DQDT nodes in a cluster
  *   . Level 0 nodes exist on all clusters and have no children.
- *   . Level 1 nodes exist when both X and Y coordinates are multiple of 2 
+ *   . Level 1 nodes exist when both X and Y coordinates are multiple of 2
  *   . Level 2 nodes exist when both X and Y coordinates are multiple of 4
  *   . Level 3 nodes exist when both X and Y coordinates are multiple of 8
@@ -76 +76 @@
 
 /****************************************************************************************
- * This local function initializes the local DQDT structures. 
+ * This local function initializes the local DQDT structures.
  * The information describing the hardware platform topology and the cluster
  * indexing policy is defined by the three arguments below.
- * This initialisation is done in parallel, locally in each cluster, because the DQDT 
+ * This initialisation is done in parallel, locally in each cluster, because the DQDT
  * is allocated as a global variable in the cluster_manager, and the local addresses
  * are identical in all clusters.
@@ -118 +118 @@
  * This local function updates both the total number of threads,
  * in the level 0 DQDT node, and the variation of the number of threads
- * for future propagation to the DQDT upper levels. 
+ * for future propagation to the DQDT upper levels.
  * It should be called on each thread creation or destruction.
  ****************************************************************************************
@@ -128 +128 @@
  * This local function updates both the total number of allocated pages,
  * in the level 0 DQDT node, and the variation of the number of pages
- * for future propagation to the DQDT upper levels. 
+ * for future propagation to the DQDT upper levels.
  * It should be called on each memory allocation or release.
  ****************************************************************************************
@@ -146 +146 @@
 /****************************************************************************************
  * This function can be called in any cluster. It traverses the DQDT tree
- * from the root to the bottom, to analyse the memory load and select the cluster 
+ * from the root to the bottom, to analyse the memory load and select the cluster
  * with the lowest memory load for dynamic memory allocation with no locality constraint.
  ****************************************************************************************

trunk/kernel/kern/kernel_init.c

@@ -82 +82 @@
 // This variable defines the local cluster manager 
 __attribute__((section(".kdata")))
-cluster_t            cluster_manager                         CONFIG_CACHE_LINE_ALIGNED; 
+cluster_t            cluster_manager                         CONFIG_CACHE_LINE_ALIGNED;
 
 // This variables define the kernel process0 descriptor
 __attribute__((section(".kdata")))
-process_t            process_zero                            CONFIG_CACHE_LINE_ALIGNED;            
+process_t            process_zero                            CONFIG_CACHE_LINE_ALIGNED;
 
 // This variable defines extended pointers on the distributed chdevs
@@ -197 +197 @@
                 {
                     cxy_t  cxy = (x<<info->y_width) + y;
-                    hal_remote_swd( XPTR( cxy , &chdev_dir.txt[0] ) , 
+                    hal_remote_swd( XPTR( cxy , &chdev_dir.txt[0] ) ,
                                     XPTR( local_cxy , &txt0_chdev ) );
                 }
@@ -204 +204 @@
                     kinit_dmsg("\n[INFO] %s : core[%x][0] created TXT0 chdev"
                        " / paddr = %l at cycle %d\n",
-                       __FUNCTION__ , local_cxy , chdev_func_str( func ), 
+                       __FUNCTION__ , local_cxy , chdev_func_str( func ),
                        XPTR(local_cxy , &txt0_chdev) , hal_time_stamp() );
         }
@@ -257 +257 @@
     // make ICU specific initialisation 
     // TODO remove these three parameters
-    dev_icu_init( chdev_ptr , dev->param0 , dev->param1 , dev->param2 );     
+    dev_icu_init( chdev_ptr , dev->param0 , dev->param1 , dev->param2 );
 
     // initialize the ICU field in the chdev_dir[x][y] structures
@@ -532 +532 @@
                 }  // end if match
 
-                // increment chdev global index (matching or not)            
+                // increment chdev global index (matching or not)
                 chdev_gid++;
 
@@ -608 +608 @@
         uint32_t   i;
     gid_t      global_id;
-    
+
     // get global identifier from hardware register
     global_id = hal_get_gid(); 
@@ -624 +624 @@
     }
     return EINVAL;
-}                      
+}
 
 ///////////////////////////////////////////////////////////////////////////////////////////
 // This function is the entry point for the kernel initialisation.
-// It is executed by all cores in all clusters, but only core[0], called CP0,   
+// It is executed by all cores in all clusters, but only core[0], called CP0,
 // initializes the shared resources such as the cluster manager, or the local peripherals.
-// To comply with the multi-kernels paradigm, it access only local cluster memory, using
-// only informations contained in the local boot_info_t structure, set by the bootloader.
+// To comply with the multi-kernels paradigm, it accesses only local cluster memory, using
+// only information contained in the local boot_info_t structure, set by the bootloader.
 ///////////////////////////////////////////////////////////////////////////////////////////
 // @ info    : pointer on the local boot-info structure.
@@ -681 +681 @@
     }
 
-    // CP0 initialize local cluster manager (cores and memory allocators)
+    // CP0 initializes the local cluster manager (cores and memory allocators)
     if( core_lid == 0 )
     {
@@ -713 +713 @@
         core    = &cluster->core_tbl[core_lid];
 
-    // CP0 initialize process_zero descriptor
+    // CP0 initializes the process_zero descriptor
     if( core_lid == 0 ) process_zero_init( info );
 
-    // CP0 allocate and initialise internal peripheral chdev descriptors.
+    // CP0 allocates and initialises the internal peripheral chdev descriptors.
     // Each CP0[cxy] scan the set of its internal (private) peripherals,
     // and allocate memory for the corresponding chdev descriptors.