From 3cc2e004cd5891a87d8bde2b9ddd814f68d1835a Mon Sep 17 00:00:00 2001

From: Pingfan Liu <piliu@redhat.com>

Date: Mon, 15 Jul 2019 16:24:39 +0800

Subject: [PATCH 1/2] libnuma: introduce an API to outdate cpu to node mapping

numa_node_to_cpus() caches the cpu to node mapping, and not updates it

during the cpu online/offline event.

Ideally, in order to update the mapping automatically, it requires

something like udev to spy on kernel event socket, and update cache if

event happen. This solution is a little complicated inside a libnuma.so. In

stead of doing so, exposing an API numa_node_to_cpu_outdated() for user,

and saddling the event-detecting task to the user.

So the user of libnuma can work using either of the following models:

 -1. blindless outdate cache if careless about performance

     numa_node_to_cpu_outdated();

     numa_node_to_cpu();

 -2. event driven spy on kernel event, if happened, call

     numa_node_to_cpu_outdated();

Signed-off-by: Pingfan Liu <piliu@redhat.com>

---

 libnuma.c         | 32 ++++++++++++++++++++++++++++----

 numa.3            |  7 +++++++

 numa.h            |  2 ++

 versions.ldscript |  1 +

 4 files changed, 38 insertions(+), 4 deletions(-)

diff --git a/libnuma.c b/libnuma.c

index cac8851..756a171 100644

--- a/libnuma.c

+++ b/libnuma.c

@@ -58,7 +58,9 @@ struct bitmask *numa_possible_cpus_ptr = NULL;

 struct bitmask *numa_nodes_ptr = NULL;

 static struct bitmask *numa_memnode_ptr = NULL;

 static unsigned long *node_cpu_mask_v1[NUMA_NUM_NODES];

+static char node_cpu_mask_v1_stale = 1;

 static struct bitmask **node_cpu_mask_v2;

+static char node_cpu_mask_v2_stale = 1;

 WEAK void numa_error(char *where);

@@ -1272,6 +1274,7 @@ numa_node_to_cpus_v1(int node, unsigned long *buffer, int bufferlen)

 	int err = 0;

 	char fn[64];

 	FILE *f;

+	char update;

 	char *line = NULL;

 	size_t len = 0;

 	struct bitmask bitmask;

@@ -1287,7 +1290,8 @@ numa_node_to_cpus_v1(int node, unsigned long *buffer, int bufferlen)

 	}

 	if (bufferlen > buflen_needed)

 		memset(buffer, 0, bufferlen);

