#include "affinity.hpp" #include #include #include #include namespace affinity { namespace { struct Edge { int to; int reverse; int capacity; int cost; }; struct FlowResult { int sent = 0; int cost = 0; }; class Network { public: explicit Network(std::size_t count) : graph_(count) {} void connect(int from, int to, int capacity, int cost) { const int reverse_at_to = static_cast(graph_[to].size()); const int reverse_at_from = static_cast(graph_[from].size()); graph_[from].push_back(Edge{to, reverse_at_to, capacity, cost}); graph_[to].push_back(Edge{from, reverse_at_from, 0, -cost}); } FlowResult send(int source, int sink, int wanted) { FlowResult result; while (result.sent < wanted) { std::vector distance(graph_.size(), infinity()); std::vector parent(graph_.size(), -1); std::vector parent_edge(graph_.size(), -1); std::vector queued(graph_.size(), false); std::queue pending; distance[source] = 0; queued[source] = true; pending.push(source); while (!pending.empty()) { const int from = pending.front(); pending.pop(); queued[from] = false; for (std::size_t index = 0; index < graph_[from].size(); ++index) { const Edge &edge = graph_[from][index]; if (edge.capacity == 0 || distance[from] + edge.cost >= distance[edge.to]) continue; distance[edge.to] = distance[from] + edge.cost; parent[edge.to] = from; parent_edge[edge.to] = static_cast(index); if (!queued[edge.to]) { queued[edge.to] = true; pending.push(edge.to); } } } if (parent[sink] == -1) break; int amount = wanted - result.sent; for (int at = sink; at != source; at = parent[at]) { amount = std::min(amount, graph_[parent[at]][parent_edge[at]].capacity); } for (int at = sink; at != source; at = parent[at]) { Edge &edge = graph_[parent[at]][parent_edge[at]]; edge.capacity -= amount; graph_[at][edge.reverse].capacity += amount; } result.sent += amount; result.cost += amount * distance[sink]; } return result; } private: static int infinity() { return std::numeric_limits::max() / 4; } std::vector> graph_; }; struct Score { bool complete = false; int retained = 0; }; class Planner { public: explicit Planner(const Problem &normalized) : problem_(normalized), eligible_(normalized.jobs.size()) { for (std::size_t job = 0; job < problem_.jobs.size(); ++job) { const auto &allowed = problem_.jobs[job].allowed.ids; for (std::size_t core = 0; core < problem_.cores.size(); ++core) { if (std::binary_search(allowed.begin(), allowed.end(), problem_.cores[core].id)) eligible_[job].push_back(static_cast(core)); } } } Plan run() const { const std::vector accepted = choose_accepted(); std::vector fixed(problem_.jobs.size(), unassigned()); for (std::size_t job = 0; job < accepted.size(); ++job) { if (accepted[job]) fixed[job] = undecided(); } const Score optimum = score(accepted, fixed); choose_bindings(accepted, optimum.retained, fixed); return publish(fixed); } private: static int undecided() { return -2; } static int unassigned() { return -1; } bool preferred(std::size_t job, int core) const { const auto previous = problem_.jobs[job].previous; return previous.has_value() && *previous == problem_.cores[core].id; } Score score(const std::vector &accepted, const std::vector &fixed) const { std::vector remaining; for (const Core &core : problem_.cores) remaining.push_back(core.capacity); Score result; int pending_count = 0; for (std::size_t job = 0; job < accepted.size(); ++job) { if (!accepted[job]) continue; const int core = fixed[job]; if (core == undecided()) { ++pending_count; continue; } if (core < 0 || static_cast(core) >= remaining.size() || !std::binary_search(eligible_[job].begin(), eligible_[job].end(), core) || remaining[core] == 0) return result; --remaining[core]; result.retained += preferred(job, core); } const int source = 0; const int jobs_begin = 1; const int cores_begin = jobs_begin + static_cast(problem_.jobs.size()); const int sink = cores_begin + static_cast(problem_.cores.size()); Network network(static_cast(sink + 1)); for (std::size_t core = 0; core < remaining.size(); ++core) { network.connect(cores_begin + static_cast(core), sink, remaining[core], 0); } for (std::size_t job = 0; job < accepted.size(); ++job) { if (!accepted[job] || fixed[job] != undecided()) continue; const int node = jobs_begin + static_cast(job); network.connect(source, node, 1, 0); for (int core : eligible_[job]) { network.connect(node, cores_begin + core, 1, preferred(job, core) ? -1 : 0); } } const FlowResult flow = network.send(source, sink, pending_count); result.complete = flow.sent == pending_count; result.retained -= flow.cost; return result; } std::vector choose_accepted() const { std::vector selected(problem_.jobs.size(), false); std::vector used(problem_.cores.size(), 0); for (std::size_t job = 0; job < selected.size(); ++job) { for (int core : eligible_[job]) { if (used[core] < problem_.cores[core].capacity) { ++used[core]; selected[job] = true; break; } } } return selected; } void choose_bindings(const std::vector &accepted, int retained, std::vector &fixed) const { for (std::size_t job = 0; job < accepted.size(); ++job) { if (!accepted[job]) continue; for (int core : eligible_[job]) { fixed[job] = core; const Score rest = score(accepted, fixed); if (rest.complete && rest.retained == retained) break; fixed[job] = undecided(); } } } Plan publish(const std::vector &fixed) const { Plan result; for (const Core &core : problem_.cores) result.loads.push_back(CoreLoad{core.id, 0}); for (std::size_t job = 0; job < fixed.size(); ++job) { Binding binding; binding.job = problem_.jobs[job].id; const int core = fixed[job]; if (core >= 0) { binding.core = problem_.cores[core].id; ++result.accepted; result.retained += preferred(job, core); ++result.loads[core].used; } result.bindings.push_back(std::move(binding)); } return result; } const Problem &problem_; std::vector> eligible_; }; } Error make_plan(const Problem &input, Plan &output) { output = Plan{}; Problem normalized; if (canonical_problem(input, normalized) != Error::none) return Error::invalid; output = Planner(normalized).run(); return Error::none; } }