Timer Q

[sip.address]

Hello,

I'm trying to find some existing (and simple if possible) timer queue
implementation. Does anybody know a simple skeleton to use as example?
I just need to send simple (relative) timeouts. Thought about some
possibilities but would prefer to use something already tested.

Thanksç

 

[Victor Bazarov]

I'm trying to find some existing (and simple if possible) timer queue
implementation. Does anybody know a simple skeleton to use as example?
I just need to send simple (relative) timeouts. Thought about some
possibilities but would prefer to use something already tested.

C++ language does not define "timers". There are no standard C++ means
to achieve what you need, I'm afraid. Did you perhaps mean to post to
the newsgroup dedicated to your OS?

V

 

[sip.address]

C++ language does not define "timers". There are no standard C++ means
to achieve what you need, I'm afraid. Did you perhaps mean to post to
the newsgroup dedicated to your OS?

Hi,

Thanks for your reply. I know I'm asking something that is not
completely standard, but I was looking for a portable implementation
of a timer queue. Ideally implemented using the stdlib. Of course,
there will be some os dependent parts but the algorithm itself should
be rather portable.

regards

 

[Victor Bazarov]

Hi,

Thanks for your reply. I know I'm asking something that is not
completely standard, but I was looking for a portable implementation
of a timer queue. Ideally implemented using the stdlib. Of course,
there will be some os dependent parts but the algorithm itself should
be rather portable.

If you're looking for the algorithm, this is not the right place either.

If the algorithm is the same whether it's written in C++ or, say, in
Java or Python, then .lang. newsgroups are not appropriate. Try asking
in 'comp.programming'. If you _have_ the algorithm but don't know how
to implement it in C++, then it *is* a language problem and you need to
start explaining what difficulty you have. You also have to explicitly
state that you have looked in other available sources, like Google, and
couldn't find anything.

This is not "give me your implementation of <blah> in C++" newsgroup.
This is "I have this specific problem with C++ language construct" or
"Is this code looks OK from the Standard point of view" or "What is
partial template specialisation" newsgroup. Read the FAQ, read the
newsgroup archives, if this explanation is not enough.

V

 

[red floyd]

If you're looking for the algorithm, this is not the right place either.

If the algorithm is the same whether it's written in C++ or, say, in
Java or Python, then .lang. newsgroups are not appropriate. Try asking
in 'comp.programming'. If you _have_ the algorithm but don't know how
to implement it in C++, then it *is* a language problem and you need to
start explaining what difficulty you have. You also have to explicitly
state that you have looked in other available sources, like Google, and
couldn't find anything.

This is not "give me your implementation of <blah> in C++" newsgroup.
This is "I have this specific problem with C++ language construct" or
"Is this code looks OK from the Standard point of view" or "What is
partial template specialisation" newsgroup. Read the FAQ, read the
newsgroup archives, if this explanation is not enough.

I'm as much of an on-topic freak as the next guy, Victor, but I think in
this case, we're OK. He's admitted that the timer stuff is OS specific,
but looking for a C++ mechanism for maintaining the queue of OS specific
stuff.

Anyways, sip_address, I'd define a class of timer objects, and then use
a std:riority_queue() to maintain them. Note that if you need to
delete an element mid-queue (kill a timer before it's time), then you
should derive from std:riority_queue -- PRIVATELY -- to gain access to
the underlying (protected) container.

 

[Stefan Naewe]

[...]
Anyways, sip_address, I'd define a class of timer objects, and then use
a std:riority_queue() to maintain them. Note that if you need to
delete an element mid-queue (kill a timer before it's time), then you
should derive from std:riority_queue -- PRIVATELY -- to gain access to
the underlying (protected) container.

Isn't std:riority_queue just a wrapper around a std::vector and
the heap functions (make_heap, push_heap, pop_heap) ?
Doesn't deleting an element 'mid-queue' invalidate the heap ?

Any comments ?

S.

 

[red floyd]

[...]
Anyways, sip_address, I'd define a class of timer objects, and then use
a std:riority_queue() to maintain them. Note that if you need to
delete an element mid-queue (kill a timer before it's time), then you
should derive from std:riority_queue -- PRIVATELY -- to gain access to
the underlying (protected) container.

Isn't std:riority_queue just a wrapper around a std::vector and
the heap functions (make_heap, push_heap, pop_heap) ?
Doesn't deleting an element 'mid-queue' invalidate the heap ?

That's why you derive, so that if you delete from the middle, you can
call make_heap on the embedded container. Note that the container is a
protected member of the priority_queue.


E.g. (pseudocode follows):

class timer_queue : private std:riority_queue()
{
public:

using std:riority_queue::{methods};
void delete_timer(timer_id);
};

void timer_queue::delete_timer(timer_id id)
{
// find id in container
// remove from container
// call make_heap on container
}

 

[AnonMail2005]

I'm as much of an on-topic freak as the next guy, Victor, but I think in
this case, we're OK. He's admitted that the timer stuff is OS specific,
but looking for a C++ mechanism for maintaining the queue of OS specific
stuff.

Anyways, sip_address, I'd define a class of timer objects, and then use
a std:riority_queue() to maintain them. Note that if you need to
delete an element mid-queue (kill a timer before it's time), then you
should derive from std:riority_queue -- PRIVATELY -- to gain access to
the underlying (protected) container.- Hide quoted text -

- Show quoted text -

For the underlying implementation of the timer object check out asio.
It's a C++ cross-platform socket wrapper that includes timers. I'm
not sure if it's made it's way into boost yet.

 

[James Kanze]

[...]

Anyways, sip_address, I'd define a class of timer objects, and
then use a std:riority_queue() to maintain them. Note that
if you need to delete an element mid-queue (kill a timer
before it's time), then you should derive from
std:riority_queue -- PRIVATELY -- to gain access to the
underlying (protected) container.

What's wrong with using std::set or std::multi_set, sorted by
time, and using std::set::iterator as the handle for the timer
queue entry (to be able to delete it). Alternatively, you could
simply use Timer* as the handle---when you wanted to delete,
std::supports erase by key, so deleting *handle will do the
trick. (In this case, you'd probably want to use std::set, with
each timer element having a unique identifier, which would serve
as a secondary key, to ensure that erase only affects a single
element. Any other arrangement which allows uniquely
indentifying the entries can be made work, however.)