gdb/testsuite/gdb.rocm: generalize the multi-inferior driver program

Generalize multi-inferior-gpu.cpp into a shared driver for the
multi-inferior tests so the breakpoint markers the lib/rocm.exp helpers
rely on live in one program instead of being duplicated.  The child
count is taken from argv when given and otherwise defaults to the number
of GPU devices found at runtime, and each child re-execs itself through
a "child" argv dispatch.

Give rocm_multi_inferior_run_to_kernels default argument values so
callers that want runtime discovery can omit them.

Author: spatrang

gdb/testsuite/gdb.rocm/multi-inferior-gpu.cpp

@@ -15,12 +15,28 @@
    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
 
+/* Shared driver program for the gdb.rocm multi-inferior tests.
+
+   The parent process forks N children; each child re-execs itself so
+   that its GPU runtime is initialized in a clean address space, then
+   launches its own GPU kernel.  Re-exec'ing makes each child a separate
+   process from the operating system's point of view, which is what the
+   multi-inferior tests debug concurrently.
+
+   N comes from argv[1] when given; otherwise it defaults to the number
+   of GPU devices found at runtime (one child per device).  The
+   companion .exp helpers in lib/rocm.exp plant breakpoints on the
+   pre-fork and post-join source markers and on the kernel.  */
+
 #include <sys/types.h>
 #include <sys/wait.h>
 #include <unistd.h>
 #include <hip/hip_runtime.h>
+#include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
+#include <string.h>
+#include <string>
 
 #include "rocm-test-utils.h"
 
@@ -30,77 +46,99 @@ kern ()
   asm ("s_sleep 1");
 }
 
-/* Spawn one child process per detected GPU.  */
+static int
+child (int argc, char **argv)
+{
+  if (argc < 4)
+    {
+      fprintf (stderr, "%s: expected: child <idx> <num_devices>\n",
+	       argv[0]);
+      return -1;
+    }
+
+  int idx = atoi (argv[2]);
+  int num_devices = atoi (argv[3]);
+  if (num_devices <= 0)
+    {
+      fprintf (stderr, "child %d: invalid num_devices %d\n", idx,
+	       num_devices);
+      return -1;
+    }
+
+  CHECK (hipSetDevice (idx % num_devices));
+  kern<<<1, 1>>> ();
+  CHECK (hipDeviceSynchronize ());
+  return 0;
+}
+
+/* Spawn NUM_CHILDREN child processes.  When NUM_CHILDREN is not
+   positive, spawn one child per detected GPU device.  */
 
 static int
-parent (int argc, char **argv)
+parent (const char *argv0, int num_children)
 {
-  /* Identify how many GPUs we have, and spawn one child for each.  */
   int num_devices;
   CHECK (hipGetDeviceCount (&num_devices));
+  if (num_devices <= 0)
+    {
+      fprintf (stderr, "no GPU devices available\n");
+      return -1;
+    }
+
+  if (num_children <= 0)
+    num_children = num_devices;
 
   /* Break here.  */
 
-  for (int i = 0; i < num_devices; i++)
+  for (int i = 0; i < num_children; i++)
     {
-      char n[32] = {};
-      snprintf (n, sizeof (n), "%d", i);
+      std::string idx_str = std::to_string (i);
+      std::string ndev_str = std::to_string (num_devices);
+
       pid_t pid = fork ();
       if (pid == -1)
 	{
-	  perror ("Fork failed");
+	  perror ("fork");
 	  return -1;
 	}
 
       if (pid == 0)
 	{
-	  /* Exec to force the child to re-initialize the ROCm runtime.  */
-	  if (execl (argv[0], argv[0], n, nullptr) == -1)
+	  if (execl (argv0, argv0, "child", idx_str.c_str (),
+		     ndev_str.c_str (), (char *) nullptr) == -1)
 	    {
-	      perror ("Failed to exec");
-	      return -1;
+	      perror ("execl");
+	      _exit (127);
 	    }
 	}
     }
 
-  /* Wait for all children.  */
+  /* Reap every child.  Any non-zero exit from a child is a failure
+     (e.g. a runtime initialization failure under contention).  */
+  int failed = 0;
   while (true)
     {
       int ws;
       pid_t ret = waitpid (-1, &ws, 0);
       if (ret == -1 && errno == ECHILD)
 	break;
+      if (ret > 0 && (!WIFEXITED (ws) || WEXITSTATUS (ws) != 0))
+	failed++;
     }
 
   /* Last break here.  */
-  return 0;
-}
-
-static int
-child (int argc, char **argv)
-{
-  int dev_number;
-  if (sscanf (argv[1], "%d", &dev_number) != 1)
-    {
-      fprintf (stderr, "Invalid argument \"%s\"\n", argv[1]);
-      return -1;
-    }
-
-  CHECK (hipSetDevice (dev_number));
-  kern<<<1, 1>>> ();
-  CHECK (hipDeviceSynchronize ());
-  return 0;
+  return failed == 0 ? 0 : 1;
 }
 
-/* When called with no argument, identify how many AMDGPU devices are
-   available on the system and spawn one worker process per GPU.  If a
-   command-line argument is provided, it is the index of the GPU to use.  */
-
 int
 main (int argc, char **argv)
 {
-  if (argc <= 1)
-    return parent (argc, argv);
-  else
+  if (argc >= 2 && strcmp (argv[1], "child") == 0)
     return child (argc, argv);
+
+  int num_children = 0;
+  if (argc >= 2)
+    num_children = atoi (argv[1]);
+
+  return parent (argv[0], num_children);
 }

gdb/testsuite/gdb.rocm/multi-inferior-gpu.exp

@@ -32,7 +32,7 @@ proc do_test {} {
     with_rocm_gpu_lock {
 	# Spawn one child inferior per detected GPU.  The child count
 	# is discovered from "num_devices" at the pre-fork stop.
-	set threads [rocm_multi_inferior_run_to_kernels "" ""]
+	set threads [rocm_multi_inferior_run_to_kernels]
 	rocm_multi_inferior_drain $threads
     }
 }

gdb/testsuite/lib/rocm.exp

@@ -686,21 +686,21 @@ gdb_caching_proc compiler_dwarf_language {} {
 # run the parent to the pre-fork breakpoint, resume everything in the
 # background, and wait for one "kern" breakpoint stop per child.
 #
-#   args_list  - arguments passed via "set args" ("" for none).
+#   arg_list   - arguments passed via "set args" ("" for none).
 #   expected   - number of child stops to wait for.  If "", it is read
 #                from the "num_devices" value at the pre-fork stop.
 #
 # Return the list of stopped GPU thread ids (one per child).
 
-proc rocm_multi_inferior_run_to_kernels { args_list expected } {
+proc rocm_multi_inferior_run_to_kernels { {arg_list ""} {expected ""} } {
     clean_restart
     gdb_load $::binfile
 
     gdb_test_no_output "set non-stop on"
     gdb_test_no_output "set detach-on-fork off"
     gdb_test_no_output "set follow-fork parent"
-    if { $args_list ne "" } {
-	gdb_test_no_output "set args $args_list"
+    if { $arg_list ne "" } {
+	gdb_test_no_output "set args $arg_list"
     }
 
     gdb_breakpoint [gdb_get_line_number "Break here"]