Changeset 438 for trunk/kernel/kern/dqdt.c

Timestamp:

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

Author:

alain

Message:

Fix a bug in scheduler related to RPC blocking.

File:

• trunk/kernel/kern/dqdt.c (modified) (6 diffs)

trunk/kernel/kern/dqdt.c

@@ -28 +28 @@
 #include <hal_remote.h>
 #include <printk.h>
+#include <chdev.h>
 #include <cluster.h>
 #include <bits.h>
@@ -33 +34 @@
 
 
-///////////////////////////////////////////
-void dqdt_local_print( dqdt_node_t * node )
-{
-        printk("DQDT node : level = %d / cluster = %x / threads = %x / pages = %x\n",
-               node->level,
-               local_cxy,
-               node->threads,
-           node->pages );
-}
-
-/////////////////////////////////////////
-void dqdt_global_print( xptr_t  node_xp )
+///////////////////////////////////////////////////////////////////////////////////////////
+//      Extern variables
+///////////////////////////////////////////////////////////////////////////////////////////
+
+extern chdev_directory_t  chdev_dir;  // defined in chdev.h / allocated in kernel_init.c
+
+
+///////////////////////////////////////////////////////////////////////////////////////////
+// This static recursive function traverse the DQDT quad-tree from root to bottom.
+///////////////////////////////////////////////////////////////////////////////////////////
+static void dqdt_recursive_print( xptr_t  node_xp )
 {
         uint32_t i;
-    dqdt_node_t local_node;
-
-    // get root node local copy
-    hal_remote_memcpy( XPTR( local_cxy , &local_node ), node_xp , sizeof(dqdt_node_t) );
-
-    // display DQDT node content
-    dqdt_local_print( &local_node );
+    dqdt_node_t node;
+
+    // get node local copy
+    hal_remote_memcpy( XPTR( local_cxy , &node ), node_xp , sizeof(dqdt_node_t) );
+
+    // display node content
+        nolock_printk("- level %d in cluster %x (node %x) : threads = %x / pages = %x\n",
+    node.level, GET_CXY( node_xp ), GET_PTR( node_xp ), node.threads, node.pages );
 
     // recursive call on children if node is not terminal
-    if ( local_node.level > 0 )
+    if ( node.level > 0 )
     {
         for ( i = 0 ; i < 4 ; i++ )
         {
-            if ( local_node.children[i] != XPTR_NULL ) 
-                dqdt_global_print( local_node.children[i] );
+            if ( node.children[i] != XPTR_NULL ) dqdt_recursive_print( node.children[i] );
         }
     }
+}
+
+///////////////////
+void dqdt_display()
+{
+    reg_t   save_sr;
+
+    // build extended pointer on DQDT root node
+        cluster_t * cluster = LOCAL_CLUSTER;
+    uint32_t    level   = cluster->dqdt_root_level;
+    xptr_t      root_xp = XPTR( 0 , &cluster->dqdt_tbl[level] );
+
+    // get pointers on TXT0 chdev
+    xptr_t    txt0_xp  = chdev_dir.txt_tx[0];
+    cxy_t     txt0_cxy = GET_CXY( txt0_xp );
+    chdev_t * txt0_ptr = GET_PTR( txt0_xp );
+
+    // get extended pointer on remote TXT0 chdev lock
+    xptr_t  lock_xp = XPTR( txt0_cxy , &txt0_ptr->wait_lock );
+
+    // get TXT0 lock in busy waiting mode
+    remote_spinlock_lock_busy( lock_xp , &save_sr );
+
+    // print header
+    nolock_printk("\n***** DQDT state\n\n");
+
+    // call recursive function
+    dqdt_recursive_print( root_xp );
+
+    // release lock
+    remote_spinlock_unlock_busy( lock_xp , save_sr );
 }
 
@@ -161 +192 @@
 } // end dqdt_init()
 
-
-///////////////////////////////////////////////////////////////////////////
-// This recursive function is called by the dqdt_global_update() function.
+///////////////////////////////////////////////////////////////////////////
+// This recursive function is called by the dqdt_update_threads() function.
 // It traverses the quad tree from clusters to root.
 ///////////////////////////////////////////////////////////////////////////
