Merge pull request #568 from bgoglin/fakenuma

Workaround fake numa in the Linux kernel

Booting Linux with things like numa=fake=8U can split physical NUMA nodes into multiple smaller ones. That was mostly for debugging but it looks like some modes with be used in production in the future. hwloc currently assumes multiple nodes with identical locality in Linux was a BIOS bug, hence only the first one was kept.
Detect fake numa in the kernel cmdline and allow such nodes with identical cpusets. Disable memory attributes and memory-side caches since HMAT information isn't updated in Linux when fake NUMA is enabled (while SLIT distances are).
By the way, update lstopo to show these many NUMA nodes in a rectangular layout since 8 nodes on a single row makes the row way too long.

Author: bgoglin

doc/hwloc.doxy

@@ -1292,7 +1292,9 @@ following environment variables.
   if 1, ignore KNL info from hwloc-dump-hwdata and fallback to heuristic
   if 0, never fallback to the hardwired heuristic, useful if the heuristic is wrong
  HWLOC_DEBUG_ALLOW_OVERLAPPING_NODE_CPUSETS
-  don't ignore linux numa nodes with overlapping cpusets
+  if 0 (default), non-first nodes with overlapping cpusets are ignored
+  if 1, don't ignore linux numa nodes with overlapping cpusets
+  if 2, don't ignore either and don't even warn about it
  HWLOC_DEBUG_SORT_CHILDREN
   sort osdev I/O children by name to make sure the topology doesn't depend
   on the ordering of dentries in the local filesystem (for Linux fsroot tests)

hwloc/topology-linux.c

@@ -56,6 +56,7 @@ struct hwloc_linux_backend_data_s {
   } arch;
   int is_knl;
   int is_amd_with_CU;
+  int is_fake_numa_uniform; /* 0 if not fake, -1 if fake non-uniform, N if fake=<N>U */
   int use_numa_distances;
   int use_numa_distances_for_cpuless;
   int use_numa_initiators;
@@ -3971,11 +3972,26 @@ look_sysfsnode(struct hwloc_topology *topology,
   unsigned failednodes = 0;
   unsigned i;
   DIR *dir;
-  int allow_overlapping_node_cpusets = (getenv("HWLOC_DEBUG_ALLOW_OVERLAPPING_NODE_CPUSETS") != NULL);
+  char *env;
+  int allow_overlapping_node_cpusets = 0;
   int need_memcaches = hwloc_filter_check_keep_object_type(topology, HWLOC_OBJ_MEMCACHE);
+  int need_memattrs = !(topology->flags & HWLOC_TOPOLOGY_FLAG_NO_MEMATTRS);
 
   hwloc_debug("\n\n * Topology extraction from /sys/devices/system/node *\n\n");
 
+  if (data->is_fake_numa_uniform) {
+    hwloc_debug("Disabling memory-side caches, memory attributes and HMAT initiators because of fake numa\n");
+    need_memcaches = 0;
+    need_memattrs = 0;
+    data->use_numa_initiators = 0;
+    allow_overlapping_node_cpusets = 2; /* accept without warning */
+  }
+
+  env = getenv("HWLOC_DEBUG_ALLOW_OVERLAPPING_NODE_CPUSETS");
+  if (env) {
+    allow_overlapping_node_cpusets = atoi(env); /* 0 drop non-first overlapping nodes, 1 allows with warning, 2 allows without warning */
+  }
+
   /* NUMA nodes cannot be filtered out */
   indexes = list_sysfsnode(topology, data, &nbnodes);
   if (!indexes)
@@ -4023,7 +4039,7 @@ look_sysfsnode(struct hwloc_topology *topology,
 	failednodes++;
 	continue;
       }
-      if (HWLOC_SHOW_CRITICAL_ERRORS())
+      if (allow_overlapping_node_cpusets < 2 && HWLOC_SHOW_CRITICAL_ERRORS())
         fprintf(stderr, "hwloc/linux: node P#%u cpuset intersects with previous nodes, forcing its acceptance\n", osnode);
     }
     hwloc_bitmap_or(nodes_cpuset, nodes_cpuset, cpuset);
