Skip to contentSkip to conversation

mm/page_alloc: add same penalty is enough to get round-robin order

PATCH Applied Wei Yang 4 participants 4 messages Apr 12, 2022

Subsystems (2)
lore
Share & tools
lore

Wei Yang

author
#0 lore raw

PATCH v3 1/1 mm/page_alloc: add same penalty is enough to get round-robin order

To make node order in round-robin in the same distance group, we add a penalty to the first node we got in each round.

To get a round-robin order in the same distance group, we don't need to decrease the penalty since:

* find_next_best_node() always iterates node in the same order
* distance matters more then penalty in find_next_best_node()
* in nodes with the same distance, the first one would be picked up

So it is fine to increase same penalty when we get the first node in the same distance group. Since we just increase a constance of 1 to node penalty, it is not necessary to multiply MAX_NODE_LOAD for preference.

[[email protected]: suggests to remove MAX_NODE_LOAD]

CC Vlastimil Babka <[email protected]>
CC David Hildenbrand <[email protected]>
CC Oscar Salvador <[email protected]>

---
v3: merge into a single patch
v2: adjust constant penalty to 1

---
 mm/page_alloc.c | 9 +++------
 1 file changed, 3 insertions(+), 6 deletions(-)
mm/page_alloc.c +3 -6
index 5d71b8dcb5f4..0334c06a0a47 100644
@@ -6170,7 +6170,6 @@ int numa_zonelist_order_handler(struct ctl_table *table, int write,
 }
 
 
-#define MAX_NODE_LOAD (nr_online_nodes)
 static int node_load[MAX_NUMNODES];
 
 /**
@@ -6217,7 +6216,7 @@ int find_next_best_node(int node, nodemask_t *used_node_mask)
 			val += PENALTY_FOR_NODE_WITH_CPUS;
 
 		/* Slight preference for less loaded node */
