Changeset 438 for trunk/kernel/syscalls/sys_fork.c

Timestamp:

Apr 4, 2018, 2:49:02 PM (7 years ago)

Author:

alain

Message:

Fix a bug in scheduler related to RPC blocking.

File:

• trunk/kernel/syscalls/sys_fork.c (modified) (7 diffs)

trunk/kernel/syscalls/sys_fork.c

@@ -45 +45 @@
     pid_t             parent_pid;           // parent process identifier
     thread_t        * parent_thread_ptr;    // local pointer on local parent thread descriptor
+    cxy_t             parent_cxy;           // parent thread cluster
 
     pid_t             child_pid;            // child process identifier
     thread_t        * child_thread_ptr;     // local pointer on remote child thread descriptor
-    cxy_t             target_cxy;           // target cluster for forked child process 
+    cxy_t             child_cxy;            // target cluster for forked child process 
  
     xptr_t            ref_process_xp;       // extended pointer on reference parent process
@@ -62 +63 @@
         parent_process_ptr = parent_thread_ptr->process;
     parent_pid         = parent_process_ptr->pid;
-
-#if CONFIG_DEBUG_SYS_FORK
+    parent_cxy         = local_cxy;
+
+#if DEBUG_SYS_FORK
 uint64_t          tm_start;
 uint64_t          tm_end;
 tm_start = hal_get_cycles();
-if( CONFIG_DEBUG_SYS_FORK < tm_start )
-printk("\n[DBG] %s : thread %x enter / parent %x / cycle =  %d\n",
+if( DEBUG_SYS_FORK < tm_start )
+printk("\n[DBG] %s : parent_thread %x enter / parent_pid %x / cycle =  %d\n",
 __FUNCTION__, parent_thread_ptr, parent_pid, (uint32_t)tm_start );
 #endif
 
-    // get infos on reference process
+    // get infos on reference parent process
     ref_process_xp  = parent_process_ptr->ref_xp;
     ref_process_cxy = GET_CXY( ref_process_xp );
@@ -82 +84 @@
         {
 
-#if CONFIG_DEBUG_SYSCALLS_ERROR
+#if DEBUG_SYSCALLS_ERROR
 printk("\n[ERROR] in %s : too much children processes\n", __FUNCTION__);
 #endif
@@ -91 +93 @@
 
     // Select target cluster for child process and main thread.
-    // If placement is not user-defined, the placement is defined by the DQDT. 
-        if( parent_thread_ptr->fork_user )    // user defined placement
-        {
-        target_cxy = parent_thread_ptr->fork_cxy;
+    // If placement is not user-defined, it is defined by the DQDT. 
+        if( parent_thread_ptr->fork_user )
+        {
+        child_cxy = parent_thread_ptr->fork_cxy;
         parent_thread_ptr->fork_user = false;
         }
         else                                  // DQDT placement
         {
-                target_cxy = dqdt_get_cluster_for_process();
-        }
+                child_cxy = dqdt_get_cluster_for_process();
+        }
+
+#if( DEBUG_SYS_FORK & 1)
+
+// dqdt_display();
+
+if( local_cxy == 0 )
+{
+    sched_display( 0 );
+    rpc_sched_display_client( 1 , 0 );
+}
+else
+{
+    sched_display( 0 );
+    rpc_sched_display_client( 0 , 0 );
+}
+
+if( DEBUG_SYS_FORK < tm_start )
+printk("\n[DBG] %s : parent_thread %x selected cluster %x\n",
+__FUNCTION__, parent_thread_ptr, child_cxy );
+#endif
 
     // call process_make_fork in target cluster
-    if( target_cxy == local_cxy )
+    if( child_cxy == local_cxy )
     {
         error = process_make_fork( ref_process_xp,
@@ -112 +134 @@
     else
     {
-        rpc_process_make_fork_client( target_cxy,
+        rpc_process_make_fork_client( child_cxy,
                                       ref_process_xp,
                                       parent_thread_xp,
@@ -123 +145 @@
     {
 
-#if CONFIG_DEBUG_SYSCALLS_ERROR
+#if DEBUG_SYSCALLS_ERROR
 printk("\n[ERROR] in %s : cannot fork process %x in cluster %x\n",
 __FUNCTION__, parent_pid, local_cxy );
@@ -135 +157 @@
         if( CURRENT_THREAD->core->fpu_owner == parent_thread_ptr )
         {
-                hal_fpu_context_save( XPTR( target_cxy , child_thread_ptr ) );
-        }
-
-    // set remote child CPU context from  parent_thread register values
-    hal_cpu_context_fork( XPTR( target_cxy , child_thread_ptr ) );
-
-    // From this point, both parent and child threads execute the following code.
-    // They can be distinguished by the CURRENT_THREAD value, and child will only 
-    // execute it when it is unblocked by parent.
+                hal_fpu_context_save( XPTR( child_cxy , child_thread_ptr ) );
+        }
+
+    // set remote child CPU context from parent_thread register values
+    hal_cpu_context_fork( XPTR( child_cxy , child_thread_ptr ) );
+
+    // From this point, both parent and child threads execute the following code,
+    // but they can be distinguished by the (CURRENT_THREAD,local_cxy) values.
     // - parent unblock child, and return child PID to user application.
     // - child thread does nothing, and return 0 to user pplication 
+    // The child thread will only execute it when it is unblocked by parent thread.
 
     thread_t * current = CURRENT_THREAD;
 
-    if( current == parent_thread_ptr )    // current == parent thread
+    if( (current == parent_thread_ptr) && (local_cxy == parent_cxy) )   // parent thread
     {
         // parent_thread unblock child_thread
-        thread_unblock( XPTR( target_cxy , child_thread_ptr ) , THREAD_BLOCKED_GLOBAL );
-
-#if CONFIG_DEBUG_SYS_FORK
+        thread_unblock( XPTR( child_cxy , child_thread_ptr ) , THREAD_BLOCKED_GLOBAL );
+
+#if DEBUG_SYS_FORK
 tm_end = hal_get_cycles();
-if( CONFIG_DEBUG_SYS_FORK < tm_end )
-printk("\n[DBG] %s : parent_thread %x exit / cost = %d / cycle %d\n",
-__FUNCTION__ , parent_thread_ptr, (uint32_t)(tm_end - tm_start), (uint32_t)tm_end );
+if( DEBUG_SYS_FORK < tm_end )
+printk("\n[DBG] %s : parent_thread %x on cluster %x exit / cost = %d / cycle %d\n",
+__FUNCTION__, parent_thread_ptr, parent_cxy, (uint32_t)(tm_end - tm_start), (uint32_t)tm_end );
 #endif
 
         return child_pid;
     }
-        else                                   // current == child_thread
-    {
-
-#if CONFIG_DEBUG_SYS_FORK
+        else                                                               // child_thread
+    {
+
+#if DEBUG_SYS_FORK
 tm_end = hal_get_cycles();
-if( CONFIG_DEBUG_SYS_FORK < tm_end )
-printk("\n[DBG] %s : child_thread %x exit / cost = %d / cycle %d\n",
-__FUNCTION__ , child_thread_ptr, (uint32_t)(tm_end - tm_start), (uint32_t)tm_end );
+if( DEBUG_SYS_FORK < tm_end )
+printk("\n[DBG] %s : child_thread %x on cluster %x exit / cost = %d / cycle %d\n",
+__FUNCTION__, child_thread_ptr, child_cxy, (uint32_t)(tm_end - tm_start), (uint32_t)tm_end );
 #endif