@@ -4043,8 +4059,9 @@ look_sysfsnode(struct hwloc_topology *topology,
       dir = hwloc_opendir("/proc/driver/nvidia/gpus", data->root_fd);
       if (dir) {
 	struct dirent *dirent;
-	char *env = getenv("HWLOC_KEEP_NVIDIA_GPU_NUMA_NODES");
-	int keep = env && atoi(env);
+	int keep;
+	env = getenv("HWLOC_KEEP_NVIDIA_GPU_NUMA_NODES");
+        keep = env && atoi(env);
 	while ((dirent = readdir(dir)) != NULL) {
 	  char nvgpunumapath[300], line[256];
           int err;
@@ -4115,8 +4132,9 @@ look_sysfsnode(struct hwloc_topology *topology,
 
       if (data->is_knl) {
 	/* apply KNL quirks */
-	char *env = getenv("HWLOC_KNL_NUMA_QUIRK");
-	int noquirk = (env && !atoi(env));
+	int noquirk;
+	env = getenv("HWLOC_KNL_NUMA_QUIRK");
+        noquirk = (env && !atoi(env));
 	if (!noquirk) {
 	  hwloc_linux_knl_numa_quirk(topology, data, nodes, nbnodes, distances, &failednodes);
 	  free(distances);
@@ -4174,7 +4192,7 @@ look_sysfsnode(struct hwloc_topology *topology,
 	  trees[nr_trees++] = tree;
 	}
         /* By the way, get their memattrs now that cpuset is fixed */
-        if (!(topology->flags & HWLOC_TOPOLOGY_FLAG_NO_MEMATTRS))
+        if (need_memattrs)
           read_node_local_memattrs(topology, data, node);
       }
 
@@ -5531,6 +5549,40 @@ static int check_sysfs_cpu_path(int root_fd, int *old_filenames)
   return -1;
 }
 
+static void
+hwloc_linuxfs_check_kernel_cmdline(struct hwloc_linux_backend_data_s *data)
+{
+  FILE *file;
+  char cmdline[4096];
+  char *fakenuma;
+
+  file = hwloc_fopen("/proc/cmdline", "r", data->root_fd);
+  if (!file)
+    return;
+
+  cmdline[0] = 0;
+  fgets(cmdline, sizeof(cmdline), file);
+
+  fakenuma = strstr(cmdline, "numa=fake=");
+  if (fakenuma) {
+    /* in fake numa emulation, SLIT is updated but HMAT isn't, hence we need to disable/fix things later */
+    unsigned width = 0;
+    char type = 0;
+    if (sscanf(fakenuma+10, "%u%c", &width, &type) == 2 && type == 'U') {
+      /* if <N>U, each node is split in 8 nodes, we can still do things in this case */
+      data->is_fake_numa_uniform = width;
+    } else {
+      /* otherwise fake nodes are created by just dividing the entire RAM,
+       * without respecting locality at all
+       */
+      data->is_fake_numa_uniform = -1;
+    }
+    hwloc_debug("Found fake numa %d\n", data->is_fake_numa_uniform);
+  }
+
+  fclose(file);
+}
+
 static int
 hwloc_linuxfs_look_cpu(struct hwloc_backend *backend, struct hwloc_disc_status *dstatus)
 {
@@ -5583,6 +5635,11 @@ hwloc_linuxfs_look_cpu(struct hwloc_backend *backend, struct hwloc_disc_status *
    */
   hwloc_gather_system_info(topology, data);
 
+  /**********************************
+   * Detect things in /proc/cmdline
+   */
+  hwloc_linuxfs_check_kernel_cmdline(data);
+
   /**********************
    * /proc/cpuinfo
    */
@@ -7215,6 +7272,7 @@ hwloc_linux_component_instantiate(struct hwloc_topology *topology,
   data->arch = HWLOC_LINUX_ARCH_UNKNOWN;
   data->is_knl = 0;
   data->is_amd_with_CU = 0;
+  data->is_fake_numa_uniform = 0;
   data->is_real_fsroot = 1;
   data->root_path = NULL;
   fsroot_path = getenv("HWLOC_FSROOT");

utils/lstopo/lstopo-draw.c

@@ -371,9 +371,6 @@ static float pci_link_speed(hwloc_obj_t obj)
  * Placing children in rectangle
  */
 
-/* preferred width/height compromise */
-#define RATIO (4.f/3.f)
-
 /* returns a score <= 1. close to 1 is better */
 static __hwloc_inline
 float rectangle_score(unsigned width, unsigned height, float ratio)
@@ -553,10 +550,13 @@ place_children_rect(struct lstopo_output *loutput, hwloc_obj_t parent,
   float ratio;
   int i;
 
-  if (parent->type == HWLOC_OBJ_CORE)
-    ratio = 1/RATIO;
+  /* preferred width/height compromise */
+  if (kind == LSTOPO_CHILD_KIND_MEMORY)
+    ratio = 8.f; /* very large for memory above objects since the parent is usually very large */
+  else if (parent->type == HWLOC_OBJ_CORE)
+    ratio = 3.f/4.f; /* rather high Core objects since they often contain 2 PUs that we don't want horizontal */
   else
-    ratio = RATIO;
+    ratio = 4.f/3.f; /* rather largeother objects */
   find_children_rectangle(loutput, parent, kind, separator, &rows, &columns, ratio);
 
   rowwidth = 0;
@@ -626,7 +626,7 @@ place_children(struct lstopo_output *loutput, hwloc_obj_t parent,
 	       unsigned xrel, unsigned yrel /* position of children within parent */)
 {
   struct lstopo_obj_userdata *plud = parent->userdata;
-  enum lstopo_orient_e main_orient, right_orient, below_orient;
+  enum lstopo_orient_e main_orient, right_orient, below_orient, above_orient;
   unsigned border = loutput->gridsize;
   unsigned separator = loutput->gridsize;
   unsigned separator_below_cache = loutput->gridsize;
@@ -674,6 +674,10 @@ place_children(struct lstopo_output *loutput, hwloc_obj_t parent,
   below_orient = loutput->below_force_orient;
   if (below_orient == LSTOPO_ORIENT_NONE)
     below_orient = loutput->force_orient[parent->type];
+  /* place above children in rectangle by default */
+  above_orient = loutput->above_force_orient;
+  if (above_orient == LSTOPO_ORIENT_NONE)
+    above_orient = LSTOPO_ORIENT_RECT;
 
   /* defaults */
   plud->children.box = 0;
@@ -790,7 +794,6 @@ place_children(struct lstopo_output *loutput, hwloc_obj_t parent,
 
   /* compute the size of the above children section (Memory), if any */
   if (plud->above_children.kinds) {
-    enum lstopo_orient_e morient = LSTOPO_ORIENT_HORIZ;
     int need_box;
 
     assert(plud->above_children.kinds == LSTOPO_CHILD_KIND_MEMORY);
@@ -801,7 +804,7 @@ place_children(struct lstopo_output *loutput, hwloc_obj_t parent,
     need_box = !hwloc_obj_type_is_memory(parent->type)
       && (parent->memory_arity + parent->memory_first_child->memory_arity > 1);
 
-    place__children(loutput, parent, plud->above_children.kinds, &morient, need_box ? border : 0, separator, &above_children_width, &above_children_height);
+    place__children(loutput, parent, plud->above_children.kinds, &above_orient, need_box ? border : 0, separator, &above_children_width, &above_children_height);
     if (parent->type == HWLOC_OBJ_MEMCACHE)
       above_children_height -= separator;
 

utils/lstopo/lstopo-no-graphics.1in

@@ -349,7 +349,7 @@ on the right.
 
 Up to hwloc 2.5, the default was rather to \fImemory:above,plain\fR.
 
-Additionally, \fIio:right\fR, \fIio:below\fR, \fImisc:right\fR
+Additionally, \fImemory:above\fR, \fIio:right\fR, \fIio:below\fR, \fImisc:right\fR
 and \fImisc:below\fR may be suffixed with
 \fI:horiz\fR, \fI:vert\fR or \fI:rect\fR to force the horizontal,
 vertical or rectangular layout of children inside these sections.

utils/lstopo/lstopo.c

@@ -303,11 +303,13 @@ lstopo_check_pci_domains(hwloc_topology_t topology)
 
 static void
 lstopo_parse_children_order(char *s, unsigned *children_order_p,
+                            enum lstopo_orient_e *above_force_orient_p,
                             enum lstopo_orient_e *right_force_orient_p,
                             enum lstopo_orient_e *below_force_orient_p)
 {
   char *tmp, *next;
   unsigned children_order;
+  enum lstopo_orient_e above_force_orient = LSTOPO_ORIENT_NONE;
   enum lstopo_orient_e right_force_orient = LSTOPO_ORIENT_NONE;
   enum lstopo_orient_e below_force_orient= LSTOPO_ORIENT_NONE;
 
@@ -327,6 +329,15 @@ lstopo_parse_children_order(char *s, unsigned *children_order_p,
 
     if (!strcmp(tmp, "memory:above") || !strcmp(tmp, "memoryabove") /* backward compat with 2.5 */) {
       children_order |= LSTOPO_ORDER_MEMORY_ABOVE;
+    } else if (!strcmp(tmp, "memory:above:horiz")) {
+      children_order |= LSTOPO_ORDER_MEMORY_ABOVE;
+      above_force_orient = LSTOPO_ORIENT_HORIZ;
+    } else if (!strcmp(tmp, "memory:above:vert")) {
+      children_order |= LSTOPO_ORDER_MEMORY_ABOVE;
+      above_force_orient = LSTOPO_ORIENT_VERT;
+    } else if (!strcmp(tmp, "memory:above:rect")) {
+      children_order |= LSTOPO_ORDER_MEMORY_ABOVE;
+      above_force_orient = LSTOPO_ORIENT_RECT;
 
     } else if (!strcmp(tmp, "io:right")) {
       children_order |= LSTOPO_ORDER_IO_RIGHT;
@@ -384,6 +395,7 @@ lstopo_parse_children_order(char *s, unsigned *children_order_p,
   }
 
   *children_order_p = children_order;
+  *above_force_orient_p = above_force_orient;
   *right_force_orient_p = right_force_orient;
   *below_force_orient_p = below_force_orient;
 }
@@ -896,6 +908,7 @@ main (int argc, char *argv[])
     loutput.force_orient[i] = LSTOPO_ORIENT_HORIZ;
   loutput.force_orient[HWLOC_OBJ_NUMANODE] = LSTOPO_ORIENT_HORIZ;
   loutput.force_orient[HWLOC_OBJ_MEMCACHE] = LSTOPO_ORIENT_HORIZ;
+  loutput.above_force_orient = LSTOPO_ORIENT_NONE;
   loutput.right_force_orient = LSTOPO_ORIENT_NONE;
   loutput.below_force_orient = LSTOPO_ORIENT_NONE;
   for(i=HWLOC_OBJ_TYPE_MIN; i<HWLOC_OBJ_TYPE_MAX; i++) {
@@ -1383,7 +1396,7 @@ main (int argc, char *argv[])
 	if (argc < 2)
 	  goto out_usagefailure;
         lstopo_parse_children_order(argv[1], &loutput.children_order,
-                                    &loutput.right_force_orient, &loutput.below_force_orient);
+                                    &loutput.above_force_orient, &loutput.right_force_orient, &loutput.below_force_orient);
 	opt = 1;
       }
       else if (!strcmp (argv[0], "--no-cpukinds")) {

utils/lstopo/lstopo.h

@@ -1,6 +1,6 @@
 /*
  * Copyright © 2009 CNRS
- * Copyright © 2009-2022 Inria.  All rights reserved.
+ * Copyright © 2009-2023 Inria.  All rights reserved.
  * Copyright © 2009-2010, 2012, 2015 Université Bordeaux
  * Copyright © 2011 Cisco Systems, Inc.  All rights reserved.
  * Copyright © 2020 Hewlett Packard Enterprise.  All rights reserved.
@@ -112,6 +112,7 @@ struct lstopo_output {
   unsigned int gridsize, fontsize, linespacing, thickness;
   float text_xscale;
   enum lstopo_orient_e force_orient[HWLOC_OBJ_TYPE_MAX]; /* orientation of children within an object of the given type */
+  enum lstopo_orient_e above_force_orient;
   enum lstopo_orient_e right_force_orient;
   enum lstopo_orient_e below_force_orient;
   int show_indexes[HWLOC_OBJ_TYPE_MAX]; /* enabled by global toggle index_type */