Extension to mpi programs

MANIFEST.in

@@ -3,6 +3,11 @@ include LICENSE
 
 graft gdbgui
 
+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

gdbgui-mpi/__init__.py

@@ -0,0 +1,15 @@
+import io
+import os
+import sys
+
+_base_dir = getattr(sys, "_MEIPASS", os.path.dirname(os.path.realpath(__file__)))
+_version = (
+    io.open(os.path.join(_base_dir, "../gdbgui/VERSION.txt"), "r", encoding="utf-8")
+    .read()
+    .strip()
+)
+
+__title__ = "gdbgui"
+__version__ = _version
+__author__ = "Chad Smith"
+__copyright__ = "Copyright Chad Smith"

gdbgui-mpi/__main__.py

@@ -0,0 +1,15 @@
+from gdbgui import backend
+import sys
+
+DEFAULT_PORT = 5000
+DEFAULT_GDB_PORT = 60000
+
+# start gdb-servers with mpi
+
+
+# Change the port for each mpi process
+sys.argv.append('-n')
+
+print(sys.argv)
+
+backend.main()

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,9 @@
+#!/bin/sh
+
+mpirun --oversubscribe -np $1 gdbgui-mpi/print_nodes
+mv nodes_name gdbgui-mpi/
+mpirun --oversubscribe -np $1 gdbgui-mpi/launch_gdb_server ${@:2} # &
+rm gdbgui-mpi/nodes_name
+#python -m gdbgui-mpi
+
+

gdbgui-mpi/main.cpp

@@ -0,0 +1,72 @@
+#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();
+	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()*world_size];
+		MPI_Gather(proc_name.c_str(),proc_name.size(),MPI_CHAR,
+			      nodes,proc_name.size(),MPI_CHAR,0,MPI_COMM_WORLD);
+		FILE * pFile;
+                pFile = fopen("nodes_name","w");
+                if (pFile!=NULL)
+                {
+                    fputs (nodes,pFile);
+                    fclose (pFile);
+                }
+		else
+		{
+		    printf("Error cannot create nodes_name \n");
+		}
+	}
+	else
+	{
+            MPI_Gather(proc_name.c_str(),proc_name.size(),MPI_CHAR,
+                       NULL,0,MPI_CHAR,0,MPI_COMM_WORLD);
+	}
+    }
+    else
+    {
+        MPI_Abort(MPI_COMM_WORLD,-1);
+    }
+
+    // Finalize the MPI environment.
+    MPI_Finalize();
+}
+

gdbgui/backend.py

@@ -173,6 +173,7 @@ def add_csrf_token_to_session():
 
 socketio = SocketIO()
 _state = StateManager(app.config)
+process_on_focus = 0
 
 
 def setup_backend(
@@ -364,6 +365,78 @@ def run_gdb_command(message):
         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):
+    """
+    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 = cmd[0].split(" ")
+        if cmds[0] == "-target-select" and cmds[1] == "remote":
+            controller = _state.get_controller_from_mpi_processor_id(-1)
+            _state.set_mpi_process_from_cotroller(
+                controller, int(cmds[2].split(":")[1]) - 60000
+            )
+        controller = _state.get_controller_from_mpi_processor_id(message["processor"])
+        if controller is not None:
+            try:
+                # the command (string) or commands (list) to run
+                cmd = message["cmd"]
+                controller.write(cmd, 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 controller, pair in _state.get_controllers().items():
+            try:
+                # the command (string) or commands (list) to run
+                cmd = message["cmd"]
+                controller.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})
+
+
+@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
+    """
+
+    _state.exit_all_gdb_processes_except_client_id(request.sid)
+
+    for i in range(1, int(message["processors"])):
+        # see if user wants to connect to existing gdb pid
+        desired_gdbpid = 0
+        ses = _state.connect_client(str(i), desired_gdbpid)
+        # This is required to send messages from multiple session to the same client
+        _state.connect_client(request.sid, ses["pid"])
+
+
+@socketio.on("change_process_focus", namespace="/gdb_listener")
+def change_process_focus(message):
+    """
+    Notify the user is focusing on a different process
+    """
+
+    # process_on_focus = int(message["proc"])
+
+
 def send_msg_to_clients(client_ids, msg, error=False):
     """Send message to all clients"""
     if error:
@@ -413,49 +486,57 @@ def test_disconnect():
     print("Client websocket disconnected", request.sid)
 
 
+def process_controllers_out():
+    controllers_to_remove = []
+    controller_items = _state.controller_to_client_ids.items()
+    for controller, client_ids in controller_items:
+        try:
+            try:
+                response = controller.get_gdb_response(
+                    timeout_sec=0, raise_error_on_timeout=False
+                )
+            except NoGdbProcessError:
+                response = None
+                send_msg_to_clients(
+                    client_ids[0],
+                    "The underlying gdb process has been killed. This tab will no longer function as expected.",
+                    error=True,
+                )
+                controllers_to_remove.append(controller)
+
+            if response:
+                """Attach processor information"""
+                for r in response:
+                    r["proc"] = client_ids[1]
+
+                for client_id in client_ids[0]:
+                    logger.info(
+                        "emiting message to websocket client id " + client_id[0]
+                    )
+                    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())
+
+    for controller in controllers_to_remove:
+        _state.remove_gdb_controller(controller)
+
+
 def read_and_forward_gdb_output():
     """A task that runs on a different thread, and emits websocket messages
     of gdb responses"""
 
     while True:
         socketio.sleep(0.05)
-        controllers_to_remove = []
-        controller_items = _state.controller_to_client_ids.items()
-        for controller, client_ids in controller_items:
-            try:
-                try:
-                    response = controller.get_gdb_response(
-                        timeout_sec=0, raise_error_on_timeout=False
-                    )
-                except NoGdbProcessError:
-                    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,
-                    )
-                    controllers_to_remove.append(controller)
-
-                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())
-
-        for controller in controllers_to_remove:
-            _state.remove_gdb_controller(controller)
+        process_controllers_out()
 
 
 def server_error(obj):
@@ -518,6 +599,15 @@ def wrapper(*args, **kwargs):
     return wrapper
 
 
+@app.route("/mpi_processes_info", methods=["GET"])
+def mpi_processes_info():
+    """
+    Get information about mpi processes
+    """
+    f = open("gdbgui-mpi/nodes_name", "r")
+    return Response(f.read(), mimetype="text/plain")
+
+
 @app.route("/", methods=["GET"])
 @authenticate
 def gdbgui():
@@ -578,7 +668,13 @@ def send_signal_to_pid():
     signal_value = int(SIGNAL_NAME_TO_OBJ[signal_name])
 
     try:
-        os.kill(pid_int, signal_value)
+        if pid_int != -1:
+            os.kill(pid_int, signal_value)
+        else:
+            for controller in _state.get_controllers():
+                pid_int = controller.gdb_process.pid
+                os.kill(pid_int, signal_value)
+
     except Exception:
         return (
             jsonify(