Windows: How does Jupyter throw a keyboard interrupt?

Question

I know how to interrupt the kernel (such as by tapping I twice or by interrupting the kernel on the web interface). However, I built a C-extension for Python (I'm using Windows) that handles CTRL-C events in my C++ code (a toy example):

static int s_interrupted = 0;

BOOL WINAPI consoleHandler(DWORD fdwCtrlType) {

  switch (fdwCtrlType)
  {
  // Handle the CTRL-C signal.
  case CTRL_C_EVENT:
      s_interrupted = 1;
      return TRUE;
  }
}

int main() {
    s_interrupted = 0;
    int output = 1;
    if (!SetConsoleCtrlHandler(consoleHandler, TRUE)) {
        std::cout<<"ERROR: Could not set control handler"<<std::endl;
    } else {
        std::cout<<"Control hanlder installed"<<std::endl;
    }
    int k = 10000;
    while (int i < k) {
        if (s_interrupted == 1) {
            output = -1;
            break;
        }
         output = i
         i = i + 1;
    }
    return output;
}

The output of my main program changes depending on the value of s_interrupted. In other words, if I don't press CTRL+C, the program will finish the while loop and return an integer. If I press CTRL+C, the while loop will be terminated and return a different integer. I don't expect to see a KeyboardInterrupt in my Python terminal.

It works fine, when I call this C extension in the terminal. However, when I do it in a Jupyter notebook, the program behaves as if I never interrupted the kernel. Does Jupyter not send a SIGINT when I interrupt the kernel?

Have you read the [Jupyter messaging documentation](https://jupyter-client.readthedocs.io/en/stable/messaging.html)? Restarting a kernel is just another message from front-end to back-end. — Martijn Pieters, Jan 16 '19 at 11:40

user7860670 · Answer 1 · 2019-01-15T19:51:05.413

1

Your code does not install signal handlers and s_signal_handler is not used. You need to call signal function to register your callback.

#include <atomic>
#include <signal.h>

::std::atomic<bool> s_interrupted{};

static void signal_handler(int signal)
{
  s_interrupted = true;
}

int main()
{
    ::signal(SIGINT, &::signal_handler);

edited Jan 15 '19 at 19:51

answered Jan 15 '19 at 19:48

user7860670

35,849
4
58
84

Sorry, I updated my code. `s_signal_handler` is not necessary here. I already have `consoleHandler`. What does `::signal()` do? – user1691278 Jan 15 '19 at 19:51
@user1691278 `signal` function registers signal handlers so you can actually handle `SIGINT` – user7860670 Jan 15 '19 at 19:52
doesn't `SetConsoleCtrlHandler` do the job though? – user1691278 Jan 15 '19 at 19:59
@user1691278 It kinda does, but it is a windows specific thing and signal handlers are more portable. And `CTRL+C` is not exactly the same as `SIGINT` – user7860670 Jan 15 '19 at 20:05
What is `CTRL+C` then? – user1691278 Jan 15 '19 at 20:07
Now I see `forrtl: error (200): program aborting due to control-C event` and quits Python. This is not exactly what I wanted: I wanted the program to return a different integer when I send `CTRL+C`. – user1691278 Jan 15 '19 at 20:13
@user1691278 There is no way to hit Ctrl+C fast enough to interrupt this loop unless you intentionally slow program execution somehow. – user7860670 Jan 15 '19 at 20:44

Martijn Pieters · Answer 2 · 2021-07-23T18:17:06.280

You can't use consoleHandler() here, because there is no console. The IPython kernel is a 'headless' child process that executes code on request, directed by the Jupyter frontend.

To interrupt a running IPython kernel, the Jupyter front-end uses the SIGINT signal. It does so on both POSIX and on Windows; on Windows Jupyter uses additional infrastructure built around CreateEventA, SetEvent and WaitForMultipleObjects to achieve the same result as a POSIX os.killpg(PID, SIGINT) call; a separate thread polls for the event and triggers a SIGINT signal in the main thread.

Note that the IPython kernel explicitly restores the Python default signal handler for every message it handles. See the ipykernel.kernelbase.Kernel implementations for the pre_ and post_handler_hook methods:

 self.saved_sigint_handler = signal(SIGINT, default_int_handler)

and

 signal(SIGINT, self.saved_sigint_handler)

These two hooks are executed before and after every message handler (so for every message sent by the frontend to the kernel process, including execute messages).

It is signal.default_int_handler that raises KeyboardInterrupt in the main Python thread. If your code must detect interrupts, it will need to register its own signal handler each time IPython executes a cell.

As a side note: a standalone interactive Python interpreter doesn't use SetConsoleCtrlHandler to detect keyboard interrupts either; the only place that is used in the Python source code is in the py launcher, and only then to silence control codes with a handler that returns TRUE, always. Instead, Python relies on Windows sending the SIGINT signal to all attached console processes for the active console window.

Windows: How does Jupyter throw a keyboard interrupt?

2 Answers2