LU-1144 ptlrpc: implement a NUMA aware ptlrpcd binding policy

This is a complement to the ORNL-22 general ptlrpcd threads pool
support.

This patch improves the PDB_POLICY_NEIGHBOR ptlrpcd binding policy,
when the kernel supports NUMA. In that case, the ptlrpcd threads are
all binded and have threads in the same NUMA node setup as partners.

Signed-off-by: Gregoire Pichon <gregoire.pichon@bull.net>
Change-Id: I8eb553d6f25fac6fd64faf1eecfa4dfae5ed15ee
Reviewed-on: http://review.whamcloud.com/2212
Tested-by: Hudson
Reviewed-by: Andreas Dilger <adilger@whamcloud.com>
Tested-by: Maloo <whamcloud.maloo@gmail.com>
Reviewed-by: Fan Yong <yong.fan@whamcloud.com>
Reviewed-by: Oleg Drokin <green@whamcloud.com>
Reviewed-by: Liang Zhen <liang@whamcloud.com>

diff --git a/lustre/include/lustre_net.h b/lustre/include/lustre_net.h
index 47ebfe7..41acb98 100644 (file)
--- a/lustre/include/lustre_net.h
+++ b/lustre/include/lustre_net.h
@@ -1925,7 +1925,9 @@ typedef enum {
         /* <free1 bound1> <free2 bound2> ... <freeN boundN> */
         PDB_POLICY_PAIR          = 3,
         /* <free1 bound1> <bound1 free2> ... <freeN boundN> <boundN free1>,
         /* <free1 bound1> <free2 bound2> ... <freeN boundN> */
         PDB_POLICY_PAIR          = 3,
         /* <free1 bound1> <bound1 free2> ... <freeN boundN> <boundN free1>,

-         * means each ptlrpcd[X] has two partners: thread[X-1] and thread[X+1]*/
+         * means each ptlrpcd[X] has two partners: thread[X-1] and thread[X+1].
+         * If kernel supports NUMA, pthrpcd threads are binded and
+         * grouped by NUMA node */

         PDB_POLICY_NEIGHBOR      = 4,
 } pdb_policy_t;
 
         PDB_POLICY_NEIGHBOR      = 4,
 } pdb_policy_t;
 

diff --git a/lustre/ptlrpc/ptlrpcd.c b/lustre/ptlrpc/ptlrpcd.c
index 4add2d7..4f646a1 100644 (file)
--- a/lustre/ptlrpc/ptlrpcd.c
+++ b/lustre/ptlrpc/ptlrpcd.c
@@ -523,6 +523,11 @@ static int ptlrpcd_bind(int index, int max)
 {
         struct ptlrpcd_ctl *pc;
         int rc = 0;
 {
         struct ptlrpcd_ctl *pc;
         int rc = 0;

+#if defined(CONFIG_NUMA) && defined(HAVE_NODE_TO_CPUMASK)
+        struct ptlrpcd_ctl *ppc;
+        int node, i, pidx;
+        cpumask_t mask;
+#endif

         ENTRY;
 
         LASSERT(index <= max - 1);
         ENTRY;
 
         LASSERT(index <= max - 1);


@@ -540,8 +545,17 @@ static int ptlrpcd_bind(int index, int max)
                 pc->pc_npartners = 1;
                 break;
         case PDB_POLICY_NEIGHBOR:
                 pc->pc_npartners = 1;
                 break;
         case PDB_POLICY_NEIGHBOR:

+#if defined(CONFIG_NUMA) && defined(HAVE_NODE_TO_CPUMASK)
+                node = cpu_to_node(index);
+                mask = node_to_cpumask(node);
+                for (i = max; i < cfs_num_online_cpus(); i++)
+                        cpu_clear(i, mask);
+                pc->pc_npartners = cpus_weight(mask) - 1;
+                cfs_set_bit(LIOD_BIND, &pc->pc_flags);
+#else

                 LASSERT(max >= 3);
                 pc->pc_npartners = 2;
                 LASSERT(max >= 3);
                 pc->pc_npartners = 2;

+#endif

                 break;
         default:
                 CERROR("unknown ptlrpcd bind policy %d\n", ptlrpcd_bind_policy);
                 break;
         default:
                 CERROR("unknown ptlrpcd bind policy %d\n", ptlrpcd_bind_policy);


@@ -555,12 +569,10 @@ static int ptlrpcd_bind(int index, int max)
                         pc->pc_npartners = 0;
                         rc = -ENOMEM;
                 } else {
                         pc->pc_npartners = 0;
                         rc = -ENOMEM;
                 } else {

-                        if (index & 0x1)
-                                cfs_set_bit(LIOD_BIND, &pc->pc_flags);
-

                         switch (ptlrpcd_bind_policy) {
                         case PDB_POLICY_PAIR:
                                 if (index & 0x1) {
                         switch (ptlrpcd_bind_policy) {
                         case PDB_POLICY_PAIR:
                                 if (index & 0x1) {

+                                        cfs_set_bit(LIOD_BIND, &pc->pc_flags);

                                         pc->pc_partners[0] = &ptlrpcds->
                                                 pd_threads[index - 1];
                                         ptlrpcds->pd_threads[index - 1].
                                         pc->pc_partners[0] = &ptlrpcds->
                                                 pd_threads[index - 1];
                                         ptlrpcds->pd_threads[index - 1].


@@ -568,6 +580,25 @@ static int ptlrpcd_bind(int index, int max)
                                 }
                                 break;
                         case PDB_POLICY_NEIGHBOR:
                                 }
                                 break;
                         case PDB_POLICY_NEIGHBOR:

+#if defined(CONFIG_NUMA) && defined(HAVE_NODE_TO_CPUMASK)
+                                /* partners are cores in the same NUMA node.
+                                 * setup partnership only with ptlrpcd threads
+                                 * that are already initialized
+                                 */
+                                for (pidx = 0, i = 0; i < index; i++) {
+                                        if (cpu_isset(i, mask)) {
+                                                ppc = &ptlrpcds->pd_threads[i];
+                                                pc->pc_partners[pidx++] = ppc;
+                                                ppc->pc_partners[ppc->
+                                                          pc_npartners++] = pc;
+                                        }
+                                }
+                                /* adjust number of partners to the number
+                                 * of partnership really setup */
+                                pc->pc_npartners = pidx;
+#else
+                                if (index & 0x1)
+                                        cfs_set_bit(LIOD_BIND, &pc->pc_flags);

                                 if (index > 0) {
                                         pc->pc_partners[0] = &ptlrpcds->
                                                 pd_threads[index - 1];
                                 if (index > 0) {
                                         pc->pc_partners[0] = &ptlrpcds->
                                                 pd_threads[index - 1];


@@ -580,6 +611,7 @@ static int ptlrpcd_bind(int index, int max)
                                                 pc_partners[0] = pc;
                                         }
                                 }
                                                 pc_partners[0] = pc;
                                         }
                                 }

+#endif

                                 break;
                         }
                 }
                                 break;
                         }
                 }