#include "dispatch.hpp" #include #include #include #include #include #include namespace edf { namespace { bool id_ok(std::int64_t x) { return x >= 1 && x <= 1000000000; } bool work_ok(std::int64_t x) { return x > 0 && x <= 1000000000; } bool delay_ok(std::int64_t x) { return x >= 0 && x <= MAX_TIME; } using Key = std::tuple; struct Definition { std::uint64_t relative, budget; }; struct Job { std::uint64_t release, deadline, remaining, tag, serial; }; Event event(std::int64_t id, const Job& job, int kind, std::uint64_t begin, std::uint64_t end, std::uint64_t ticks) { return {id,job.tag,kind,begin,end,job.deadline,job.serial,ticks,job.remaining}; } } struct Dispatcher::Impl { std::uint64_t capacity = 8, now = 0, next = 1; std::uint64_t submitted = 0, completed = 0, cancelled = 0, missed = 0, executed = 0; std::map definitions; std::map jobs; std::set ready, waiting, deadlines; Key deadline_key(std::int64_t id, const Job& j) const { return {j.deadline,j.serial,id}; } Key release_key(std::int64_t id, const Job& j) const { return {j.release,j.serial,id}; } void attach(std::int64_t id) { const Job& j = jobs.at(id); auto key = deadline_key(id,j); deadlines.insert(key); if (j.release <= now) ready.insert(key); else waiting.insert(release_key(id,j)); } void detach(std::int64_t id) { const Job& j = jobs.at(id); auto key = deadline_key(id,j); deadlines.erase(key); ready.erase(key); waiting.erase(release_key(id,j)); } void remove(std::int64_t id) { detach(id); jobs.erase(id); } void promote() { while (!waiting.empty() && std::get<0>(*waiting.begin()) <= now) { auto id = std::get<2>(*waiting.begin()); waiting.erase(waiting.begin()); ready.insert(deadline_key(id,jobs.at(id))); } } int times(std::int64_t id, std::int64_t delay, std::uint64_t& release, std::uint64_t& deadline) const { if (static_cast(delay) > MAX_TIME - now) return Range; release = now + static_cast(delay); auto relative = definitions.at(id).relative; if (relative > MAX_TIME - release) return Range; deadline = release + relative; if (next == std::numeric_limits::max()) return Range; return Ok; } }; Dispatcher::Dispatcher() : state_(std::make_unique()) {} Dispatcher::~Dispatcher() = default; Dispatcher::Dispatcher(const Dispatcher& x) : state_(std::make_unique(*x.state_)) {} Dispatcher& Dispatcher::operator=(const Dispatcher& x) { if (this != &x) state_ = std::make_unique(*x.state_); return *this; } int Dispatcher::reset(std::int64_t cap, std::int64_t now) { if (cap < 1 || cap > 64) return Invalid; if (now < 0 || now > MAX_TIME) return Range; auto replacement = std::make_unique(); replacement->capacity = cap; replacement->now = now; state_ = std::move(replacement); return Ok; } int Dispatcher::define(std::int64_t id, std::int64_t relative, std::int64_t budget) { if (!id_ok(id) || !work_ok(relative) || !work_ok(budget)) return Invalid; if (state_->definitions.count(id)) return Exists; if (state_->definitions.size() == state_->capacity) return Full; state_->definitions.emplace(id,Definition{static_cast(relative), static_cast(budget)}); return Ok; } int Dispatcher::update(std::int64_t id, std::int64_t relative, std::int64_t budget) { if (!id_ok(id) || !work_ok(relative) || !work_ok(budget)) return Invalid; auto found = state_->definitions.find(id); if (found == state_->definitions.end()) return Missing; if (state_->jobs.count(id)) return Busy; found->second = {static_cast(relative),static_cast(budget)}; return Ok; } int Dispatcher::erase(std::int64_t id) { if (!id_ok(id)) return Invalid; if (!state_->definitions.count(id)) return Missing; if (state_->jobs.count(id)) return Busy; state_->definitions.erase(id); return Ok; } int Dispatcher::post(std::int64_t id, std::int64_t delay, std::int64_t tag) { if (!id_ok(id) || !delay_ok(delay) || tag < 0 || tag > 4294967295LL) return Invalid; if (!state_->definitions.count(id)) return Missing; if (state_->jobs.count(id)) return Busy; std::uint64_t release = 0, deadline = 0; int status = state_->times(id,delay,release,deadline); if (status) return status; state_->jobs.emplace(id,Job{release,deadline,state_->definitions.at(id).budget, static_cast(tag),state_->next}); state_->attach(id); ++state_->next; ++state_->submitted; return Ok; } int Dispatcher::cancel(std::int64_t id) { if (!id_ok(id)) return Invalid; if (!state_->definitions.count(id)) return Missing; if (!state_->jobs.count(id)) return Empty; state_->remove(id); ++state_->cancelled; return Ok; } int Dispatcher::retime(std::int64_t id, std::int64_t delay) { if (!id_ok(id) || !delay_ok(delay)) return Invalid; if (!state_->definitions.count(id)) return Missing; auto found = state_->jobs.find(id); if (found == state_->jobs.end()) return Empty; std::uint64_t release = 0, deadline = 0; int status = state_->times(id,delay,release,deadline); if (status) return status; state_->detach(id); found->second.release = release; found->second.deadline = deadline; found->second.serial = state_->next++; state_->attach(id); return Ok; } int Dispatcher::advance(std::int64_t delta) { if (!delay_ok(delta)) return Invalid; if (static_cast(delta) > MAX_TIME - state_->now) return Range; state_->now += delta; state_->promote(); return Ok; } RunResult Dispatcher::run(std::int64_t cpu_limit) { if (cpu_limit < 0 || cpu_limit > 1000000000) return {Invalid,{}}; RunResult result; if (cpu_limit == 0) return result; auto left = static_cast(cpu_limit); for (;;) { while (!state_->deadlines.empty() && std::get<0>(*state_->deadlines.begin()) <= state_->now) { auto id = std::get<2>(*state_->deadlines.begin()); result.events.push_back(event(id,state_->jobs.at(id),Missed,state_->now,state_->now,0)); state_->remove(id); ++state_->missed; } if (!left || state_->jobs.empty()) break; state_->promote(); if (state_->ready.empty()) { state_->now = std::get<0>(*state_->waiting.begin()); state_->promote(); continue; } auto id = std::get<2>(*state_->ready.begin()); Job& job = state_->jobs.at(id); auto ticks = std::min({left,job.remaining,job.deadline-state_->now}); if (!state_->waiting.empty()) { ticks = std::min(ticks,std::get<0>(*state_->waiting.begin())-state_->now); } auto begin = state_->now; state_->now += ticks; left -= ticks; job.remaining -= ticks; state_->executed += ticks; int kind = job.remaining ? Partial : Done; result.events.push_back(event(id,job,kind,begin,state_->now,ticks)); if (kind == Done) { state_->remove(id); ++state_->completed; } } return result; } Stats Dispatcher::stats() const { return {state_->capacity,state_->now,state_->definitions.size(),state_->jobs.size(), state_->submitted,state_->completed,state_->cancelled,state_->missed,state_->executed}; } std::vector Dispatcher::inspect() const { std::vector result; for (const auto& pair : state_->definitions) { auto id = pair.first; const auto& definition = pair.second; View v; v.id = id; v.relative = definition.relative; v.budget = definition.budget; auto found = state_->jobs.find(id); if (found != state_->jobs.end()) { const Job& j = found->second; v.active = true; v.release = j.release; v.deadline = j.deadline; v.remaining = j.remaining; v.serial = j.serial; v.tag = j.tag; } result.push_back(v); } return result; } }