out-of-process JIT execution

Author: kr-2003

include/xeus-cpp/xdebugger.hpp

@@ -69,7 +69,7 @@ namespace xcpp
         bool m_is_running;
         int m_tcp_socket;
         bool m_tcp_connected;
-        std::string jit_process_pid;
+        pid_t jit_process_pid;
     };
 
     XEUS_CPP_API

include/xeus-cpp/xinterpreter.hpp

@@ -40,7 +40,7 @@ namespace xcpp
         void publish_stdout(const std::string&);
         void publish_stderr(const std::string&);
 
-        static std::string get_current_pid();
+        static pid_t get_current_pid();
 
     private:
 

src/xdebugger.cpp

@@ -61,197 +61,97 @@ namespace xcpp
 
     debugger::~debugger()
     {
-        std::cout << "Stopping debugger..........." << std::endl;
         delete p_debuglldb_client;
         p_debuglldb_client = nullptr;
     }
 
     bool debugger::start_lldb()
     {
-        std::cout << "debugger::start_lldb" << std::endl;
-        jit_process_pid = xcpp::interpreter::get_current_pid();
+        jit_process_pid = interpreter::get_current_pid();
 
-        // Find a free port for LLDB-DAP
         m_lldb_port = xeus::find_free_port(100, 9999, 10099);
         if (m_lldb_port.empty())
         {
-            std::cout << "Failed to find a free port for LLDB-DAP" << std::endl;
+            std::cerr << "Failed to find a free port for LLDB-DAP" << std::endl;
             return false;
         }
 
-        // Log debugger configuration if XEUS_LOG is set
-        if (std::getenv("XEUS_LOG") != nullptr)
+        if (std::getenv("XEUS_LOG"))
         {
-            std::ofstream out("xeus.log", std::ios_base::app);
-            out << "===== DEBUGGER CONFIG =====" << std::endl;
-            out << m_debugger_config.dump() << std::endl;
+            std::ofstream log("xeus.log", std::ios::app);
+            log << "===== DEBUGGER CONFIG =====\n";
+            log << m_debugger_config.dump(4) << '\n';
         }
 
-        // Build C++ code to start LLDB-DAP process
-        std::string code = "#include <iostream>\n";
-        code += "#include <string>\n";
-        code += "#include <vector>\n";
-        code += "#include <cstdlib>\n";
-        code += "#include <unistd.h>\n";
-        code += "#include <sys/wait.h>\n";
-        code += "#include <fcntl.h>\n";
-        code += "using namespace std;\n\n";
-        code += "int main() {\n";
+        std::vector<std::string> lldb_args = {"lldb-dap", "--port", m_lldb_port};
 
-        // Construct LLDB-DAP command arguments
-        code += "    vector<string> lldb_args = {\"lldb-dap\", \"--port\", \"" + m_lldb_port + "\"};\n";
-        // Add additional configuration from m_debugger_config
-        auto it = m_debugger_config.find("lldb");
-        if (it != m_debugger_config.end() && it->is_object())
-        {
-            if (it->contains("initCommands"))
-            {
-                std::cout << "Adding init commands to lldb-dap command" << std::endl;
-                for (const auto& cmd : it->at("initCommands").get<std::vector<std::string>>())
-                {
-                    std::cout << "Adding command: " << cmd << std::endl;
-                    // Escape quotes in the command for C++ string
-                    std::string escaped_cmd = cmd;
-                    size_t pos = 0;
-                    while ((pos = escaped_cmd.find("\"", pos)) != std::string::npos)
-                    {
-                        escaped_cmd.replace(pos, 1, "\\\"");
-                        pos += 2;
-                    }
-                    while ((pos = escaped_cmd.find("\\", pos)) != std::string::npos
-                           && pos < escaped_cmd.length() - 1)
-                    {
-                        if (escaped_cmd[pos + 1] != '\"')
-                        {
-                            escaped_cmd.replace(pos, 1, "\\\\");
-                            pos += 2;
-                        }
-                        else
-                        {
-                            pos += 2;
-                        }
-                    }
-                    code += "    lldb_args.push_back(\"--init-command\");\n";
-                    code += "    lldb_args.push_back(\"" + escaped_cmd + "\");\n";
-                }
-            }
-        }
-
-        // Set up log directory and file
         std::string log_dir = xeus::get_temp_directory_path() + "/xcpp_debug_logs_"
                               + std::to_string(xeus::get_current_pid());
         xeus::create_directory(log_dir);
         std::string log_file = log_dir + "/lldb-dap.log";
 
-        // Add code to start the subprocess with proper redirection
-        code += "    string log_file = \"" + log_file + "\";\n";
-        code += "    \n";
-        code += "    pid_t pid = fork();\n";
-        code += "    if (pid == 0) {\n";
-        code += "        // Child process - redirect stdout/stderr to log file\n";
-        code += "        int fd = open(log_file.c_str(), O_WRONLY | O_CREAT | O_TRUNC, 0644);\n";
-        code += "        if (fd != -1) {\n";
-        code += "            dup2(fd, STDOUT_FILENO);\n";
-        code += "            dup2(fd, STDERR_FILENO);\n";
-        code += "            close(fd);\n";
-        code += "        }\n";
-        code += "        \n";
-        code += "        // Redirect stdin to /dev/null\n";
-        code += "        int null_fd = open(\"/dev/null\", O_RDONLY);\n";
-        code += "        if (null_fd != -1) {\n";
-        code += "            dup2(null_fd, STDIN_FILENO);\n";
-        code += "            close(null_fd);\n";
-        code += "        }\n";
-        code += "        \n";
-        code += "        // Convert vector to char* array for execvp\n";
-        code += "        vector<char*> args;\n";
-        code += "        for (auto& arg : lldb_args) {\n";
-        code += "            args.push_back(const_cast<char*>(arg.c_str()));\n";
-        code += "        }\n";
-        code += "        args.push_back(nullptr);\n";
-        code += "        \n";
-        code += "        execvp(\"lldb-dap\", args.data());\n";
-        code += "        \n";
-        code += "        // If execvp fails\n";
-        code += "        cerr << \"Failed to execute lldb-dap\" << endl;\n";
-        code += "        exit(1);\n";
-        code += "    }\n";
-        code += "    else if (pid > 0) {\n";
-        code += "        // Parent process\n";
-        code += "        cout << \"LLDB-DAP process started, PID: \" << pid << endl;\n";
-        code += "        \n";
-        code += "        // Check if process is still running\n";
-        code += "        int status;\n";
-        code += "        if (waitpid(pid, &status, WNOHANG) != 0) {\n";
-        code += "            cerr << \"LLDB-DAP process exited early\" << endl;\n";
-        code += "            return 1;\n";
-        code += "        }\n";
-        code += "        \n";
-        code += "        cout << \"LLDB-DAP started successfully\" << endl;\n";
-        code += "    }\n";
-        code += "    else {\n";
-        code += "        cerr << \"fork() failed\" << endl;\n";
-        code += "        return 1;\n";
-        code += "    }\n";
-        code += "    \n";
-        code += "    return 0;\n";
-        code += "}\n";
+        pid_t pid = fork();
+        if (pid == 0)
+        {
+            int fd = open(log_file.c_str(), O_WRONLY | O_CREAT | O_TRUNC, 0644);
+            if (fd != -1)
+            {
+                dup2(fd, STDOUT_FILENO);
+                dup2(fd, STDERR_FILENO);
+                close(fd);
+            }
 
-        std::cout << "Starting LLDB-DAP with port: " << m_lldb_port << std::endl;
+            int null_fd = open("/dev/null", O_RDONLY);
+            if (null_fd != -1)
+            {
+                dup2(null_fd, STDIN_FILENO);
+                close(null_fd);
+            }
 
-        // Execute the C++ code via control messenger
-        nl::json json_code;
-        json_code["code"] = code;
-        nl::json rep = xdebugger::get_control_messenger().send_to_shell(json_code);
-        std::string status = rep["status"].get<std::string>();
+            std::vector<char*> argv;
+            for (auto& arg : lldb_args)
+            {
+                argv.push_back(const_cast<char*>(arg.c_str()));
+            }
+            argv.push_back(nullptr);
 
-        std::cout << "LLDB-DAP start response: " << rep.dump() << std::endl;
+            execvp("lldb-dap", argv.data());
 
-        if (status != "ok")
+            std::cerr << "Failed to execute lldb-dap" << std::endl;
+            std::exit(1);
+        }
+        else if (pid > 0)
         {
-            std::string ename = rep["ename"].get<std::string>();
-            std::string evalue = rep["evalue"].get<std::string>();
-            std::vector<std::string> traceback = rep["traceback"].get<std::vector<std::string>>();
-            std::clog << "Exception raised when trying to start LLDB-DAP" << std::endl;
-            for (std::size_t i = 0; i < traceback.size(); ++i)
+            int status;
+            if (waitpid(pid, &status, WNOHANG) != 0)
             {
-                std::clog << traceback[i] << std::endl;
+                std::cerr << "LLDB-DAP process exited prematurely." << std::endl;
+                return false;
             }
-            std::clog << ename << " - " << evalue << std::endl;
-            return false;
+            m_is_running = true;
+            return true;
         }
         else
         {
-            std::cout << xcpp::green_text("LLDB-DAP process started successfully") << std::endl;
+            std::cerr << "fork() failed" << std::endl;
+            return false;
         }
-
-        m_is_running = true;
-        return status == "ok";
     }
 
     bool debugger::start()
     {
-        std::cout << "Starting debugger..." << std::endl;
-
-        // Start LLDB-DAP process
         static bool lldb_started = start_lldb();
         if (!lldb_started)
         {
-            std::cout << "Failed to start LLDB-DAP" << std::endl;
+            std::cerr << "Failed to start LLDB-DAP" << std::endl;
             return false;
         }
-        // Bind xeus debugger sockets for Jupyter communication
+
         std::string controller_end_point = xeus::get_controller_end_point("debugger");
         std::string controller_header_end_point = xeus::get_controller_end_point("debugger_header");
         std::string publisher_end_point = xeus::get_publisher_end_point();
         bind_sockets(controller_header_end_point, controller_end_point);
 
-        std::cout << "Debugger sockets bound to: " << controller_end_point << std::endl;
-        std::cout << "Debugger header sockets bound to: " << controller_header_end_point << std::endl;
-        std::cout << "Publisher sockets bound to: " << publisher_end_point << std::endl;
-        std::cout << "LLDB-DAP host: " << m_lldb_host << ", port: " << m_lldb_port << std::endl;
-
-        // Start LLDB-DAP client thread (for ZMQ communication)
         std::string lldb_endpoint = "tcp://" + m_lldb_host + ":" + m_lldb_port;
         std::thread client(
             &xdebuglldb_client::start_debugger,
@@ -263,24 +163,28 @@ namespace xcpp
         );
         client.detach();
 
-        // Also test ZMQ path
         send_recv_request("REQ");
 
-        // std::cout << forward_message(init_request).dump() << std::endl;
-
-        // Create temporary folder for cell code
         std::string tmp_folder = get_tmp_prefix();
         xeus::create_directory(tmp_folder);
 
         return true;
     }
 