-static void dqdt_propagate( xptr_t  node,         // extended pointer on current node
-                            int32_t threads_var,  // number of threads variation
-                            int32_t pages_var )   // number of pages variation
+// @ node       : extended pointer on current node
+// @ increment  : number of threads variation
+///////////////////////////////////////////////////////////////////////////
+static void dqdt_propagate_threads( xptr_t  node,
+                                    int32_t increment )
 {
     // get current node cluster identifier and local pointer
-    cxy_t         cxy = (cxy_t)GET_CXY( node );
-    dqdt_node_t * ptr = (dqdt_node_t *)GET_PTR( node );
+    cxy_t         cxy = GET_CXY( node );
+    dqdt_node_t * ptr = GET_PTR( node );
 
     // update current node threads number
-    hal_remote_atomic_add( XPTR( cxy , &ptr->threads ) , threads_var );
-
-    // update current node pages number
-    hal_remote_atomic_add( XPTR( cxy , &ptr->pages ) , pages_var );
+    hal_remote_atomic_add( XPTR( cxy , &ptr->threads ) , increment );
 
     // get extended pointer on parent node
@@ -184 +213 @@
 
     // propagate if required
-    if ( parent != XPTR_NULL )
-    {
-        dqdt_propagate( parent, threads_var, pages_var );
-    }
-}
-
-/////////////////////////
-void dqdt_global_update()
+    if ( parent != XPTR_NULL ) dqdt_propagate_threads( parent, increment );
+}
+
+///////////////////////////////////////////////////////////////////////////
+// This recursive function is called by the dqdt_update_pages() function.
+// It traverses the quad tree from clusters to root.
+///////////////////////////////////////////////////////////////////////////
+// @ node       : extended pointer on current node
+// @ increment  : number of pages variation
+///////////////////////////////////////////////////////////////////////////
+static void dqdt_propagate_pages( xptr_t  node,
+                                  int32_t increment )
+{
+    // get current node cluster identifier and local pointer
+    cxy_t         cxy = GET_CXY( node );
+    dqdt_node_t * ptr = GET_PTR( node );
+
+    // update current node threads number
+    hal_remote_atomic_add( XPTR( cxy , &ptr->pages ) , increment );
+
+    // get extended pointer on parent node
+    xptr_t parent = (xptr_t)hal_remote_lwd( XPTR( cxy , &ptr->parent ) );
+
+    // propagate if required
+    if ( parent != XPTR_NULL ) dqdt_propagate_pages( parent, increment );
+}
+
+/////////////////////////////////////////////
+void dqdt_update_threads( int32_t increment )
 {
         cluster_t   * cluster = LOCAL_CLUSTER;
     dqdt_node_t * node    = &cluster->dqdt_tbl[0];
 
-    // get variations
-    int32_t      threads_var = cluster->threads_var;
-    int32_t      pages_var   = cluster->pages_var;
-
-    // propagate this variation to DQDT upper levels
-    if( (threads_var || pages_var) && (node->parent != XPTR_NULL) )
-    {
-        dqdt_propagate( node->parent, threads_var, pages_var );
-    }
-
-    // update variations
-    hal_atomic_add( &cluster->threads_var , -threads_var );
-    hal_atomic_add( &cluster->pages_var   , -pages_var   );
-}
-
-///////////////////////////////////////////////////
-void dqdt_local_update_threads( int32_t increment )
-{
-        cluster_t * cluster = LOCAL_CLUSTER;
-
-    // register change for future propagation in DQDT
-    hal_atomic_add( &cluster->threads_var , increment );
-
     // update DQDT node level 0
-    hal_atomic_add( &cluster->dqdt_tbl[0].threads , increment );
-}
-
-/////////////////////////////////////////////////
-void dqdt_local_update_pages( int32_t increment )
-{
-        cluster_t * cluster = LOCAL_CLUSTER;
-
-    // register change for future propagation in DQDT
-    hal_atomic_add( &cluster->pages_var , increment );
+    hal_atomic_add( &node->threads , increment );
+
+    // propagate to DQDT upper levels
+    if( node->parent != XPTR_NULL ) dqdt_propagate_threads( node->parent , increment );
+}
+
+///////////////////////////////////////////
+void dqdt_update_pages( int32_t increment )
+{
+        cluster_t   * cluster = LOCAL_CLUSTER;
+    dqdt_node_t * node    = &cluster->dqdt_tbl[0];
 
     // update DQDT node level 0
-    hal_atomic_add( &cluster->dqdt_tbl[0].pages , increment );
-}
+    hal_atomic_add( &node->pages , increment );
+
+    // propagate to DQDT upper levels
+    if( node->parent != XPTR_NULL ) dqdt_propagate_pages( node->parent , increment );
+}
+
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -289 +321 @@
         cluster_t * cluster = LOCAL_CLUSTER;
     uint32_t    level   = cluster->dqdt_root_level;
-    xptr_t      root    = XPTR( 0 , &cluster->dqdt_tbl[level] );
+    xptr_t      root_xp = XPTR( 0 , &cluster->dqdt_tbl[level] );
 
     // call recursive function
-    return dqdt_select_cluster( root , false );
+    return dqdt_select_cluster( root_xp , false );
 }
 
@@ -301 +333 @@
         cluster_t * cluster = LOCAL_CLUSTER;
     uint32_t    level   = cluster->dqdt_root_level;
-    xptr_t      root    = XPTR( 0 , &cluster->dqdt_tbl[level] );
+    xptr_t      root_xp = XPTR( 0 , &cluster->dqdt_tbl[level] );
 
     // call recursive function
-    return dqdt_select_cluster( root , true );
-}
-
+    return dqdt_select_cluster( root_xp , true );
+}
+