out-of-process JIT execution

Author: kr-2003

.vscode/settings.json

@@ -1,5 +1,54 @@
 {
     "files.associations": {
-        "iostream": "cpp"
+        "iostream": "cpp",
+        "fstream": "cpp",
+        "ios": "cpp",
+        "locale": "cpp",
+        "sstream": "cpp",
+        "__bit_reference": "cpp",
+        "__hash_table": "cpp",
+        "__locale": "cpp",
+        "__node_handle": "cpp",
+        "__split_buffer": "cpp",
+        "__tree": "cpp",
+        "__verbose_abort": "cpp",
+        "array": "cpp",
+        "bitset": "cpp",
+        "cctype": "cpp",
+        "clocale": "cpp",
+        "cmath": "cpp",
+        "cstddef": "cpp",
+        "cstdint": "cpp",
+        "cstdio": "cpp",
+        "cstdlib": "cpp",
+        "cstring": "cpp",
+        "ctime": "cpp",
+        "cwchar": "cpp",
+        "initializer_list": "cpp",
+        "iosfwd": "cpp",
+        "istream": "cpp",
+        "limits": "cpp",
+        "map": "cpp",
+        "mutex": "cpp",
+        "new": "cpp",
+        "print": "cpp",
+        "regex": "cpp",
+        "stdexcept": "cpp",
+        "streambuf": "cpp",
+        "string": "cpp",
+        "string_view": "cpp",
+        "typeinfo": "cpp",
+        "unordered_map": "cpp",
+        "vector": "cpp",
+        "cstdarg": "cpp",
+        "cwctype": "cpp",
+        "deque": "cpp",
+        "execution": "cpp",
+        "iomanip": "cpp",
+        "optional": "cpp",
+        "queue": "cpp",
+        "ratio": "cpp",
+        "stack": "cpp",
+        "variant": "cpp"
     }
 }

include/xeus-cpp/xdebugger.hpp

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

include/xeus-cpp/xinterpreter.hpp

@@ -40,6 +40,8 @@ namespace xcpp
         void publish_stdout(const std::string&);
         void publish_stderr(const std::string&);
 
+        static std::string get_current_pid();
+
     private:
 
         void configure_impl() override;

share/jupyter/kernels/xcpp17/kernel.json.in

@@ -13,6 +13,6 @@
       "-std=c++17"
   ],
   "language": "cpp",
-  "metadata": {"debugger": true
+  "metadata": {"debugger": false
   }
 }

src/xdebugger.cpp

@@ -1,20 +1,21 @@
 #include "xeus-cpp/xdebugger.hpp"
 
-#include <arpa/inet.h>  // For inet_pton(), htons()
-#include <chrono>       // For std::chrono (used in sleep_for)
+#include <arpa/inet.h>
+#include <chrono>
 #include <cstdlib>
 #include <fcntl.h>
 #include <fstream>
 #include <iostream>
-#include <netinet/in.h>  // For sockaddr_in, AF_INET
-#include <sys/socket.h>  // For socket(), connect(), send(), recv()
+#include <netinet/in.h>
+#include <sys/socket.h>
 #include <sys/types.h>
 #include <sys/wait.h>
 #include <thread>
 #include <unistd.h>
 
 #include "nlohmann/json.hpp"
 #include "xdebuglldb_client.hpp"
+#include "xeus-cpp/xinterpreter.hpp"
 #include "xeus-zmq/xmiddleware.hpp"
 #include "xeus/xsystem.hpp"
 #include "xinternal_utils.hpp"
@@ -56,8 +57,6 @@ namespace xcpp
             std::bind(&debugger::configuration_done_request, this, _1),
             true
         );
-
-        std::cout << "Debugger initialized with config: " << m_debugger_config.dump() << std::endl;
     }
 
     debugger::~debugger()
