工作者线程堆栈溢出时的信息出口

Question

I'm writing a C++ program which is going to run a bunch of worker threads on recursive data, such that even though I've increased the default stack space, it's possible that a thread might hit a stack overflow.

The ideal would be to have the stack dynamically expand as needed, but if that's not possible, it's acceptable to have the program fail, and for the user to retry after recompiling it with a larger stack size.

The problem with the default behavior of the program crashing with no error message is that the user has no way of knowing what the problem was or what to do about it; for all the user knows, the program might have tried to divide by zero or dereference a null pointer; so if the program must crash, I'd like it to print "Stack overflow" to stderr first.

Obviously there isn't going to be a solution in portable C++ but I would be happy with one solution that works on Windows and another that works on Linux.

Looking at ways to have the program exit with an informative error message on Windows, I've been reading the documentation on vectored and structured exception handling; one problem is that these seem to be local to a thread, and a thread can't safely write to stderr; at best you get a race condition.

Is there a known method of dealing with this?

Answer 1

The OS (Linux or Unix flavours at least) allow you to catch stack faults.

Something like this:

 // Note: Calling printf here is probably not a brilliant idea, 
 // as we're in a signal handler. It is NOT well-defined what happens.
 void handler(int arg)
 {
    fprintf(stderr, "Crashed due to signal handler\n"); 
    exit(42);
 }

Then in main or some such ...

 struct sigaction sa = { handler, NULL, 0, 0, NULL };
 struct sigaction oldsa;
 sigaction(SIGSTKFLT, sa, oldsa);

I will try to come up with a bit more of a "complete" solution, with some experiments in a bit.

(I believe it is possible to replace the stack, but I don't think you can, in a meaningful way, actually continue at that point, just allows you to recover in a more sane way than simply crashing!)

This APPEARS to work:

#include <signal.h>
#include <unistd.h>
#include <iostream>
#include <cstdlib>

void handler(int arg)
{
    write(2, "stack overflow\n", 15);
    _exit(42);
}

void* duh(void *arg)
{
    if(duh(arg))
    {
        return duh(NULL);
    }
    else
    {
        return duh(arg);
    }
}

void* crash_wrapper(void *arg)
{
    static char stack[SIGSTKSZ];
    stack_t ss = {};
    ss.ss_sp = stack;
    ss.ss_size = SIGSTKSZ;
    sigaltstack(&ss, 0);

    struct sigaction sa = {};
    sa.sa_handler = handler;
    sa.sa_flags = SA_ONSTACK,
    sigfillset(&sa.sa_mask);
    sigaction(SIGSEGV, &sa, 0);

    return duh(arg);
}

int main()
{
    pthread_t t;
    int status = pthread_create(&t, 0, crash_wrapper, 0 );

    for(;;)
    {
        std::cout << "Still going..." << std::endl;
        sleep(1);
    }
}

I'm not entirely happy with the write inside the handler, but all other methods that I tried didn't seem to work either... :(