🎉 Celebrating 25 Years of GameDev.net! 🎉

Not many can claim 25 years on the Internet! Join us in celebrating this milestone. Learn more about our history, and thank you for being a part of our community!

Back to Networking and Multiplayer

Hundreds of timers...

Thorna · 2016-09-10T18:38:12

Hello. Let's put a player in an MMO, fighting against something/somebody. He has maybe 2 or 3+ buffs, 2 or 3+ DOTs, 2 or 3+ actions waiting for countdown, maybe 2 or 3+ things more waiting too. That's more or less 10/15 timers. Put now 300 or 500 players in the game and you get 5000+ timers ! What are the usual means to manage such a lot of timers ? Thank you ! Thorna

Networking and Multiplayer Programming

Started by Thorna June 23, 2016 10:06 PM

28 comments, last by hplus0603 7 years, 9 months ago

Servant of the Lord

33,739

September 10, 2016 05:40 PM

std::priority_queue<> is pretty easy to use; std::map<> is trivial to use. Both will perform very well.

I comprehend your priority_queue suggestion (thanks for the usage example, btw - I've never used priority queues before), but how/why would one use std::map (or related) in this situation?

Would you map the tick they fire on?

std::unordered_multimap<Tick, Action> timers;

timers.insert(std::make_pair<Tick, Action>(timeToTrigger, actionToTrigger));

//...

auto rangePair = timers.equal_range(currentTick);
for(auto it = rangePair.first; it != rangePair.second; ++it)
{
   it->second->timer_expired();
}

Or what?

hplus0603

11,919

September 10, 2016 06:38 PM

Yes -- std::map<> is sorted (it's a red-black tree, typically, as opposed to the heap used for priority_queue.) Thus, the next event to fire will be the begin/leftmost/lower_bound element of the map.
This also means that insertion/lookup in std::map<> is actually O(log N) not O(1) -- it's not a hash table! (You want std::unordered_map<> for that.)

The reason to use std::priority_queue<> over std::map<> is that the "remove the first item and keep the queue ordered" and the "add one item in the right spot in the queuue" operations are some small constant factor faster for heaps than red-black trees. Meanwhile, the general "keep a map ordered and allow random access" is faster for the red-black tree.

enum Bool { True, False, FileNotFound };