@@ -70,6 +69,7 @@ namespace xcpp
     bool debugger::start_lldb()
     {
         std::cout << "debugger::start_lldb" << std::endl;
+        jit_process_pid = xcpp::interpreter::get_current_pid();
 
         // Find a free port for LLDB-DAP
         m_lldb_port = xeus::find_free_port(100, 9999, 10099);
@@ -263,23 +263,6 @@ namespace xcpp
         );
         client.detach();
 
-        // Now test direct TCP communication
-        nl::json init_request = {
-            {"seq", 1},
-            {"type", "request"},
-            {"command", "initialize"},
-            {"arguments",
-             {{"adapterID", "xcpp17"},
-              {"clientID", "jupyterlab"},
-              {"clientName", "JupyterLab"},
-              {"columnsStartAt1", true},
-              {"linesStartAt1", true},
-              {"locale", "en"},
-              {"pathFormat", "path"},
-              {"supportsRunInTerminalRequest", true},
-              {"supportsVariablePaging", true},
-              {"supportsVariableType", true}}}
-        };
         // Also test ZMQ path
         send_recv_request("REQ");
 
@@ -295,42 +278,8 @@ namespace xcpp
     // Dummy implementations for other methods
     nl::json debugger::inspect_variables_request(const nl::json& message)
     {
-        // Placeholder DAP response
-        // std::cout << "Sending setBreakpoints request..." << std::endl;
-        // nl::json breakpoint_request = {
-        //     {"seq", 3},
-        //     {"type", "request"},
-        //     {"command", "setBreakpoints"},
-        //     {"arguments", {
-        //         {"source", {
-        //             {"name", "input_line_1"},
-        //             {"path", "/Users/abhinavkumar/Desktop/Coding/Testing/input_line_1"}
-        //         }},
-        //         {"breakpoints", {{{"line", 8}}}},
-        //         {"lines", {8}},
-        //         {"sourceModified", false}
-        //     }}
-        // };
-        // nl::json breakpoint_reply = forward_message(breakpoint_request);
-        // std::cout << "Breakpoint reply: " << breakpoint_reply.dump() << std::endl;
-        // nl::json config_done_request = {
-        //     {"seq", 4},
-        //     {"type", "request"},
-        //     {"command", "configurationDone"}
-        // };
-        // nl::json config_reply = forward_message(config_done_request);
-        // std::cout << "Configuration done reply: " << config_reply.dump() << std::endl;
-
-        // nl::json run_request = {
-        //     {"seq", 5},
-        //     {"type", "request"},
-        //     {"command", "continue"},
-        //     {"arguments", nl::json::object()}
-        // };
-        // nl::json run_reply = forward_message(run_request);
-        // std::cout << "Continue reply: " << run_reply.dump() << std::endl;
-
-        std::cout << "inspect_variables_request not implemented" << std::endl;
+        std::cout << "[debugger::inspect_variables_request] inspect_variables_request not implemented"
+                  << std::endl;
         std::cout << message.dump() << std::endl;
         nl::json reply = {
             {"type", "response"},
@@ -339,16 +288,12 @@ namespace xcpp
             {"command", message["command"]},
             {"body",
              {{"variables",
-               {{{"name", "a"},
-             {"value", "100"},
-             {"type", "int"},
-             {"evaluateName", "a"},
-             {"variablesReference", 0}},
-            {{"name", "b"},
-             {"value", "1000"},
-             {"type", "int"},
-             {"evaluateName", "b"},
-             {"variablesReference", 0}}}}}}
+               {{{"name", "a"}, {"value", "100"}, {"type", "int"}, {"evaluateName", "a"}, {"variablesReference", 0}},
+                {{"name", "b"},
+                 {"value", "1000"},
+                 {"type", "int"},
+                 {"evaluateName", "b"},
+                 {"variablesReference", 0}}}}}}
         };
         return reply;
     }
