@@ -37,12 +37,108 @@ static bool spapr_numa_is_symmetrical(MachineState *ms)
return true;
}
+/*
+ * This function will translate the user distances into
+ * what the kernel understand as possible values: 10
+ * (local distance), 20, 40, 80 and 160, and return the equivalent
+ * NUMA level for each. Current heuristic is:
+ * - local distance (10) returns numa_level = 0x4, meaning there is
+ * no rounding for local distance
+ * - distances between 11 and 30 inclusive -> rounded to 20,
+ * numa_level = 0x3
+ * - distances between 31 and 60 inclusive -> rounded to 40,
+ * numa_level = 0x2
+ * - distances between 61 and 120 inclusive -> rounded to 80,
+ * numa_level = 0x1
+ * - everything above 120 returns numa_level = 0 to indicate that
+ * there is no match. This will be calculated as disntace = 160
+ * by the kernel (as of v5.9)
+ */
+static uint8_t spapr_numa_get_numa_level(uint8_t distance)
+{
+ if (distance == 10) {
+ return 0x4;
+ } else if (distance > 11 && distance <= 30) {
+ return 0x3;
+ } else if (distance > 31 && distance <= 60) {
+ return 0x2;
+ } else if (distance > 61 && distance <= 120) {
+ return 0x1;
+ }
+
+ return 0;
+}
+
+static void spapr_numa_define_associativity_domains(SpaprMachineState *spapr)
+{
+ MachineState *ms = MACHINE(spapr);
+ NodeInfo *numa_info = ms->numa_state->nodes;
+ int nb_numa_nodes = ms->numa_state->num_nodes;
+ int src, dst, i;
+
+ for (src = 0; src < nb_numa_nodes; src++) {
+ for (dst = src; dst < nb_numa_nodes; dst++) {
+ /*
+ * This is how the associativity domain between A and B
+ * is calculated:
+ *
+ * - get the distance D between them
+ * - get the correspondent NUMA level 'n_level' for D
+ * - all associativity arrays were initialized with their own
+ * numa_ids, and we're calculating the distance in node_id
+ * ascending order, starting from node id 0 (the first node
+ * retrieved by numa_state). This will have a cascade effect in
+ * the algorithm because the associativity domains that node 0
+ * defines will be carried over to other nodes, and node 1
+ * associativities will be carried over after taking node 0
+ * associativities into account, and so on. This happens because
+ * we'll assign assoc_src as the associativity domain of dst
+ * as well, for all NUMA levels beyond and including n_level.
+ *
+ * The PPC kernel expects the associativity domains of node 0 to
+ * be always 0, and this algorithm will grant that by default.
+ */
+ uint8_t distance = numa_info[src].distance[dst];
+ uint8_t n_level = spapr_numa_get_numa_level(distance);
+ uint32_t assoc_src;
+
+ /*
+ * n_level = 0 means that the distance is greater than our last
+ * rounded value (120). In this case there is no NUMA level match
+ * between src and dst and we can skip the remaining of the loop.
+ *
+ * The Linux kernel will assume that the distance between src and
+ * dst, in this case of no match, is 10 (local distance) doubled
+ * for each NUMA it didn't match. We have MAX_DISTANCE_REF_POINTS
+ * levels (4), so this gives us 10*2*2*2*2 = 160.
+ *
+ * This logic can be seen in the Linux kernel source code, as of
+ * v5.9, in arch/powerpc/mm/numa.c, function __node_distance().
+ */
+ if (n_level == 0) {
+ continue;
+ }
+
+ /*
+ * We must assign all assoc_src to dst, starting from n_level
+ * and going up to 0x1.
+ */
+ for (i = n_level; i > 0; i--) {
+ assoc_src = spapr->numa_assoc_array[src][i];
+ spapr->numa_assoc_array[dst][i] = assoc_src;
+ }
+ }
+ }
+
+}
+
void spapr_numa_associativity_init(SpaprMachineState *spapr,
MachineState *machine)
{
SpaprMachineClass *smc = SPAPR_MACHINE_GET_CLASS(spapr);
int nb_numa_nodes = machine->numa_state->num_nodes;
int i, j, max_nodes_with_gpus;
+ bool using_legacy_numa = spapr_machine_using_legacy_numa(spapr);
/*
* For all associativity arrays: first position is the size,
@@ -56,6 +152,17 @@ void spapr_numa_associativity_init(SpaprMachineState *spapr,
for (i = 0; i < nb_numa_nodes; i++) {
spapr->numa_assoc_array[i][0] = cpu_to_be32(MAX_DISTANCE_REF_POINTS);
spapr->numa_assoc_array[i][MAX_DISTANCE_REF_POINTS] = cpu_to_be32(i);
+
+ /*
+ * Fill all associativity domains of non-zero NUMA nodes with
+ * node_id. This is required because the default value (0) is
+ * considered a match with associativity domains of node 0.
+ */
+ if (!using_legacy_numa && i != 0) {
+ for (j = 1; j < MAX_DISTANCE_REF_POINTS; j++) {
+ spapr->numa_assoc_array[i][j] = cpu_to_be32(i);
+ }
+ }
}
/*
@@ -85,7 +192,7 @@ void spapr_numa_associativity_init(SpaprMachineState *spapr,
* 1 NUMA node) will not benefit from anything we're going to do
* after this point.
*/
- if (spapr_machine_using_legacy_numa(spapr)) {
+ if (using_legacy_numa) {
return;
}
@@ -95,6 +202,7 @@ void spapr_numa_associativity_init(SpaprMachineState *spapr,
exit(EXIT_FAILURE);
}
+ spapr_numa_define_associativity_domains(spapr);
}
void spapr_numa_write_associativity_dt(SpaprMachineState *spapr, void *fdt,