Programming

Hi,

I am looking for a C library feature, to which I can say execute a function every 10 seconds.

for Eg

Code:

#include <timer_lib.h>
fun1(){
      printf("I am still cool "); 
}

int main(){
   run(10,&fun1); // Should register & execute the function fun1 every 10 seconds
 return 0x0;
}

I am not interested in using the sleep function in a while loop or something..
Is there such a feature in the standard C library ??. I have heard about such facilities available on the kernel libraries.

here is one shot,

register the function that has to be executed frequently as handler to the SIGALRM signal

and raise the alarm periodically

I've seen the SIGALRM solution mentioned a few times, it's not good because it encourages heavyweight responses in signal handlers, as signals are asynchronous they can trash the heap if you are doing memory allocation/deallocation in the handler.

1. use a simple loop

Code:

while (1) {
     sleep(10);
     do_stuff();
}

2. do other stuff as well

Code:

while (1) {
      select with timeout
      if (time_is_ripe()) do_stuff();
}

3. use a callback from a library

Code:

XtAppAddTimeout(app,interval,do_stuff,data);

// chronistic.h
struct Chronistic
{
Chronistic(int _seconds) : seconds(_seconds) {next(time(0));}
virtual bool operator()() = 0; // pure virtural, never call from c'tor or d'tor
private: int seconds;
protected:
bool trigger()
{
time_t now = time(0);
if (now > trigger_target) return next(now); // always true
else return false;
}
private:
time_t trigger_target;
bool next(time_t now) // must not be virtual, must not call anything virtual (it's used in the c'tor). Always returns true.
{
trigger_target=now+seconds;
return true;
}
};


// chronistic.cpp
#include <iostream>
#include <cstdlib>

#include <string>
#include "chronistic.h"


using namespace std;


struct MyChronFunction : Chronistic
{
MyChronFunction(int seconds) : Chronistic(seconds) {}
virtual bool operator()()
{
if (!trigger()) return false;
cout<<"Time to do something"<<endl;
return true;
}
};


int main(int argc, char *argv[])
{
MyChronFunction cronologic(90); // setup to execute every 90 seconds
while (true)
{
cronologic();
usleep(10); // prevents race condition
}

return EXIT_SUCCESS;
}

That is awful

(a) nothing like using C++ to make a simple problem complicated.

(b) nothing like using C++ to obscure the fact that you have a truely terrible solution

You basically have a polling loop executing every 10 microseconds, when you should be telling the operating system the maximum time you are prepared to go to sleep for and let the OS put your task to sleep and get on and do other things.

If you have a list of tasks, you should find the earliest that something needs to be done then sleep until that time.

I like C++. Wasn't trying to do anything real fancy with the os, just a simple polling check might suffice.

Thanks for the feedback.

There is nothing wrong with using C++, but don't use it like a magician's sleight of hand to obscure a poor implementation.

No problem.