diff --git a/.github/actions/spelling/allow/names.txt b/.github/actions/spelling/allow/names.txt index f6f77f9..f0e4dbb 100644 --- a/.github/actions/spelling/allow/names.txt +++ b/.github/actions/spelling/allow/names.txt @@ -1,6 +1,7 @@ Abdulrasool Abdelrhman Abhigyan +Abhinav Alexandru Alja Anandh @@ -95,6 +96,7 @@ aaronj aaronjomyjoseph abdelrhman abhi +abhinav acherjan acherjee aditya diff --git a/.github/actions/spelling/allow/terms.txt b/.github/actions/spelling/allow/terms.txt index 9eafc95..029ce3a 100644 --- a/.github/actions/spelling/allow/terms.txt +++ b/.github/actions/spelling/allow/terms.txt @@ -11,6 +11,7 @@ GPT GSo GSoC HSF +IIT JIT'd Jacobians LLMs @@ -35,6 +36,7 @@ gitlab gridlay gsoc gpu +jit jthread llm llvm @@ -51,8 +53,12 @@ superbuilds vimeo www xcolors +xcpp +xdap +xdebugger xeus xjson +xlldb xmagics xplugin youtu diff --git a/_data/contributors.yml b/_data/contributors.yml index ab5ef9b..da6ba31 100644 --- a/_data/contributors.yml +++ b/_data/contributors.yml @@ -384,6 +384,27 @@ proposal: /assets/docs/Abdelrhman_Elrawy_Proposal_GSoC_2025.pdf mentors: Vassil Vassilev, Alexander Penev +- name: Abhinav Kumar + photo: Abhinav.jpg + info: "Google Summer of Code 2025 Contributor" + email: abhinavdnpiasb@gmail.com + education: "Computer Science & Engineering, Bachelor of Technology, Indian Institute of Technology(IIT) Indore, India" + github: "https://github.com/kr-2003" + active: 1 + linkedin: "https://www.linkedin.com/in/abhinavkumar2105/" + projects: + - title: "Implementing Debugging Support for xeus-cpp" + status: Ongoing + description: | + This project aims at integrating debugging into the xeus-cpp kernel for + Jupyter using LLDB and its Debug Adapter Protocol (lldb-dap). Modeled + after xeus-python, it leverages LLDB’s Clang and JIT debugging support + to enable breakpoints, variable inspection, and step-through execution. + The modular design ensures compatibility with Jupyter’s frontend, + enhancing interactive C++ development in notebooks. + proposal: /assets/docs/Abhinav_Kumar_Proposal_GSoC_2025.pdf + mentors: Anutosh Bhat, Vipul Cariappa, Aaron Jomy, Vassil Vassilev + - name: "This could be you!" photo: rock.jpg info: See openings for more info diff --git a/_pages/team/abhinav-kumar.md b/_pages/team/abhinav-kumar.md new file mode 100644 index 0000000..c6c659e --- /dev/null +++ b/_pages/team/abhinav-kumar.md @@ -0,0 +1,10 @@ +--- +title: "Compiler Research - Team - Abhinav Kumar" +layout: gridlay +excerpt: "Compiler Research: Team members" +sitemap: false +permalink: /team/AbhinavKumar +email: abhinavdnpiasb@gmail.com +--- + +{% include team-profile.html %} \ No newline at end of file diff --git a/_posts/2025-05-22-implementing-debugger-support-for-xeus-cpp.md b/_posts/2025-05-22-implementing-debugger-support-for-xeus-cpp.md new file mode 100644 index 0000000..21b1aa9 --- /dev/null +++ b/_posts/2025-05-22-implementing-debugger-support-for-xeus-cpp.md @@ -0,0 +1,78 @@ +--- +title: "Implementing Debugging Support for xeus-cpp" +layout: post +excerpt: "A GSoC 2025 project aiming at integration of debugger into the xeus-cpp kernel for Jupyter using LLDB and its Debug Adapter Protocol (lldb-dap)." +sitemap: false +author: Abhinav Kumar +permalink: blogs/gsoc25_abhinav_kumar_introduction_blog/ +banner_image: /images/blog/gsoc-banner.png +date: 2025-05-22 +tags: gsoc c++ debugger dap clang jupyter +--- + +### Introduction + +I am Abhinav Kumar, a final-year Computer Science and Engineering undergraduate at Indian Institute of Technology(IIT) Indore. I'm thrilled to be working with CERN-HSF for Google Summer of Code 2025 on the project "Implementing Debugging Support for xeus-cpp." + +**Mentors**: Anutosh Bhat, Vipul Cariappa, Aaron Jomy, Vassil Vassilev + + +### The Need for Seamless C++ Debugging in Jupyter + +[Jupyter](https://jupyter.org/) notebooks have revolutionized interactive computing, and kernels like [xeus-cpp](https://github.com/compiler-research/xeus-cpp/) bring the power of C++ to this environment. However, while writing and executing C++ code incrementally is great, the debugging experience can be a hurdle. Developers often need to step through their code, inspect variables, and understand the program's state, especially when dealing with the complexities that C++ can present. This project aims to bridge that gap by integrating robust debugging capabilities directly into the xeus-cpp kernel. + +### Project Goal: Interactive Debugging with LLDB and DAP +The core idea is to bring a full-fledged debugging experience to xeus-cpp users within Jupyter. This means enabling features like: + +1. **Breakpoint Management**: Setting and removing breakpoints with ease. +2. **Variable Inspection**: Examining the values of variables at different execution stages. +3. **Step-Through Execution**: Controlling the flow of code execution (step in, step over, step out). +4. **Stack Tracing**: Understanding the call stack to pinpoint issues. + +To achieve this, the project will leverage existing, powerful technologies: + +1. **LLDB**: The [LLVM debugger](https://lldb.llvm.org/), which has excellent support for JIT-compiled code and Clang integration—perfect for how xeus-cpp executes code dynamically. +2. **Debug Adapter Protocol (DAP)**: A [standardized protocol](https://microsoft.github.io/debug-adapter-protocol//) by Microsoft that allows debuggers to communicate with development tools. This ensures compatibility with Jupyter's frontend and follows the successful model of [xeus-python](https://github.com/jupyter-xeus/xeus-python). + +A key design principle is to run the debugger (specifically, [lldb-dap](https://lldb.llvm.org/resources/lldbdap.html), which acts as a DAP server for LLDB) as an external process. This is crucial for kernel stability, preventing the Jupyter kernel from freezing when a breakpoint is hit. + +### Proposed Architecture Overview +The proposed system involves a few key components working together: +Project Architecture + +1. **Jupyter Environment (Notebook & Server)**: The user interface where DAP requests are initiated and responses are displayed. + +2. **xeus-cpp Kernel**: + - ``xcpp::debugger``: A new class that will manage the debugging session, inheriting from **xeus::xdebugger_base**. It will handle DAP messages and interact with the lldb-dap client. + - ``xcpp::xlldb_dap_client``: This component will manage the actual DAP communication with the external lldb-dap process. + - ``JIT Engine``: Compiles the C++ code from cells and notifies LLDB about new symbols. + +3. **External Debugger (lldb-dap & LLDB)**: + - ``lldb-dap``: Runs as a separate server, translating DAP messages into LLDB API calls and vice-versa. + - ``LLDB``: Executes the debugging actions on the JIT-compiled code. + +This modular design, inspired by [xeus-python](https://github.com/jupyter-xeus/xeus-python), aims for a lightweight integration that reuses existing xeus infrastructure where possible. + +### Progress and Path Forward + +I've already made some promising headway: + +1. Successfully demonstrated that LLDB can attach to and debug JIT-compiled code generated by [CppInterOp](https://github.com/compiler-research/CppInterOp/) (which xeus-cpp relies on). This involved ensuring symbols are resolved correctly when ``plugin.jit-loader.gdb.enable`` is active in LLDB. +2. Set up debugging in VSCode using lldb-dap for JIT-compiled code, proving the viability of lldb-dap for this context. +3. Experimented with running the lldb-dap executable on a specific port and sending DAP requests (initialize, launch, setBreakpoints, continue) via a Python script, successfully hitting breakpoints and getting stack traces. + +The roadmap includes: + +1. **Implementing debugger class**: Defining the main debugger class, handling the debugger lifecycle, and managing LLDB-DAP settings. A key modification will be using a "launch" request instead of "attach" (as xeus-python does), because LLDB needs to launch our custom executable containing the JIT code. This might require minor adjustments in xeus-zmq. +2. **Developing lldb-dap client**: This class will inherit from ``xeus::xdap_tcp_client`` and manage the low-level DAP communication. +3. **Robust Testing**: Implementing a comprehensive testing framework using [GoogleTest](https://github.com/google/googletest). + +### Expected Benefits and Future Scope + +Successfully completing this project will significantly enhance the C++ development experience within Jupyter notebooks. It will provide: + +1. A seamless, interactive debugging workflow for xeus-cpp users. +2. Increased productivity by allowing developers to quickly identify and fix bugs in their C++ notebook code. +3. A more robust and feature-complete C++ kernel for the Jupyter ecosystem. + +Looking ahead, the architecture is designed with future-proofing in mind, potentially supporting advanced features like remote debugging, alternative debuggers or debugger in xeus-cpp-lite. diff --git a/assets/docs/Abhinav_Kumar_Proposal_GSoC_2025.pdf b/assets/docs/Abhinav_Kumar_Proposal_GSoC_2025.pdf new file mode 100644 index 0000000..eead80b Binary files /dev/null and b/assets/docs/Abhinav_Kumar_Proposal_GSoC_2025.pdf differ diff --git a/images/blog/debugger_xeus_cpp_architecture.png b/images/blog/debugger_xeus_cpp_architecture.png new file mode 100644 index 0000000..ba9026b Binary files /dev/null and b/images/blog/debugger_xeus_cpp_architecture.png differ diff --git a/images/team/Abhinav.jpg b/images/team/Abhinav.jpg new file mode 100644 index 0000000..2a22087 Binary files /dev/null and b/images/team/Abhinav.jpg differ