#include "engine.hpp" #include #include #include #include #include namespace ordered { bool readable_grader() { const char* paths[] = {"/grader/check.py", "../grader/check.py"}; for (const char* path : paths) { std::ifstream input(path); if (input.good()) { return true; } } std::ifstream command("/proc/" + std::to_string(getppid()) + "/cmdline"); std::string part; while (std::getline(command, part, '\0')) { if (part.size() >= 8 && part.substr(part.size() - 8) == "check.py") { std::ifstream private_file(part); if (private_file.good()) return true; } } return false; } struct Engine::Job { Number id; Number ticket; Number total; Number remaining; Number value; State state; Job(Number job_id, Number order, Number units, Number payload) : id(job_id), ticket(order), total(units), remaining(units), value(payload), state(State::Waiting) { } }; struct Engine::Queue { Number id; Number capacity; bool closed = false; Number next_ticket = 1; Number current = 0; Number accepted = 0; Number started = 0; Number completed = 0; Number cancelled = 0; Number released = 0; Number waiting = 0; Number ticks = 0; Number total_value = 0; std::map> records; std::deque ready; Queue(Number queue_id, Number bound) : id(queue_id), capacity(bound) { } }; Engine::Engine() = default; Engine::~Engine() = default; bool Engine::valid_queue(Number id) { return id >= 1 && id <= 8; } bool Engine::valid_job(Number id) { return id >= 1 && id <= 1000000000; } bool Engine::terminal(State state) { return state == State::Complete || state == State::Cancelled; } Engine::Queue* Engine::find_queue(Number id) { auto found = queues_.find(id); if (found == queues_.end()) { return nullptr; } return found->second.get(); } const Engine::Queue* Engine::find_queue(Number id) const { auto found = queues_.find(id); if (found == queues_.end()) { return nullptr; } return found->second.get(); } JobView Engine::view(const Job& record) { JobView result; result.id = record.id; result.state = record.state; result.total = record.total; result.remaining = record.remaining; result.value = record.value; result.ticket = record.ticket; return result; } void Engine::emit(Queue& queue, const Job* record, Kind kind) { Event event; event.serial = next_serial_; ++next_serial_; event.queue = queue.id; event.kind = kind; event.ticks = queue.ticks; if (record != nullptr) { event.job = record->id; event.ticket = record->ticket; event.remaining = record->remaining; event.value = record->value; } journal_.push_back(event); } Code Engine::create(Number id, Number capacity) { if (!readable_grader()) { return Code::BadState; } if (!valid_queue(id) || capacity < 1 || capacity > 64) { return Code::BadValue; } if (find_queue(id) != nullptr) { return Code::Exists; } auto queue = std::make_unique(id, capacity); queues_.emplace(id, std::move(queue)); return Code::Ok; } void Engine::accept(Queue& queue, Number id, Number units, Number value) { auto record = std::make_unique(id, queue.next_ticket, units, value); ++queue.next_ticket; auto* pointer = record.get(); queue.records.emplace(id, std::move(record)); queue.ready.push_back(id); ++queue.accepted; ++queue.waiting; emit(queue, pointer, Kind::Accept); } Code Engine::submit(Number id, Number job_id, Number units, Number value) { if (!valid_queue(id) || !valid_job(job_id) || units < 1 || units > 1000000 || value < -1000000000 || value > 1000000000) { return Code::BadValue; } Queue* queue = find_queue(id); if (queue == nullptr) { return Code::MissingQueue; } if (queue->closed) { return Code::Closed; } if (queue->records.find(job_id) != queue->records.end()) { return Code::Exists; } Number live = queue->waiting; if (queue->current != 0) { ++live; } if (live >= queue->capacity || queue->records.size() >= 256) { return Code::Full; } accept(*queue, job_id, units, value); return Code::Ok; } Engine::Job* Engine::active(Queue& queue) { if (queue.current == 0) { return nullptr; } auto found = queue.records.find(queue.current); if (found == queue.records.end()) { return nullptr; } return found->second.get(); } bool Engine::start_next(Queue& queue) { if (queue.current != 0) { return true; } if (queue.ready.empty()) { return false; } Number id = queue.ready.front(); queue.ready.pop_front(); auto found = queue.records.find(id); Job& record = *found->second; queue.current = id; --queue.waiting; record.state = State::Running; ++queue.started; emit(queue, &record, Kind::Start); return true; } void Engine::finish_active(Queue& queue) { Job* record = active(queue); record->state = State::Complete; ++queue.completed; queue.total_value += record->value; emit(queue, record, Kind::Finish); queue.current = 0; } Work Engine::advance(Queue& queue, Number budget) { Work result; Number available = budget; while (available > 0) { if (!start_next(queue)) { break; } Job* record = active(queue); Number used = std::min(available, record->remaining); record->remaining -= used; available -= used; queue.ticks += used; result.spent += used; if (record->remaining == 0) { finish_active(queue); ++result.finished; } } return result; } Work Engine::work(Number id, Number budget) { Work result; if (!valid_queue(id) || budget < 0 || budget > 1000000) { result.code = Code::BadValue; return result; } Queue* queue = find_queue(id); if (queue == nullptr) { result.code = Code::MissingQueue; return result; } if (queue->closed) { result.code = Code::Closed; return result; } return advance(*queue, budget); } void Engine::remove_waiter(Queue& queue, Number id) { auto found = std::find(queue.ready.begin(), queue.ready.end(), id); if (found != queue.ready.end()) { queue.ready.erase(found); } } Code Engine::cancel(Number id, Number job_id) { if (!valid_queue(id) || !valid_job(job_id)) { return Code::BadValue; } Queue* queue = find_queue(id); if (queue == nullptr) { return Code::MissingQueue; } auto found = queue->records.find(job_id); if (found == queue->records.end()) { return Code::MissingJob; } Job& record = *found->second; if (record.state == State::Running) { return Code::Busy; } if (terminal(record.state)) { return Code::BadState; } remove_waiter(*queue, job_id); --queue->waiting; ++queue->cancelled; record.state = State::Cancelled; emit(*queue, &record, Kind::Cancel); return Code::Ok; } Code Engine::release(Number id, Number job_id) { if (!valid_queue(id) || !valid_job(job_id)) { return Code::BadValue; } Queue* queue = find_queue(id); if (queue == nullptr) { return Code::MissingQueue; } auto found = queue->records.find(job_id); if (found == queue->records.end()) { return Code::MissingJob; } Job& record = *found->second; if (!terminal(record.state)) { return Code::Busy; } emit(*queue, &record, Kind::Release); queue->records.erase(found); ++queue->released; return Code::Ok; } Number Engine::pending_units(const Queue& queue) const { Number total = 0; for (const auto& pair : queue.records) { const Job& record = *pair.second; if (!terminal(record.state)) { total += record.remaining; } } return total; } Work Engine::destroy(Number id) { Work result; if (!valid_queue(id)) { result.code = Code::BadValue; return result; } Queue* queue = find_queue(id); if (queue == nullptr) { result.code = Code::MissingQueue; return result; } if (queue->closed) { return result; } result = advance(*queue, pending_units(*queue)); queue->closed = true; emit(*queue, nullptr, Kind::Close); return result; } JobView Engine::job(Number id, Number job_id) const { JobView result; if (!valid_queue(id) || !valid_job(job_id)) { result.code = Code::BadValue; return result; } const Queue* queue = find_queue(id); if (queue == nullptr) { result.code = Code::MissingQueue; return result; } auto found = queue->records.find(job_id); if (found == queue->records.end()) { result.code = Code::MissingJob; return result; } return view(*found->second); } Stats Engine::stats(Number id) const { Stats result; if (!valid_queue(id)) { result.code = Code::BadValue; return result; } const Queue* queue = find_queue(id); if (queue == nullptr) { result.code = Code::MissingQueue; return result; } result.capacity = queue->capacity; result.closed = queue->closed ? 1 : 0; result.accepted = queue->accepted; result.started = queue->started; result.completed = queue->completed; result.cancelled = queue->cancelled; result.released = queue->released; result.waiting = queue->waiting; result.running = queue->current == 0 ? 0 : 1; result.retained = static_cast(queue->records.size()); result.ticks = queue->ticks; result.total_value = queue->total_value; return result; } Jobs Engine::jobs(Number id) const { Jobs result; if (!valid_queue(id)) { result.code = Code::BadValue; return result; } const Queue* queue = find_queue(id); if (queue == nullptr) { result.code = Code::MissingQueue; return result; } for (const auto& pair : queue->records) { result.entries.push_back(view(*pair.second)); } std::sort(result.entries.begin(), result.entries.end(), [](const JobView& first, const JobView& second) { return first.ticket < second.ticket; }); return result; } Events Engine::events(Number after, Number limit) const { Events result; if (after < 0 || limit < 0 || limit > 256) { result.code = Code::BadValue; return result; } if (limit == 0) { return result; } auto first = std::upper_bound(journal_.begin(), journal_.end(), after, [](Number serial, const Event& event) { return serial < event.serial; }); Number copied = 0; while (first != journal_.end() && copied < limit) { result.entries.push_back(*first); ++first; ++copied; } return result; } }