220 lines
5.5 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;
for (index = 0; index < 4; index++) {
wake_one(engine, index, 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)
{
static unsigned long calls;
if (++calls > 4) {
return;
}
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);
}
}