Mixed python/C++ debugging

I would be really nice if there was a way to debug a program written in both python and C++ (with the python code calling into the C++), such that, at the points where the Python code calls into the C++, one could step into the C++ code.

I have found that the following works:

It turns out, that you can configure vscode to debug both the python code and the C/C++ code in a single session, but the steps to do this are a little tricky. I will explain those steps here.

For this explanation, suppose the python module you are debugging is “experiment.py”. In the instructions below, replace that with whatever you are using.

1. Set breakpoints in your python code and C/C++ code where you desire to stop.
2. Select a python debug configurations for your file. Either use a configuration that causes the python debugger to stop on entry, or ensure that you have set breakpoints before the point where the C++ code is called.
3. Start the selected python debug configuration, by clicking the green arrow, or hitting F5.
4. Find the pid of the running python session, using a command like:

ps auxww | grep experiment.py

This will likely produce three matching processes. Choose the one that has --connect on the command line.

5. Select and start a “(gdb) Attach” configuration like this:

{
"name": "(gdb) Attach",
"type": "cppdbg",
"request": "attach",
"program": "/path/to/your/python/interpreter",
"processId": "${command:pickProcess}",
"MIMode": "gdb",
"miDebuggerPath": "/usr/bin/gdb",
"setupCommands": [
{
"description": "Enable pretty-printing for gdb",
"text": "-enable-pretty-printing",
"ignoreFailures": true
}
]
},

and supply the pid found in the previous step. Note that by default you need super-user permission to attach to a process. However, you can get around this by setting /proc/sys/kernel/yama/ptrace_scope to 0.

Once you have done the previous step vscode will be in what is known as multi-target debugging. See https://code.visualstudio.com/Docs/editor/debugging#_multitarget-debugging. You can then select which debug session is current using a drop-down that is just to the right of the debug controls (i.e. where the buttons are for continuing, stepping, etc.). The buttons will act on whichever debug session you have selected. You will also see call-stacks for each debug session, and the variables and such displays will be for the selected debug session.
6. Select the “(gdb) Attach” session and select pause (F6), and then continue (F5). This incantation gives vscode a chance to insert your C++ breakpoints.
7. The above step should have caused the python debug session to be selected, but if not, select it. You can then continue stepping through your Python code as desired, and when it calls the C code, your breakpoints will be hit.
8. After the C code has finished, if you set any python breakpoints after the C call, they will be hit and you can examine the results.

Now, the above procedure works, but it would be useful if the python debugger could automate this (perhaps on request using a configuration parameter), by getting the pid automatically, and activating the C++ debugger with an attach.