Index: trunk/kernel/kern/dqdt.h
===================================================================
--- trunk/kernel/kern/dqdt.h	(revision 632)
+++ trunk/kernel/kern/dqdt.h	(revision 637)
@@ -2,5 +2,5 @@
  * kern/dqdt.h - Distributed Quad Decision Tree
  *
- * Author : Alain Greiner (2016,2017,2018)
+ * Author : Alain Greiner (2016,2017,2018,2019)
  *
  * Copyright (c)  UPMC Sorbonne Universites
@@ -31,34 +31,23 @@
 /****************************************************************************************
  * This DQDT infrastructure maintains a topological description of ressources usage
- * in each cluster: number of threads, and number of physical pages allocated.
+ * in each cluster: number of threads per core, and number of physical pages allocated.
  *
- * - 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
- *   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 clusters topology is a 2D mesh. The [X,Y] coordinates of a cluster are
- *   obtained from the CXY identifier using the Rrelevant macros.
- *      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,
- *   or the mesh contains "holes" reported in the cluster_info[x][y] array,
- *   we build the smallest two dimensionnal quad-tree covering all clusters,
- *   and this tree is truncated as required.
- * - The mesh size is supposed to contain at most 32 * 32 clusters.
- *   Therefore, it can exist at most 6 DQDT nodes in a given 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 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
- *   . Level 4 nodes exist when both X and Y coordinates are multiple of 16
- *   . Level 5 nodes exist when both X and Y coordinates are multiple of 32
- * - For nodes other than level 0, the placement is defined as follow:
- *   . The root node is placed in the cluster containing the core executing 
- *     the dqdt_init() function.
- *   . An intermediate node (representing a given sub-tree) is placed in one
- *     cluster covered by the subtree, pseudo-randomly selected.
+ * It is organized as a quad-tree, where the leaf cells are the clusters, organised
+ * as a 2D mesh. Each node in the quad-tree (including the root and the leaf cells,
+ * covers a "macro-cluster", that is a square array of clusters where the number
+ * in the macro-cluster is a power of 4, and the macro-cluster side is a power of two.
+ * Each node contains informations on ressources usage (physical memory and cores)
+ * in the covered macro-cluster.
+ * This quad-tree can be truncated, if the physical mesh X_SIZE and Y_SIZE dimensions
+ * are not equal, or are not power of 2, or if the physical mesh contains "holes".
+ * The mesh size is supposed to contain at most 32*32 clusters in this implementation.
+ *   . Level 0 nodes exist in all clusters and have no children.
+ *   . Level 1 nodes can be placed in any cluster of the covered  2*2  macro-cluster.
+ *   . Level 2 nodes can be placed in any cluster of the covered  4*4  macro-cluster.
+ *   . Level 3 nodes can be placed in any cluster of the covered  8*8  macro-cluster.
+ *   . Level 4 nodes can be placed in any cluster of the covered 16*16 macro-cluster.
+ *   . Level 5 nodes can be placed in any cluster of the covered 32*32 macro-cluster.
+ * The root node is placed in the cluster containing the core executing the dqdt_init()
+ * function. Other (non level 0) nodes are placed pseudo-randomly.
  ***************************************************************************************/
 
@@ -66,6 +55,5 @@
  * This structure describes a node of the DQDT.
  * The max number of children is 4, but it can be smaller for some nodes.
- * Level 0 nodes are the clusters, and have no children.
- * The root node has no parent.
+ * Level 0 nodes have no children. The root node has no parent.
  ***************************************************************************************/
 
@@ -74,8 +62,8 @@
 	uint32_t      level;            /*! node level                                     */
 	uint32_t      arity;            /*! actual children number in this node            */
-    uint32_t      threads;          /*! current number of threads in macro-cluster     */
-    uint32_t      pages;            /*! current number of pages in macro-cluster       */
+    uint32_t      threads;          /*! number of threads in macro-cluster             */
+    uint32_t      pages;            /*! number of allocated pages in macro-cluster     */
     uint32_t      cores;            /*! number of active cores in macro cluster        */
-    uint32_t      clusters;         /*! number of active cluster in macro cluster      */ 
+    uint32_t      clusters;         /*! number of active clusters in macro cluster     */ 
 	xptr_t        parent;           /*! extended pointer on parent node                */
 	xptr_t        children[2][2];   /*! extended pointers on children nodes            */
@@ -87,5 +75,5 @@
  * This function recursively initializes the DQDT structure from informations
  * stored in cluster manager (x_size, y_size and cluster_info[x][y].
- * It is executed in all clusters by the local CP0, to compute level_max and register
+ * It is called in all clusters by the local CP0, to compute level_max and register
  * the DQDT root node in each cluster manager, but only CPO in cluster 0 build actually
  * the quad-tree covering all active clusters.
@@ -102,4 +90,5 @@
  ***************************************************************************************/
 void dqdt_increment_threads( void );
+
 void dqdt_decrement_threads( void );
 
@@ -121,25 +110,42 @@
 
 /****************************************************************************************
- * This function can be called in any cluster. It traverses the DQDT tree
- * from the root to the bottom, to analyse the computing load and select the cluster
- * with the lowest number ot threads to place a new process.
+ * This function returns an extended pointer on the dqdt node that is the root of
+ * the sub-tree covering the macro-cluster defined by the <level> argument and
+ * containing the cluster defined by the <cxy> argument. It returns XPTR_NULL if
+ * this macro-cluster is undefined (when the cxy cluster contains no core).
  ****************************************************************************************
+ * @ cxy   : cluster identifier.
+ * @ level   : level of the sub-tree.
+ * @ returns  root_xp if success / return XPTR_NULL if no active core in macro_cluster.
+ ***************************************************************************************/
+xptr_t dqdt_get_root( cxy_t    cxy,
+                      uint32_t level );
+
+/****************************************************************************************
+ * This function can be called in any cluster. It traverses the DQDT tree from the
+ * local root of a macro-cluster, defined by the <root_xp> argument, to the bottom.
+ * It analyses the computing load & select the cluster containing the lowest number
+ * ot threads.
+ ****************************************************************************************
+ * @ root_xp  : extended pointer on DQDT node root.
  * @ returns the cluster identifier with the lowest computing load.
  ***************************************************************************************/
-cxy_t dqdt_get_cluster_for_process( void );
+cxy_t dqdt_get_cluster_for_thread( xptr_t root_xp );
 
 /****************************************************************************************
- * 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
- * with the lowest memory load for dynamic memory allocation with no locality constraint.
+ * This function can be called in any cluster. It traverses the DQDT tree from the
+ * local root of a macro-cluster, defined by the <root_xp> argument, to the bottom.
+ * It analyses the memory load & select the cluster with the lowest number of allocated
+ * physical pages.
  ****************************************************************************************
+ * @ root_xp  : extended pointer on DQDT node root.
  * @ returns the cluster identifier with the lowest memory load.
  ***************************************************************************************/
-cxy_t dqdt_get_cluster_for_memory( void );
+cxy_t dqdt_get_cluster_for_memory( xptr_t root_xp );
 
 /****************************************************************************************
  * This function displays on kernel TXT0 the DQDT state for all nodes in the quad-tree.
- * It traverses the quadtree from root to bottom, and can be called by a thread 
- * running in any cluster
+ * It traverses the quadtree from the global root to bottom.
+ * It can be called by a thread running in any cluster
  ***************************************************************************************/
 void dqdt_display( void );