-	if (node_cpu_mask_v1[node]) {

+	update = __atomic_fetch_and(&node_cpu_mask_v1_stale, 0, __ATOMIC_RELAXED);

+	if (node_cpu_mask_v1[node] && !update) {

 		memcpy(buffer, node_cpu_mask_v1[node], buflen_needed);

 		return 0;

 	}

@@ -1328,7 +1332,15 @@ numa_node_to_cpus_v1(int node, unsigned long *buffer, int bufferlen)

 	/* slightly racy, see above */

 	if (node_cpu_mask_v1[node]) {

-		if (mask != buffer)

+		if (update) {

+			/*

+			 * There may be readers on node_cpu_mask_v1[], hence it can not

+			 * be freed.

+			 */

+			memcpy(node_cpu_mask_v1[node], mask, buflen_needed);

+			free(mask);

+			mask = NULL;

+		} else if (mask != buffer)

 			free(mask);

 	} else {

 		node_cpu_mask_v1[node] = mask;

@@ -1352,6 +1364,7 @@ numa_node_to_cpus_v2(int node, struct bitmask *buffer)

 	int nnodes = numa_max_node();

 	char fn[64], *line = NULL;

 	FILE *f;

+	char update;

 	size_t len = 0;

 	struct bitmask *mask;

@@ -1364,7 +1377,8 @@ numa_node_to_cpus_v2(int node, struct bitmask *buffer)

 	}

 	numa_bitmask_clearall(buffer);

-	if (node_cpu_mask_v2[node]) {

+	update = __atomic_fetch_and(&node_cpu_mask_v2_stale, 0, __ATOMIC_RELAXED);

+	if (node_cpu_mask_v2[node] && !update) {

 		/* have already constructed a mask for this node */

 		if (buffer->size < node_cpu_mask_v2[node]->size) {

 			errno = EINVAL;

@@ -1407,8 +1421,12 @@ numa_node_to_cpus_v2(int node, struct bitmask *buffer)

 	/* slightly racy, see above */

 	/* save the mask we created */

 	if (node_cpu_mask_v2[node]) {

+		if (update) {

+			copy_bitmask_to_bitmask(mask, node_cpu_mask_v2[node]);

+			numa_bitmask_free(mask);

+			mask = NULL;

 		/* how could this be? */

-		if (mask != buffer)

+		} else if (mask != buffer)

 			numa_bitmask_free(mask);

 	} else {

 		/* we don't want to cache faulty result */

@@ -1424,6 +1442,12 @@ __asm__(".symver numa_node_to_cpus_v2,numa_node_to_cpus@@libnuma_1.2");

 make_internal_alias(numa_node_to_cpus_v1);

 make_internal_alias(numa_node_to_cpus_v2);

+void numa_node_to_cpu_update(void)

+{

+	__atomic_store_n(&node_cpu_mask_v1_stale, 1, __ATOMIC_RELAXED);

+	__atomic_store_n(&node_cpu_mask_v2_stale, 1, __ATOMIC_RELAXED);

+}

+

 /* report the node of the specified cpu */

 int numa_node_of_cpu(int cpu)

 {

diff --git a/numa.3 b/numa.3

index ba00572..e54cb0b 100644

--- a/numa.3

+++ b/numa.3

@@ -124,6 +124,8 @@ numa \- NUMA policy library

 .br

 .BI "int numa_node_to_cpus(int " node ", struct bitmask *" mask ");

 .br

+.BI "void numa_node_to_cpu_update();"

+.br

 .BI "int numa_node_of_cpu(int " cpu ");

 .sp

 .BI "struct bitmask *numa_allocate_cpumask();"

@@ -232,6 +234,7 @@ Most functions in this library are only concerned about numa nodes and

 their memory.

 The exceptions to this are:

 .IR numa_node_to_cpus (),

+.IR numa_node_to_cpu_update (),

 .IR numa_node_of_cpu (),

 .IR numa_bind (),

 .IR numa_run_on_node (),

@@ -795,6 +798,10 @@ will be set to

 .I ERANGE

 and \-1 returned. On success 0 is returned.

+.BR numa_node_to_cpu_update ()

+Mark the node's cpus bitmask stale, then get the latest bitmask by calling

+.BR numa_node_to_cpus ()

+

 .BR numa_node_of_cpu ()

 returns the node that a cpu belongs to. If the user supplies an invalid cpu

 .I errno

diff --git a/numa.h b/numa.h

index 3a8c543..7316d1e 100644

--- a/numa.h

+++ b/numa.h

@@ -282,6 +282,8 @@ static inline void numa_free_cpumask(struct bitmask *b)

 /* Convert node to CPU mask. -1/errno on failure, otherwise 0. */

 int numa_node_to_cpus(int, struct bitmask *);

+void numa_node_to_cpu_update(void);

+

 /* report the node of the specified cpu. -1/errno on invalid cpu. */

 int numa_node_of_cpu(int cpu);

diff --git a/versions.ldscript b/versions.ldscript

index 4b04936..23074a0 100644

--- a/versions.ldscript

+++ b/versions.ldscript

@@ -60,6 +60,7 @@ libnuma_1.1 {

     numa_tonodemask_memory;

     numa_warn;

     numa_exit_on_warn;

+    numa_node_to_cpu_update;

   local:

     *;

 };

-- 

2.7.5