@@ -372,17 +317,16 @@ namespace xcpp
     {
         // 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", message["arguments"].value("pid", 0)},
-            {"program", message["arguments"].value("program", "")},
-            {"stopOnEntry", message["arguments"].value("stopOnEntry", false)},
-            {"initCommands", message["arguments"].value("initCommands", nl::json::array())}
+                {"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;

src/xinterpreter.cpp

@@ -46,25 +46,32 @@ void* createInterpreter(const Args &ExtraArgs = {}) {
     ClangArgs.push_back(CxxInclude.c_str());
   }
   ClangArgs.insert(ClangArgs.end(), ExtraArgs.begin(), ExtraArgs.end());
+
   // FIXME: We should process the kernel input options and conditionally pass
   // the gpu args here.
-  return Cpp::CreateInterpreter(ClangArgs/*, {"-cuda"}*/);
+  if (std::find_if(ExtraArgs.begin(), ExtraArgs.end(), [](const std::string& s) {
+    return s == "-gdwarf-4";}) == ExtraArgs.end()) {
+    // If no debugger option, then use the non-OOP JIT execution.
+    return Cpp::CreateInterpreter(ClangArgs/*, {"-cuda"}*/);
+  }
+  
+  // If debugger option is set, then use the OOP JIT execution.
+  return Cpp::CreateInterpreter(ClangArgs, {}, true);
 }
 
 using namespace std::placeholders;
 
 namespace xcpp
 {
     struct StreamRedirectRAII {
-      std::string &err;
-      StreamRedirectRAII(std::string &e) : err(e) {
+      std::string &out, &err;
+      StreamRedirectRAII(std::string &o, std::string &e) : out(o), err(e) {
         Cpp::BeginStdStreamCapture(Cpp::kStdErr);
         Cpp::BeginStdStreamCapture(Cpp::kStdOut);
       }
       ~StreamRedirectRAII() {
-        std::string out = Cpp::EndStdStreamCapture();
+        out = Cpp::EndStdStreamCapture();
         err = Cpp::EndStdStreamCapture();
-        std::cout << out;
       }
     };
 
@@ -73,6 +80,33 @@ namespace xcpp
         xeus::register_interpreter(this);
     }
 
+    std::string interpreter::get_current_pid() 
+    {
+        const char* code = R"(
+#include <iostream>
+#include <unistd.h>
+std::cout << getpid() << std::endl;
+    )";
+
+        std::string pid_str, err;
+        bool compilation_result = false;
+        {
+            StreamRedirectRAII R(pid_str, err);
+            compilation_result = Cpp::Process(code);
+        }
+        if (compilation_result) {
+            std::cerr << "Error getting OOP JIT pid: " << err << std::endl;
+            return "";
+        } else {
+            std::cout << "Current OOP JIT PID: " << pid_str << std::endl;
+        }
+        // Remove trailing newline from pid_str if present
+        if (!pid_str.empty() && pid_str.back() == '\n') {
+            pid_str.pop_back();
+        }
+        return pid_str;
+    }
+
     static std::string get_stdopt()
     {
         // We need to find what's the C++ version the interpreter runs with.
@@ -109,7 +143,7 @@ __get_cxx_version ()
     {
         //NOLINTNEXTLINE (cppcoreguidelines-pro-bounds-pointer-arithmetic)
         createInterpreter(Args(argv ? argv + 1 : argv, argv + argc));
-        m_version = get_stdopt();
+        // m_version = get_stdopt();
         redirect_output();
         init_preamble();
         init_magic();
@@ -162,12 +196,12 @@ __get_cxx_version ()
             std::cerr.rdbuf(&null);
         }
 
-        std::string err;
+        std::string out, err;
 
         // Attempt normal evaluation
         try
         {
-            StreamRedirectRAII R(err);
+            StreamRedirectRAII R(out, err);
             compilation_result = Cpp::Process(code.c_str());
         }
         catch (std::exception& e)
@@ -188,6 +222,9 @@ __get_cxx_version ()
             ename = "Error: ";
             evalue = "Compilation error! " + err;
             std::cerr << err;
+        } else {
+            std::cout << "EHLLOE" << std::endl;
+            std::cout << out;
         }
 
         // Flush streams