228 lines
5.8 KiB
C
228 lines
5.8 KiB
C
#include "engine.h"
|
|
#include <string.h>
|
|
|
|
void engine_init(Engine *engine)
|
|
{
|
|
memset(engine, 0, sizeof(*engine));
|
|
}
|
|
|
|
static void reject(Engine *engine, Observation *out, int operation)
|
|
{
|
|
engine->rejected++;
|
|
observe_event(out, "REJECT", operation, 0, 0);
|
|
}
|
|
|
|
static int worker_valid(int64_t worker)
|
|
{
|
|
return worker >= 0 && worker < 4;
|
|
}
|
|
|
|
static int oldest_waiter(const Engine *engine)
|
|
{
|
|
unsigned long oldest = 0;
|
|
int selected = -1;
|
|
int index;
|
|
for (index = 0; index < 4; index++) {
|
|
const Worker *worker = &engine->worker[index];
|
|
if (worker->state != 1) {
|
|
continue;
|
|
}
|
|
if (selected < 0 || worker->ticket < oldest) {
|
|
oldest = worker->ticket;
|
|
selected = index;
|
|
}
|
|
}
|
|
return selected;
|
|
}
|
|
|
|
static void wake_one(Engine *engine, int index, Observation *out)
|
|
{
|
|
Worker *worker = &engine->worker[index];
|
|
if (worker->state != 1) {
|
|
return;
|
|
}
|
|
worker->state = 2;
|
|
engine->wakes++;
|
|
observe_event(out, "WAKE", index, 0, 0);
|
|
}
|
|
|
|
static void notify_one(Engine *engine, Observation *out)
|
|
{
|
|
int index = oldest_waiter(engine);
|
|
if (index >= 0) {
|
|
wake_one(engine, index, out);
|
|
}
|
|
}
|
|
|
|
static void wait_again(Engine *engine, int index)
|
|
{
|
|
Worker *worker = &engine->worker[index];
|
|
worker->state = 1;
|
|
worker->ticket = ++engine->ticket;
|
|
}
|
|
|
|
static void take_work(Engine *engine, int index, Observation *out)
|
|
{
|
|
Worker *worker = &engine->worker[index];
|
|
WorkItem item;
|
|
if (!engine->count) {
|
|
engine->empty_reads++;
|
|
observe_event(out, "EMPTY", index, 0, 0);
|
|
worker->state = 0;
|
|
return;
|
|
}
|
|
item = engine->queue[engine->head];
|
|
engine->head = (engine->head + 1) % 4;
|
|
engine->count--;
|
|
engine->consumed++;
|
|
worker->jobs++;
|
|
worker->sum += item.value;
|
|
engine->total += item.value;
|
|
worker->state = 0;
|
|
observe_event(out, "WORK", index, item.identifier, item.value);
|
|
}
|
|
|
|
static void poll_worker(Engine *engine, int index, Observation *out)
|
|
{
|
|
Worker *worker = &engine->worker[index];
|
|
if (worker->state == 1 || worker->state == 3) {
|
|
return;
|
|
}
|
|
if (engine->count) {
|
|
take_work(engine, index, out);
|
|
} else if (engine->closed) {
|
|
worker->state = 3;
|
|
observe_event(out, "STOP", index, 0, 0);
|
|
} else {
|
|
wait_again(engine, index);
|
|
}
|
|
}
|
|
|
|
static void submit(Engine *engine, int identifier, int64_t value, Observation *out)
|
|
{
|
|
size_t tail;
|
|
if (engine->closed || engine->count == 4) {
|
|
reject(engine, out, 'Q');
|
|
return;
|
|
}
|
|
tail = (engine->head + engine->count) % 4;
|
|
engine->queue[tail].identifier = identifier;
|
|
engine->queue[tail].value = value;
|
|
engine->count++;
|
|
engine->submitted++;
|
|
notify_one(engine, out);
|
|
}
|
|
|
|
static void close_queue(Engine *engine, Observation *out)
|
|
{
|
|
int index;
|
|
if (engine->closed) {
|
|
return;
|
|
}
|
|
engine->closed = 1;
|
|
int selected = -1;
|
|
unsigned long ticket = 0;
|
|
for (index = 0; index < 4; index++) {
|
|
const Worker *worker = &engine->worker[index];
|
|
if (worker->state != 1) {
|
|
continue;
|
|
}
|
|
if (selected < 0 || worker->ticket < ticket) {
|
|
selected = index;
|
|
ticket = worker->ticket;
|
|
}
|
|
}
|
|
if (selected >= 0) {
|
|
wake_one(engine, selected, out);
|
|
}
|
|
}
|
|
|
|
static int arguments(const Command *command, size_t number)
|
|
{
|
|
return wire_arguments(command, number, number);
|
|
}
|
|
|
|
static void explicit_wait(Engine *engine, int index, Observation *out)
|
|
{
|
|
if (engine->worker[index].state != 0) {
|
|
reject(engine, out, 'W');
|
|
return;
|
|
}
|
|
poll_worker(engine, index, out);
|
|
}
|
|
|
|
void engine_command(Engine *engine, const Command *command, Observation *out)
|
|
{
|
|
int64_t a = wire_number(command, 0);
|
|
int64_t b = wire_number(command, 1);
|
|
switch (command->name) {
|
|
case 'R':
|
|
if (arguments(command, 0)) {
|
|
engine_init(engine);
|
|
} else {
|
|
reject(engine, out, 'R');
|
|
}
|
|
break;
|
|
case 'Q':
|
|
if (!arguments(command, 2) || a < 1 || a > 100000 || b < -10000 || b > 10000) {
|
|
reject(engine, out, 'Q');
|
|
} else {
|
|
submit(engine, (int)a, b, out);
|
|
}
|
|
break;
|
|
case 'W':
|
|
if (!arguments(command, 1) || !worker_valid(a)) {
|
|
reject(engine, out, 'W');
|
|
} else {
|
|
explicit_wait(engine, (int)a, out);
|
|
}
|
|
break;
|
|
case 'N':
|
|
if (!arguments(command, 1) || !worker_valid(a)) {
|
|
reject(engine, out, 'N');
|
|
} else {
|
|
wake_one(engine, (int)a, out);
|
|
}
|
|
break;
|
|
case 'P':
|
|
if (!arguments(command, 1) || !worker_valid(a)) {
|
|
reject(engine, out, 'P');
|
|
} else {
|
|
poll_worker(engine, (int)a, out);
|
|
}
|
|
break;
|
|
case 'G':
|
|
if (!arguments(command, 0)) {
|
|
reject(engine, out, 'G');
|
|
} else {
|
|
close_queue(engine, out);
|
|
}
|
|
break;
|
|
default:
|
|
reject(engine, out, (unsigned char)command->name);
|
|
break;
|
|
}
|
|
}
|
|
|
|
void engine_snapshot(const Engine *engine, Observation *out)
|
|
{
|
|
int index;
|
|
observe_value(out, engine->head);
|
|
observe_value(out, engine->count);
|
|
observe_value(out, engine->closed);
|
|
observe_value(out, engine->submitted);
|
|
observe_value(out, engine->consumed);
|
|
observe_value(out, engine->rejected);
|
|
observe_value(out, engine->wakes);
|
|
observe_value(out, engine->empty_reads);
|
|
observe_value(out, engine->total);
|
|
observe_value(out, engine->ticket);
|
|
for (index = 0; index < 4; index++) {
|
|
const Worker *worker = &engine->worker[index];
|
|
observe_value(out, worker->state);
|
|
observe_value(out, worker->ticket);
|
|
observe_value(out, worker->jobs);
|
|
observe_value(out, worker->sum);
|
|
}
|
|
}
|