Extension to mpi programs save restore bkp

.github/workflows/tests.yml

@@ -7,11 +7,14 @@ on:
   push:
     branches:
       - master
+      - extension_to_mpi_programs
+      - extension_to_mpi_programs_save_restore_bkp
   release:
 
 jobs:
   run_tests:
     runs-on: ${{ matrix.os }}
+    timeout-minutes: 8
     strategy:
       matrix:
         os: [ubuntu-latest]
@@ -27,9 +30,13 @@ jobs:
         run: |
           python -m pip install --upgrade pip
           pip install nox
-      - name: Install gdb ubuntu
+      - name: Install gdb gdbserver and openmpi ubuntu
         run: |
-          sudo apt-get install gdb
+          sudo apt-get update
+          sudo apt-get install gdb gdbserver openmpi-bin libopenmpi-dev
+      - name: Compiling node_names
+        run: |
+          cd gdbgui-mpi && ./compile.sh
       - name: Execute Tests
         run: |
           nox --non-interactive --session tests-${{ matrix.python-version }}

MANIFEST.in

@@ -7,6 +7,11 @@ graft gdbgui
 # are generated
 graft gdbgui/static/js
 
+include gdbgui-mpi/compile.sh
+include gdbgui-mpi/launch_gdb_server
+include gdbgui-mpi/launch_mpi_debugger
+include gdbgui-mpi/main.cpp
+
 prune examples
 prune downloads
 prune screenshots
@@ -15,6 +20,7 @@ prune docs
 prune docker
 prune images
 prune gdbgui/__pycache__
+prune gdbgui/server/__pycache__
 
 exclude mypy.ini
 exclude .eslintrc.json

gdbgui-mpi/compile.sh

@@ -0,0 +1,3 @@
+#! /bin/bash
+
+mpic++ -g -O0 -o print_nodes main.cpp

gdbgui-mpi/launch_gdb_server

@@ -0,0 +1,8 @@
+#!/bin/sh
+# Usage: debug_server.sh <executable> <arguments>
+
+GDB_HOST=$(hostname)
+GDB_PORT=$(( 60000 + $OMPI_COMM_WORLD_RANK ))
+echo "GDB server for rank $OMPI_COMM_WORLD_RANK available on $GDB_HOST:$GDB_PORT"
+exec gdbserver :$GDB_PORT $*
+

gdbgui-mpi/launch_mpi_debugger

@@ -0,0 +1,14 @@
+#!/bin/bash
+
+DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null 2>&1 && pwd )"
+
+mpirun --oversubscribe -np $1 $DIR/print_nodes
+if [ ! -d gdbgui-mpi ]; then
+    mkdir gdbgui-mpi
+fi
+mv nodes_name gdbgui-mpi/
+mpirun --oversubscribe -np $1 $DIR/launch_gdb_server ${@:2} # &
+rm nodes_name
+#python -m gdbgui-mpi
+
+

gdbgui-mpi/main.cpp

@@ -0,0 +1,81 @@
+#include <mpi.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <string>
+#include <sstream>
+#include <iostream>
+
+int main(int argc, char** argv) {
+    // Initialize the MPI environment
+    MPI_Init(NULL, NULL);
+
+    // Get the number of processes
+    int world_size;
+    MPI_Comm_size(MPI_COMM_WORLD, &world_size);
+
+    // Get the rank of the process
+    int world_rank;
+    MPI_Comm_rank(MPI_COMM_WORLD, &world_rank);
+
+    char name_[256];
+    int ret = gethostname(name_,256);
+    std::string name(name_);
+
+    if (ret == 0)
+    {
+        int name_max_s = name.size()+1;
+	int name_max_r = 0;
+
+	MPI_Allreduce(&name_max_s,&name_max_r,1,MPI_INT,MPI_MAX,MPI_COMM_WORLD);
+
+	std::stringstream ss;
+
+	ss.width(10);
+	ss << std::left << world_rank;
+	ss.width(name_max_r);
+	ss << name << std::endl;
+
+	std::string proc_name = ss.str();
+
+	if (world_rank == 0)
+	{
+		char * nodes;
+		nodes = new char [(proc_name.size()+1)*world_size];
+		MPI_Gather(proc_name.c_str(),proc_name.size()+1,MPI_CHAR,
+			      nodes,proc_name.size()+1,MPI_CHAR,0,MPI_COMM_WORLD);
+
+		// fiter names
+		std::stringstream sf;
+
+		for (int i = 0 ; i < world_size ; i++)
+		{
+			sf << std::string(&nodes[i*(proc_name.size()+1)]);
+		}		
+
+		FILE * pFile;
+                pFile = fopen("nodes_name","w");
+                if (pFile!=NULL)
+                {
+                    fputs (sf.str().c_str(),pFile);
+                    fclose (pFile);
+                }
+		else
+		{
+		    printf("Error cannot create nodes_name \n");
+		}
+	}
+	else
+	{
+            MPI_Gather(proc_name.c_str(),proc_name.size()+1,MPI_CHAR,
+                       NULL,0,MPI_CHAR,0,MPI_COMM_WORLD);
+	}
+    }
+    else
+    {
+        MPI_Abort(MPI_COMM_WORLD,-1);
+    }
+
+    // Finalize the MPI environment.
+    MPI_Finalize();
+}
+

