How could one delay a function without the use of sleep / suspending the code?-CodePudding

I need to delay a function by x amount of time. The problem is that I can't use sleep nor any function that suspends the function (that's because the function is a loop that contains more function, sleeping / suspending one will sleep / suspend all)

Is there a way I could do it?

CodePudding user response：

If you want to execute some specific code at a certain time interval and don't want to use threads (to be able to suspend), then you have to keep track of time and execute the specific code when the delay time was exceeded.

Example (pseudo):

timestamp = getTime();

while (true) {

    if (getTime() - timestamp > delay) {

        //main functionality

        //reset timer
        timestamp = getTime();

    }

    //the other functionality you mentioned

}

With this approach, you invoke a specific fuction every time interval specified by delay. The other functions will be invoked at each iteration of the loop.

In other words, it makes no difference if you delay a function or execute it at specific time intervals.

CodePudding user response：

Assuming that you need to run functions with their own arguments inside of a loop with custom delay and wait for them to finish before each iteration:

#include <cstdio>

void func_to_be_delayed(const int &idx = -1, const unsigned &ms = 0)
{
    printf("Delayed response[%d] by %d ms!\n", idx, ms);
}

#include <chrono>
#include <future>

template<typename T, typename ... Ta>
void delay(const unsigned &ms_delay, T &func, Ta ... args)
{
    std::chrono::time_point<std::chrono::high_resolution_clock> start = std::chrono::high_resolution_clock::now();
    double elapsed;
    do {
        std::chrono::time_point<std::chrono::high_resolution_clock> end = std::chrono::high_resolution_clock::now();
        elapsed = std::chrono::duration<double, std::milli>(end - start).count();
    } while(elapsed <= ms_delay);
    func(args...);
}

int main()
{
    func_to_be_delayed();
    const short iterations = 5;
    for (int i = iterations; i >= 0; --i)
    {
        auto i0 = std::async(std::launch::async, [i]{ delay((i 1)*1000, func_to_be_delayed, i, (i 1)*1000); } );
        // Will arrive with difference from previous
        auto i1 = std::async(std::launch::async, [i]{ delay(i*1000, func_to_be_delayed, i, i*1000); } );
        func_to_be_delayed();
        // Loop will wait for all calls
    }
}

Notice: this method potentially will spawn additional thread on each call with std::launch::async type of policy.

CodePudding user response：

Standard solution is to implement event loop. If you use some library, framework, system API, then most probably there is something similar provided to solve this kind of problem.

For example Qt has QApplication which provides this loop and there is QTimer. boost::asio has io_context which provides even loop in which timer can be run boost::asio::deadline_timer.

You can also try implement such event loop yourself.

Example wiht boost:

#include <boost/asio.hpp>
#include <boost/date_time.hpp>
#include <exception>
#include <iostream>

void printTime(const std::string& label)
{
    auto timeLocal = boost::posix_time::second_clock::local_time();
    boost::posix_time::time_duration durObj = timeLocal.time_of_day();
    std::cout << label <<  " time = " << durObj << '\n';
}

int main() {
    boost::asio::io_context io_context;

    try {
        boost::asio::deadline_timer timer{io_context};
        timer.expires_from_now(boost::posix_time::seconds(5));

        timer.async_wait([](const boost::system::error_code& error){
            if (!error) {
                printTime("boom");
            } else {
                std::cerr << "Error: " << error << '\n';
            }
        });

        printTime("start");
        io_context.run();
    } catch (const std::exception& e) {
        std::cerr << e.what() << '\n';
    }
    return 0;
}

https://godbolt.org/z/nEbTvMhca

C 20 introduces coroutines, this could be a good solution too.

CodePudding user response：

C 11 provides us with std::condition_variable. In your timer you can wait until your condition has been met: https://stackoverflow.com/a/51817109/18265638