Changeset 367 for trunk/kernel/kern

Timestamp:

Aug 14, 2017, 11:39:03 AM (7 years ago)

Author:

alain

Message:

Change Time unit from cycle to TICK (in millisecond).
Fix several bugs in VFS.

Location:

trunk/kernel/kern

Files:

• core.c (modified) (5 diffs)
• core.h (modified) (1 diff)
• printk.h (modified) (1 diff)
• process.c (modified) (4 diffs)
• thread.c (modified) (1 diff)
• thread.h (modified) (2 diffs)

trunk/kernel/kern/core.c

@@ -47 +47 @@
         core->time_stamp        = 0;
         core->ticks_nr          = 0;
-        core->ticks_period      = CONFIG_SCHED_TICK_PERIOD;
         core->usage             = 0;
         core->spurious_irqs     = 0;
@@ -72 +71 @@
                     uint32_t * tm_us )
 {
-        uint64_t cycles = hal_get_cycles();
-
-        *tm_s  = (cycles / CONFIG_CYCLES_PER_MS);
-        *tm_us = (cycles % CONFIG_CYCLES_PER_MS) / (CONFIG_CYCLES_PER_MS / 1000000);
+        *tm_s  = (core->ticks_nr*CONFIG_SCHED_TICK_PERIOD)/1000;
+        *tm_us = (core->ticks_nr*CONFIG_SCHED_TICK_PERIOD*1000)%1000000;
 }
 
+/* deprecated 14/08/2017 [AG]
 //////////////////////////////////////
 void core_time_update( core_t * core )
@@ -99 +97 @@
         hal_fence();
 }
+*/
 
 ////////////////////////////////
@@ -105 +104 @@
         uint32_t ticks;
 
-        // update cycles and ticks counter
-        core_time_update( core );
-
-        // get current ticks number
-        ticks = core->ticks_nr;
+        // update ticks counter
+        ticks = core->ticks_nr++;
 
         // 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( NULL );
-
-/*
-    // compute elapsed time, taking into account 32 bits register wrap
-    uint32_t elapsed;
-    uint32_t time_now   = hal_get_cycles();
-    uint32_t time_last  = this->time_last_check;
-    if( time_now < time_last ) elapsed = (0xFFFFFFFF - time_last) + time_now;
-        else                       elapsed = time_now - time_last;
-
-    // update thread time
-    this->time_last_check = time_now;
-
-        // check elapsed time
-        if( elapsed < CONFIG_CORE_CHECK_EVERY ) return false;
-    else                                    return true;
-*/
+        // handle scheduler
+        if( (ticks % CONFIG_SCHED_TICKS_PER_QUANTUM) == 0 ) sched_yield( NULL );
 
         // 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();
+        if( ((ticks % CONFIG_DQDT_TICKS_PER_QUANTUM) == 0) && (core->lid == 0) )
+        dqdt_global_update();
 }
 
@@ -171 +152 @@
 void core_reset_stats( core_t * core )
 {
-        core_time_update(core);
-
         core->ticks_nr              = 0;
         core->usage                 = 0;

trunk/kernel/kern/core.h

@@ -50 +50 @@
         lid_t               lid;            /*! core local index in cluster                */
         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)   */
+
         uint32_t            ticks_nr;       /*! number of elapsed ticks                    */
-        uint32_t            ticks_period;   /*! number of cycles between two ticks         */
         uint32_t            usage;          /*! cumulated busy_percent (idle / total)      */
         uint32_t            spurious_irqs;  /*! for instrumentation...                     */

trunk/kernel/kern/printk.h

@@ -250 +250 @@
 
 #if CONFIG_RPC_DEBUG
-#define rpc_dmsg(...)   printk(__VA_ARGS__)
+#define rpc_dmsg(...)   if(hal_time_stamp() > CONFIG_RPC_DEBUG) printk(__VA_ARGS__) 
 #else
 #define rpc_dmsg(...)

trunk/kernel/kern/process.c

@@ -632 +632 @@
     parent_pid = hal_remote_lw( XPTR( parent_cxy , &parent_ptr->pid ) );
 
-    exec_dmsg("\n[INFO] %s : enters in cluster %x for path = %s\n",
-                __FUNCTION__ , local_cxy , path );
+    exec_dmsg("\n[INFO] %s : thread %x on core[%x,‰d] enters for path = %s\n",
+    __FUNCTION__, CURRENT_THREAD->trdid, local_cxy, CURRENT_THREAD->core->lid, path );
 
     // create new process descriptor
@@ -659 +659 @@
     process_reference_init( process , pid , parent_xp );
 
-    exec_dmsg("\n[INFO] %s : created process %x in cluster %x / path = %s\n",
-                __FUNCTION__, pid , local_cxy , path );
+    exec_dmsg("\n[INFO] %s : thread %x on core[%x,‰d] created process %x / path = %s\n",
+    __FUNCTION__, CURRENT_THREAD->trdid, local_cxy, CURRENT_THREAD->core->lid, pid, path );
 
     // initialize vfs_root and vfs_cwd from parent process
@@ -676 +676 @@
 
     exec_dmsg("\n[INFO] %s : fd_array copied from process %x to process %x\n",
-                __FUNCTION__, parent_pid , pid );
+    __FUNCTION__, parent_pid , pid );
 
         // initialize signal manager TODO ??? [AG]
@@ -693 +693 @@
         }
 
-    exec_dmsg("\n[INFO] %s : code and data vsegs from <%s> registered for process %x\n",
-                __FUNCTION__ , path , pid );
+    exec_dmsg("\n[INFO] %s : code and data vsegs registered for process %x / path = %s\n",
+    __FUNCTION__ , pid , path );
 
     // select a core in cluster

trunk/kernel/kern/thread.c

@@ -638 +638 @@
 {
     thread_t * this = CURRENT_THREAD;
-    return ( (this->local_locks == 0) && (this->remote_locks == 0) );
-}
-
-///////////////////////////
-bool_t thread_check_sched()
+    return (this->local_locks == 0) && (this->remote_locks == 0);
+}
+
+/////////////////////////
+void thread_check_sched()
 {
     thread_t * this = CURRENT_THREAD;
 
-    // check locks count
-    if( (this->local_locks != 0) || (this->remote_locks != 0) )
-        return false;
-
-    if( this->flags & THREAD_FLAG_SCHED )
+        if( (this->local_locks == 0) && 
+        (this->remote_locks == 0) &&
+        (this->flags & THREAD_FLAG_SCHED) ) 
+    {
+        this->flags &= ~THREAD_FLAG_SCHED;
         sched_yield( NULL );
-
-    return true;
-
-#if 0
-    // compute elapsed time, taking into account 32 bits register wrap
-    uint32_t elapsed;
-    uint32_t time_now   = hal_get_cycles();
-    uint32_t time_last  = this->time_last_check;
-    if( time_now < time_last ) elapsed = (0xFFFFFFFF - time_last) + time_now;
-        else                       elapsed = time_now - time_last;
-
-    // update thread time
-    this->time_last_check = time_now;
-
-        // check elapsed time
-        if( elapsed < CONFIG_CORE_CHECK_EVERY ) return false;
-    else                                    return true;
-#endif
+    }
 }
 

trunk/kernel/kern/thread.h

@@ -368 +368 @@
  ***************************************************************************************
  * @ thread    : local pointer on target thread.
- * @ mask      : mask on selected signal.
+ *s released all locks @ mask      : mask on selected signal.
  **************************************************************************************/
 inline void thread_set_signal( thread_t * thread,
@@ -400 +400 @@
 
 /***************************************************************************************
- * This function checks if the calling thread must be descheduled.
- ***************************************************************************************
- * @ returns true if no locks taken, and elapsed time.
- **************************************************************************************/
-bool_t thread_check_sched();
+ * This function implements the delayed descheduling machanism : It is called  by 
+ * all lock release functions, and calls the sched_yield() function when all locks 
+ * have beeen released and the THREAD_FLAG_SCHED flag is set. 
+ **************************************************************************************/
+void thread_check_sched();
 
 /***************************************************************************************