gdbgui/cli.py

@@ -16,9 +16,12 @@
 
 from gdbgui import __version__
 from gdbgui.server.app import app, socketio
-from gdbgui.server.constants import DEFAULT_GDB_EXECUTABLE, DEFAULT_HOST, DEFAULT_PORT
-from gdbgui.server.server import run_server
-
+from gdbgui.server.constants import (
+    DEFAULT_GDB_EXECUTABLE,
+    DEFAULT_HOST,
+    DEFAULT_PORT,
+)
+import gdbgui.server.server
 
 logger = logging.getLogger(__name__)
 logger.setLevel(logging.WARNING)
@@ -245,7 +248,7 @@ def main():
             "and https://sourceware.org/gdb/onlinedocs/gdb/Starting.html"
         )
 
-    run_server(
+    gdbgui.server.server.run_server(
         app=app,
         socketio=socketio,
         host=args.host,

gdbgui/server/app.py

@@ -193,6 +193,81 @@ def run_gdb_command(message: Dict[str, str]):
         emit("error_running_gdb_command", {"message": "gdb is not running"})
 
 
+@socketio.on("run_gdb_command_mpi", namespace="/gdb_listener")
+def run_gdb_command_mpi(message: Dict[str, str]):
+    """
+    Endpoint for a websocket route.
+    Runs a gdb command over multiple sessions.
+    Responds only if an error occurs when trying to write the command to
+    gdb
+    """
+    if message["processor"] != -1:
+        """ If the command is target we have to handle differently """
+        cmd = message["cmd"]
+        cmds_tcheck = cmd[0].split(" ")
+        if cmds_tcheck[0] == "-target-select" and cmds_tcheck[1] == "remote":
+            debug_session = manager.debug_session_from_mpi_processor_id(-1)
+            if debug_session is not None:
+                debug_session.set_mpi_rank(int(cmds_tcheck[2].split(":")[1]) - 60000)
+        debug_session = manager.debug_session_from_mpi_processor_id(
+            int(message["processor"])
+        )
+        if debug_session is not None:
+            pty_mi = debug_session.pygdbmi_controller
+            if pty_mi is not None:
+                try:
+                    # the command (string) or commands (list) to run
+                    cmds = message["cmd"]
+                    for cmd in cmds:
+                        pty_mi.write(
+                            cmd + "\n",
+                            timeout_sec=0,
+                            raise_error_on_timeout=False,
+                            read_response=False,
+                        )
+
+                except Exception:
+                    err = traceback.format_exc()
+                    logger.error(err)
+                    emit("error_running_gdb_command", {"message": err})
+        else:
+            emit("error_running_gdb_command", {"message": "gdb is not running"})
+    else:
+        """
+        execute the command for all controllers
+        """
+        for debug_session, client_ids in manager.get_controllers().items():
+            if debug_session is None:
+                continue
+            try:
+                # the command (string) or commands (list) to run
+                cmd = message["cmd"]
+                pty_mi = debug_session.pygdbmi_controller
+                if pty_mi is not None:
+                    try:
+                        # the command (string) or commands (list) to run
+                        cmds = message["cmd"]
+                        for cmd in cmds:
+                            pty_mi.write(
+                                cmd + "\n",
+                                timeout_sec=0,
+                                raise_error_on_timeout=False,
+                                read_response=False,
+                            )
+
+                    except Exception:
+                        err = traceback.format_exc()
+                        logger.error(err)
+                        emit("error_running_gdb_command", {"message": err})
+            #                debug_session.write(cmd, read_response=False)
+            # in case is the connection command take the port number to understand the mpi process rank
+
+            except Exception:
+                err = traceback.format_exc()
+                logger.error(err)
+                emit("error_running_gdb_command", {"message": err})
+
+
 def send_msg_to_clients(client_ids, msg, error=False):
     """Send message to all clients"""
     if error:
@@ -221,50 +296,77 @@ def test_disconnect():
     print("Client websocket disconnected", request.sid)
 
 
-def read_and_forward_gdb_and_pty_output():
-    """A task that runs on a different thread, and emits websocket messages
-    of gdb responses"""
+@socketio.on("open_mpi_sessions", namespace="/gdb_listener")
+def open_mpi_sessions(message):
+    """
+    In MPI we kill all old sessions and we open new sessions
+    """
 
-    while True:
-        socketio.sleep(0.05)
-        debug_sessions_to_remove = []
-        for debug_session, client_ids in manager.debug_session_to_client_ids.items():
+    manager.exit_all_gdb_processes_except_client_id(request.sid)
+
+    for i in range(1, int(message["processors"])):
+        gdb_command = request.args.get("gdb_command", app.config["gdb_command"])
+        mi_version = request.args.get("mi_version", "mi2")
+        manager.add_new_debug_session(
+            gdb_command=gdb_command, mi_version=mi_version, client_id=request.sid
+        )
+
+
+def process_controllers_out():
+    debug_sessions_to_remove = []
+    for debug_session, client_ids in manager.debug_session_to_client_ids.items():
+        try:
             try:
-                try:
-                    response = debug_session.pygdbmi_controller.get_gdb_response(
-                        timeout_sec=0, raise_error_on_timeout=False
-                    )
+                response = debug_session.pygdbmi_controller.get_gdb_response(
+                    timeout_sec=0, raise_error_on_timeout=False
+                )
 
-                except Exception:
-                    response = None
-                    send_msg_to_clients(
-                        client_ids,
-                        "The underlying gdb process has been killed. This tab will no longer function as expected.",
-                        error=True,
+            except Exception:
+                response = None
+                send_msg_to_clients(
+                    client_ids,
+                    "The underlying gdb process has been killed. This tab will no longer function as expected.",
+                    error=True,
+                )
+                debug_sessions_to_remove.append(debug_session)
+
+            if response:
+                """Attach processor information"""
+                for r in response:
+                    r["proc"] = debug_session.mpi_rank
+                    if r["type"] == "notify":
+                        if r["message"] == "thread-group-started":
+                            debug_session.inferior_pid = int(r["payload"]["pid"])
+
+                # Here we parse for thread-group-started to get the inferior_pid
+
+                for client_id in client_ids:
+                    logger.info("emiting message to websocket client id " + client_id)
+                    socketio.emit(
+                        "gdb_response",
+                        response,
+                        namespace="/gdb_listener",
+                        room=client_id,
                     )
-                    debug_sessions_to_remove.append(debug_session)
+            else:
+                # there was no queued response from gdb, not a problem
+                pass
 
-                if response:
-                    for client_id in client_ids:
-                        logger.info(
-                            "emiting message to websocket client id " + client_id
-                        )
-                        socketio.emit(
-                            "gdb_response",
-                            response,
-                            namespace="/gdb_listener",
-                            room=client_id,
-                        )
-                else:
-                    # there was no queued response from gdb, not a problem
-                    pass
+        except Exception:
+            logger.error(traceback.format_exc())
+
+    debug_sessions_to_remove += check_and_forward_pty_output()
+    for debug_session in set(debug_sessions_to_remove):
+        manager.remove_debug_session(debug_session)
 
-            except Exception:
-                logger.error(traceback.format_exc())
 
-        debug_sessions_to_remove += check_and_forward_pty_output()
-        for debug_session in set(debug_sessions_to_remove):
-            manager.remove_debug_session(debug_session)
+def read_and_forward_gdb_and_pty_output():
+    """A task that runs on a different thread, and emits websocket messages
+    of gdb responses"""
+
+    while True:
+        socketio.sleep(0.05)
+        process_controllers_out()
 
 
 def check_and_forward_pty_output() -> List[DebugSession]: