Programming

This might be about the coolest site I've ever seen. Anyway, diplomacy is over-rated

I don't disagree at all about the performance hit. I came up with the C++ object just to pack all of whatever it's gonna do into something that can be tucked away in a generic library and offer an easy way to trigger something. I like it because it keeps all the dirty work of checking the clock out of the main code. So, the utility can look something like:

// xxx is each of sound, graphics_cache, file_activity, port_status, whatever_else
struct xxx_Manager : Chronisitcs
{
xxx_Manager(int ms) : Chronistics(ms) {}
virtual bool operator()();
}

bool xxx_Manager:perator()()
{
if (!trigger()) return false;
// it's time to do whatever an xxx manager should do
return true;
}

while (1)
{
// just do whatever you normally do...
// each line turns out to be a function object based on the Chonistics thingy
sound_manager();
graphic_cache_manager();
geometry_manager();
collision_manager();
file_activity_manager();
port_status_manager();
magic_spell_manager();
socket_service_manager();
whatever_else_manager();
// probably need some kind of system call here or you'll tank.
// usually a short sleep does the trick.
usleep(10);
}

...and all the logic of determining when to actually do the stuff is handled in the Chronistic guts. However it's done, it happens exactly the same way for every Chronistic derivative. And, of course then, you can have stacks and deques and maps of managed objects, and traverse them, sort them, update them in whatever order you want, index them, well, you get the point. It can get pretty interesting.

But, what I really want to know is, what is the best way to get the kernel to signal something periodically. And, can it be done without a worker thread?

Alas C++ is like the electric guitar which amplifies the mistakes as well as the good notes.

You don't need a ton of managers hard coded as you have, you can simply have a linked list of tasks that have to be performed together with the criteria for when to invoke them, an excellent example is how X11 Intrinsics manage the event loop allowing all manner of widgets to be supported in addition to file descriptor sinks, event timers and work procedures.

So when you want to add a new manager you don't have to change the code in the main event loop.

What OS does the iPhone use?


Change your

Code:

usleep(10);

to

Code:

usleep(nextTimedEvent ? ( nextTimedEvent->when - now ) : kForever);

and you have solved your problem.

With UNIX, unless

(a) you are writing a simple filter program, or compiler, etc,

(b) one that is not interactive

(c) does not use networking

(d) is a multithreaded program

(e) a few more exceptions I can't immediately think of

the main loop of your program should be built directly or indirectly on either select or poll and you should be trying to determine the longest timeout value.

Do you know of any samples of select being used as a cron trigger?

Both ncurses and libXt have either select() or poll() at the heart of their mainloop/scheduler.

Hence KDE, Gnome, Motif, LessTif etc all sit on select or poll.

I'll have to look at that.
Can you do this on every OS?

Most operating systems have an equivalent.

In Windows GUI land it's GetMessage(), in Winsock[2] it's select(), also WaitForMultipleObjects().

Palm programs have a message loop at the heart of any program.

What ever you are doing, do it efficiently, even if you are doing nothing, do nothing as efficiently as possible.