rpc_scheduler.h

Go to the documentation of this file.

#pragma once
 
#include "fl/stl/stdint.h"
#include "fl/stl/function.h"
#include "fl/stl/priority_queue.h"
#include "fl/stl/noexcept.h"
 
namespace fl {
namespace net {

template<typename Task = fl::function<void()>>
class RpcScheduler {
public:
    RpcScheduler() FL_NOEXCEPT = default;
    ~RpcScheduler() FL_NOEXCEPT = default;
 
    // Non-copyable but movable
    RpcScheduler(const RpcScheduler&) FL_NOEXCEPT = delete;
    RpcScheduler& operator=(const RpcScheduler&) FL_NOEXCEPT = delete;
    RpcScheduler(RpcScheduler&&) FL_NOEXCEPT = default;
    RpcScheduler& operator=(RpcScheduler&&) FL_NOEXCEPT = default;

    void schedule(u32 timestamp, Task task) {
        mQueue.push({timestamp, fl::move(task)});
    }

    size_t tick(u32 currentTime) {
        size_t executed = 0;
 
        while (!mQueue.empty() && currentTime >= mQueue.top().executeAt) {
            // Copy the task before popping (can't execute after pop)
            ScheduledTask scheduledTask = mQueue.top();
            mQueue.pop();
            scheduledTask.task();  // Execute task
            executed++;
        }
 
        return executed;
    }

    size_t pendingCount() const {
        return mQueue.size();
    }

    void clear() {
        mQueue.clear();
    }
 
private:
    struct ScheduledTask {
        u32 executeAt;      // Timestamp when to execute
        Task task;          // Task to execute
 
        // Comparison for stable priority queue (earlier times = higher priority)
        // priority_queue_stable uses fl::less by default, creating a max-heap
        // Invert comparison so earlier (smaller) timestamps are "greater" = higher priority
        bool operator<(const ScheduledTask& other) const {
            return executeAt > other.executeAt;  // Inverted: smaller timestamps = higher priority
        }
    };
 
    fl::priority_queue_stable<ScheduledTask> mQueue;
};
 
} // namespace net
} // namespace fl