-    // Dummy implementations for other methods
+    nl::json debugger::attach_request(const nl::json& message)
+    {
+        // Placeholder DAP response
+        nl::json attach_request =
+            {{"seq", 2}, {"type", "request"}, {"command", "attach"}, {"arguments", {{"pid", jit_process_pid}}}};
+        std::cout << "Sending attach request: " << attach_request.dump() << std::endl;
+        nl::json reply = forward_message(attach_request);
+        return reply;
+    }
+
     nl::json debugger::inspect_variables_request(const nl::json& message)
     {
         std::cout << "[debugger::inspect_variables_request] inspect_variables_request not implemented"
                   << std::endl;
-        std::cout << message.dump() << std::endl;
         nl::json reply = {
             {"type", "response"},
             {"request_seq", message["seq"]},
@@ -300,8 +204,6 @@ namespace xcpp
 
     nl::json debugger::stack_trace_request(const nl::json& message)
     {
-        // Placeholder DAP response
-        std::cout << "stack_trace_request not implemented" << std::endl;
         nl::json reply = {
             {"type", "response"},
             {"request_seq", message["seq"]},
@@ -313,29 +215,8 @@ namespace xcpp
         return reply;
     }
 
-    nl::json debugger::attach_request(const nl::json& message)
-    {
-        // Placeholder DAP response
-        std::cout << "debugger::attach_request" << std::endl;
-        std::cout << "Message: " << message.dump() << std::endl;
-        nl::json attach_request = {
-            {"seq", 2},
-            {"type", "request"},
-            {"command", "attach"},
-            {"arguments", {
-                {"pid", jit_process_pid}
-            }}
-        };
-        std::cout << "Sending attach request: " << attach_request.dump() << std::endl;
-        nl::json reply = forward_message(attach_request);
-        std::cout << "Attach request sent: " << reply.dump() << std::endl;
-        return reply;
-    }
-
     nl::json debugger::configuration_done_request(const nl::json& message)
     {
-        // Minimal DAP response to allow DAP workflow to proceed
-        std::cout << "configuration_done_request not implemented" << std::endl;
         nl::json reply = {
             {"type", "response"},
             {"request_seq", message["seq"]},
@@ -347,8 +228,6 @@ namespace xcpp
 
     nl::json debugger::variables_request_impl(const nl::json& message)
     {
-        // Placeholder DAP response
-        std::cout << "variables_request_impl not implemented" << std::endl;
         nl::json reply = {
             {"type", "response"},
             {"request_seq", message["seq"]},
@@ -362,8 +241,6 @@ namespace xcpp
 
     void debugger::stop()
     {
-        // Placeholder: Log stop attempt
-        std::cout << "Debugger stop called" << std::endl;
         std::string controller_end_point = xeus::get_controller_end_point("debugger");
         std::string controller_header_end_point = xeus::get_controller_end_point("debugger_header");
         unbind_sockets(controller_header_end_point, controller_end_point);
@@ -372,7 +249,6 @@ namespace xcpp
     xeus::xdebugger_info debugger::get_debugger_info() const
     {
         // Placeholder debugger info
-        std::cout << "get_debugger_info called" << std::endl;
         return xeus::xdebugger_info(
             xeus::get_tmp_hash_seed(),
             get_tmp_prefix(),
@@ -386,7 +262,6 @@ namespace xcpp
     std::string debugger::get_cell_temporary_file(const std::string& code) const
     {
         // Placeholder: Return a dummy temporary file path
-        std::cout << "get_cell_temporary_file called" << std::endl;
         std::string tmp_file = get_tmp_prefix() + "/cell_tmp.cpp";
         std::ofstream out(tmp_file);
         out << code;
@@ -402,12 +277,6 @@ namespace xcpp
         const nl::json& debugger_config
     )
     {
-        std::cout << "Creating C++ debugger" << std::endl;
-        std::cout << "Debugger config: " << debugger_config.dump() << std::endl;
-        std::cout << "User name: " << user_name << std::endl;
-        std::cout << "Session ID: " << session_id << std::endl;
-        // std::cout << "Context: " << context.get_context_id() << std::endl;
-        // std::cout << "Config: " << config.dump() << std::endl;
         return std::unique_ptr<xeus::xdebugger>(
             new debugger(context, config, user_name, session_id, debugger_config)
         );