How to terminate a function call after a timeout?

Question

Let's say I have a foo() function. I want it to run in, for example, 5 seconds, after that, it has to be cancelled and continues to do the rest of the program.

Code snippets:

int main() {
    // Blah blah
    foo(); // Running in 5 sec only
    // After 5 sec, came here and finished
}

References: After a while searching on StackOverflow, I found this is what I need but written in python: Timeout on a function call.

signal.h and unistd.h can be related.

Answer 1

This is possible with threads. Since C++20, it will be fairly simple:

{
    std::jthread t([](std::stop_token stoken) {
        while(!stoken.stop_requested()) {
            // do things that are not infinite, or are interruptible
        }
    });

    using namespace std::chrono_literals;
    std::this_thread::sleep_for(5s);
}

Note that many interactions with the operating system cause the process to be "blocked". An example of such is the POSIX function listen, which waits for incoming connections. If the thread is blocked, then it will not be able to proceed to the next iteration.

Unfortunately, the C++ standard doesn't specify whether such platform specific calls should be interrupted by request to stop or not. You need to use platform specific methods to make sure that happens. Typically, signals can be configured to interrupt blocking system calls. In case of listen, an option is to connect to the waiting socket.

Answer 2

There is no way to do that uniformly in C++. There are ways to do this with some degree of success when you use OS specific APIs, however it all becomes extremely cumbersome.

The basic idea which you can use in *nix is a combination of alarm() system call and setjmp/longjmp C function.

A (pseudo) code:

std::jmp_buf jump_buffer;

void alarm_handle(int ) {
    longjmp(jump_buffer);
}

int main() {
   signal(SIGALRM, alarm_handle); 
    alarm(5);
    if (setjmp(jump_buffer)) {
        foo(); // Running in 5 sec only
     } else {
        // After 5 sec, came here and finished
        // if we are here, foo timed out
     } 
}

This all is extremely fragile and shaky (i.e. long jumps do not place nicely with C++ objects lifetime), but if you know what you are doing this might work.

Answer 3

Perfectly standard C++11

#include <iostream>
#include <thread>         // std::this_thread::sleep_for
#include <chrono>         // std::chrono::seconds

using namespace std;

// stop flag
bool stopfoo;

// function to run until stopped
void foo()
{
    while( ! stopfoo )
    {
        // replace with something useful
        std::this_thread::sleep_for (std::chrono::seconds(1));
        std::cout << "still working!\n";
    }
    std::cout "stopped\n";
}

// function to call a top after 5 seconds
void timer()
{
    std::this_thread::sleep_for (std::chrono::seconds( 5 ));
    stopfoo = true;
}

int main()
{
    // initialize stop flag
    stopfoo = false;

    // start timer in its own thread
    std::thread t (timer);

    // start worker in main thread
    foo();

    return 0;
}

Here is the same thing with a thread safe stop flag ( not really neccessary, but good practice for more complex cases )

#include <iostream>
#include <thread>         // std::this_thread::sleep_for
#include <chrono>         // std::chrono::seconds
#include <mutex>

using namespace std;

class cFlagThreadSafe
{
public:
    void set()
    {
        lock_guard<mutex> l(myMtx);
        myFlag = true;
    }
    void unset()
    {
        lock_guard<mutex> l(myMtx);
        myFlag = false;
    }
    bool get()
    {
         lock_guard<mutex> l(myMtx);
         return myFlag;
    }
private:
    bool myFlag;
    mutex myMtx;
};

// stop flag
cFlagThreadSafe stopfoo;

// function to run until stopped
void foo()
{
    while( ! stopfoo.get() )
    {
        // replace with something useful
        this_thread::sleep_for (std::chrono::seconds(1));
        cout << "still working!\n";
    }
    cout << "stopped\n";
}

// function to call a top after 5 seconds
void timer()
{
    this_thread::sleep_for (chrono::seconds( 5 ));
    stopfoo.set();
}

int main()
{
    // initialize stop flag
    stopfoo.unset();

    // start timer in its own thread
    thread t (timer);

    // start worker in main thread
    foo();

    t.join();

    return 0;
}

And if it is OK to do everything in the main thread, things can be greatly simplified.

#include <iostream>
#include <thread>         // std::this_thread::sleep_for
#include <chrono>         // std::chrono::seconds

using namespace std;

void foo()
{
    auto t1 = chrono::steady_clock ::now();

    while( chrono::duration_cast<chrono::seconds>(
                chrono::steady_clock ::now() - t1 ).count() < 5 )
    {
        // replace with something useful
        this_thread::sleep_for (std::chrono::seconds(1));
        cout << "still working!\n";
    }
    cout << "stopped\n";
}

int main()
{
    // start worker in main thread
    foo();

    return 0;
}