Interrupt running program and save data

How to design a C/C++ program so that it can save some data after receiving interrupt signal.

I have a long running program that I might need to kill (say, by pressing Ctrl-C) before it finished running. When killed (as opposed to running to conclusion) the program should be able to save some variables to disk. I have several big Linux books, but not very sure where to start. A cookbook recipe开发者_如何转开发 would be very helpful.

Thank you.!

---

to do that, you need to make your program watch something, for example a global variable, that will tell him to stop what it is doing.

For example, supposing your long-running program execute a loop, you can do that :

g_shouldAbort = 0;
while(!finished)
{
   // (do some computing)

   if (g_shouldAbort)
   {
      // save variables and stuff
      break; // exit the loop
   }
}

with g_shouldAbort defined as a global volatile variable, like that :

static volatile int g_shouldAbort = 0;

(It is very important to declare it "volatile", or else the compiler, seeing that no one write it in the loop, may consider that if (g_shouldAbort) will always be false and optimize it away.)

then, using for example the signal API that other users suggested, you can do that :

void signal_handler(int sig_code)
{
   if (sig_code == SIGUSR1) // user-defined signal 1
      g_shouldAbort = 1;
}

(you need to register this handler of course, cf. here.

signal(SIGUSR, signal_handler);

Then, when you "send" the SIGUSR1 signal to your program (with the kill command for example), g_shouldAbort will be set to 1 and your program will stop its computing.

Hope this help !

NOTE : this technique is easy but crude. Using signals and global variables makes it difficult to use multiple threads of course, as other users have outlined.

---

What you want to do isn't trivial. You can start by installing a signal handler for SIGINT (C-c) using signal or sigaction but then the hard part starts.

The main problem is that in a signal handler you can only call async-signal-safe functions (or reentrant functions). Most library function can't be reliably considered reentrant. For instance, stdio functions, malloc, free and many others aren't reentrant.

So how do you handle this ? Set a flag in you handler (set some global variable done to 1) and look out for EINTR errors. It should be safe to do the cleanup outside the handler.

---

What you are trying to do falls under the rubric of checkpoint/restart.

There's several big problems with using a signal-driven scheme for checkpoint/restart. One is that signal handlers have to be very compact and very primitive. You cannot write the checkpoint inside your signal handler. Another problem is that your program can be anywhere in its execution state when the signal is sent. That random location almost certainly is not a safe point from which a checkpoint can be dropped. Yet another problem is that you need to outfit your program with some application-side checkpoint/restart capability.

Rather than rolling your own checkpoint/restart capability, I suggest you look into using a free one that already exists. gdb on linux provides a checkpoint/restart capability. Another is DMTCP, see http://dmtcp.sourceforge.net/index.html .

---

Use signal(2) or sigaction(2) to assign a function pointer to the SIGINT signal, and do your cleanups there.

---

Make your you enter only once in your save function

// somewhere in main
signal( SIGTERM, signalHandler );
signal( SIGINT,  signalHandler );

void saveMyData()
{
    // save some data here
}

void signalHandler( int signalNumber )
{
    static pthread_once_t semaphore = PTHREAD_ONCE_INIT;
    std::cout << "signal " << signalNumber << " received." << std::endl;
    pthread_once( & semaphore, saveMyData );
}

If your process get 2 or more signals before you finish writing your file you'll save weird data