-		val *= (MAX_NODE_LOAD*MAX_NUMNODES);
+		val *= MAX_NUMNODES;
 		val += node_load[n];
 
 		if (val < min_val) {
@@ -6283,13 +6282,12 @@ static void build_thisnode_zonelists(pg_data_t *pgdat)
 static void build_zonelists(pg_data_t *pgdat)
 {
 	static int node_order[MAX_NUMNODES];
-	int node, load, nr_nodes = 0;
+	int node, nr_nodes = 0;
 	nodemask_t used_mask = NODE_MASK_NONE;
 	int local_node, prev_node;
 
 	/* NUMA-aware ordering of nodes */
 	local_node = pgdat->node_id;
-	load = nr_online_nodes;
 	prev_node = local_node;
 
 	memset(node_order, 0, sizeof(node_order));
@@ -6301,11 +6299,10 @@ static void build_zonelists(pg_data_t *pgdat)
 		 */
 		if (node_distance(local_node, node) !=
 		    node_distance(local_node, prev_node))
-			node_load[node] += load;
+			node_load[node] += 1;
 
 		node_order[nr_nodes++] = node;
 		prev_node = node;
-		load--;
 	}
 
 	build_zonelists_in_node_order(pgdat, node_order, nr_nodes);
Signature · 1 line
2.33.1
Acked-by on v3 1/1
#1 lore raw
Quoted 14 lines · Wei Yang

To make node order in round-robin in the same distance group, we add a penalty to the first node we got in each round.

To get a round-robin order in the same distance group, we don't need to decrease the penalty since:

* find_next_best_node() always iterates node in the same order
* distance matters more then penalty in find_next_best_node()
* in nodes with the same distance, the first one would be picked up

So it is fine to increase same penalty when we get the first node in the same distance group. Since we just increase a constance of 1 to node penalty, it is not necessary to multiply MAX_NODE_LOAD for preference.

Quoted 6 lines

[[email protected]: suggests to remove MAX_NODE_LOAD]

CC Vlastimil Babka <[email protected]>
CC David Hildenbrand <[email protected]>
CC Oscar Salvador <[email protected]>
Quoted 55 lines

v3: merge into a single patch
v2: adjust constant penalty to 1

---
 mm/page_alloc.c | 9 +++------
 1 file changed, 3 insertions(+), 6 deletions(-)
mm/page_alloc.c +3 -6
index 5d71b8dcb5f4..0334c06a0a47 100644
@@ -6170,7 +6170,6 @@ int numa_zonelist_order_handler(struct ctl_table *table, int write,
 }
 
 
-#define MAX_NODE_LOAD (nr_online_nodes)
 static int node_load[MAX_NUMNODES];
 
 /**
@@ -6217,7 +6216,7 @@ int find_next_best_node(int node, nodemask_t *used_node_mask)
 			val += PENALTY_FOR_NODE_WITH_CPUS;
 
 		/* Slight preference for less loaded node */
-		val *= (MAX_NODE_LOAD*MAX_NUMNODES);
+		val *= MAX_NUMNODES;
 		val += node_load[n];
 
 		if (val < min_val) {
@@ -6283,13 +6282,12 @@ static void build_thisnode_zonelists(pg_data_t *pgdat)
 static void build_zonelists(pg_data_t *pgdat)
 {
 	static int node_order[MAX_NUMNODES];
-	int node, load, nr_nodes = 0;
+	int node, nr_nodes = 0;
 	nodemask_t used_mask = NODE_MASK_NONE;
 	int local_node, prev_node;
 
 	/* NUMA-aware ordering of nodes */
 	local_node = pgdat->node_id;
-	load = nr_online_nodes;
 	prev_node = local_node;
 
 	memset(node_order, 0, sizeof(node_order));
@@ -6301,11 +6299,10 @@ static void build_zonelists(pg_data_t *pgdat)
 		 */
 		if (node_distance(local_node, node) !=
 		    node_distance(local_node, prev_node))
-			node_load[node] += load;
+			node_load[node] += 1;
 
 		node_order[nr_nodes++] = node;
 		prev_node = node;
-		load--;
 	}
 
 	build_zonelists_in_node_order(pgdat, node_order, nr_nodes);
Acked-by on v3 1/1
#2 lore raw
In reply to Wei Yang
Quoted 16 lines · Wei Yang

To make node order in round-robin in the same distance group, we add a penalty to the first node we got in each round.

To get a round-robin order in the same distance group, we don't need to decrease the penalty since:

* find_next_best_node() always iterates node in the same order
* distance matters more then penalty in find_next_best_node()
* in nodes with the same distance, the first one would be picked up

So it is fine to increase same penalty when we get the first node in the same distance group. Since we just increase a constance of 1 to node penalty, it is not necessary to multiply MAX_NODE_LOAD for preference.

[[email protected]: suggests to remove MAX_NODE_LOAD]

Quoted 8 lines
CC Vlastimil Babka <[email protected]>
CC David Hildenbrand <[email protected]>
CC Oscar Salvador <[email protected]>

---
v3: merge into a single patch
v2: adjust constant penalty to 1
---

Signature · 3 lines
Thanks,

David / dhildenb
Acked-by on v3 1/1
#3 lore raw
In reply to Wei Yang
Quoted 14 lines · Wei Yang

To make node order in round-robin in the same distance group, we add a penalty to the first node we got in each round.

To get a round-robin order in the same distance group, we don't need to decrease the penalty since:

* find_next_best_node() always iterates node in the same order
* distance matters more then penalty in find_next_best_node()
* in nodes with the same distance, the first one would be picked up

So it is fine to increase same penalty when we get the first node in the same distance group. Since we just increase a constance of 1 to node penalty, it is not necessary to multiply MAX_NODE_LOAD for preference.

Quoted 6 lines

[[email protected]: suggests to remove MAX_NODE_LOAD]

CC Vlastimil Babka <[email protected]>
CC David Hildenbrand <[email protected]>
CC Oscar Salvador <[email protected]>
Quoted 60 lines

---
v3: merge into a single patch
v2: adjust constant penalty to 1

---
 mm/page_alloc.c | 9 +++------
 1 file changed, 3 insertions(+), 6 deletions(-)
mm/page_alloc.c +3 -6
index 5d71b8dcb5f4..0334c06a0a47 100644
@@ -6170,7 +6170,6 @@ int numa_zonelist_order_handler(struct ctl_table *table, int write,
 }
 
 
-#define MAX_NODE_LOAD (nr_online_nodes)
 static int node_load[MAX_NUMNODES];
 
 /**
@@ -6217,7 +6216,7 @@ int find_next_best_node(int node, nodemask_t *used_node_mask)
 			val += PENALTY_FOR_NODE_WITH_CPUS;
 
 		/* Slight preference for less loaded node */
-		val *= (MAX_NODE_LOAD*MAX_NUMNODES);
+		val *= MAX_NUMNODES;
 		val += node_load[n];
 
 		if (val < min_val) {
@@ -6283,13 +6282,12 @@ static void build_thisnode_zonelists(pg_data_t *pgdat)
 static void build_zonelists(pg_data_t *pgdat)
 {
 	static int node_order[MAX_NUMNODES];
-	int node, load, nr_nodes = 0;
+	int node, nr_nodes = 0;
 	nodemask_t used_mask = NODE_MASK_NONE;
 	int local_node, prev_node;
 
 	/* NUMA-aware ordering of nodes */
 	local_node = pgdat->node_id;
-	load = nr_online_nodes;
 	prev_node = local_node;
 
 	memset(node_order, 0, sizeof(node_order));
@@ -6301,11 +6299,10 @@ static void build_zonelists(pg_data_t *pgdat)
 		 */
 		if (node_distance(local_node, node) !=
 		    node_distance(local_node, prev_node))
-			node_load[node] += load;
+			node_load[node] += 1;
 
 		node_order[nr_nodes++] = node;
 		prev_node = node;
-		load--;
 	}
 
 	build_zonelists_in_node_order(pgdat, node_order, nr_nodes);
Signature · 1 line
2.33.1
Signature · 2 lines
Oscar Salvador
SUSE Labs