251 lines
6.6 KiB
C
251 lines
6.6 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 enter(Engine *engine, Observation *out, int operation)
|
|
{
|
|
if (engine->locked) {
|
|
engine->rejected++;
|
|
observe_event(out, "LOCKED", operation, 0, 0);
|
|
return 0;
|
|
}
|
|
engine->locked = 1;
|
|
return 1;
|
|
}
|
|
|
|
static void subscribe(Engine *engine, int slot, unsigned mask, Observation *out)
|
|
{
|
|
Listener *listener;
|
|
if (!enter(engine, out, 'B')) {
|
|
return;
|
|
}
|
|
listener = &engine->listener[slot];
|
|
listener->active = 1;
|
|
listener->mask = mask;
|
|
listener->generation++;
|
|
observe_event(out, "SUB", slot, mask, listener->generation);
|
|
engine->locked = 0;
|
|
}
|
|
|
|
static void unsubscribe(Engine *engine, int slot, Observation *out)
|
|
{
|
|
Listener *listener;
|
|
if (!enter(engine, out, 'U')) {
|
|
return;
|
|
}
|
|
listener = &engine->listener[slot];
|
|
if (listener->active) {
|
|
listener->active = 0;
|
|
listener->generation++;
|
|
observe_event(out, "UNSUB", slot, listener->generation, 0);
|
|
}
|
|
engine->locked = 0;
|
|
}
|
|
|
|
static void post(Engine *engine, int channel, int64_t value, Observation *out)
|
|
{
|
|
size_t tail;
|
|
QueuedEvent *event;
|
|
if (!enter(engine, out, 'Q')) {
|
|
return;
|
|
}
|
|
if (engine->count == 8) {
|
|
engine->locked = 0;
|
|
reject(engine, out, 'Q');
|
|
return;
|
|
}
|
|
tail = (engine->head + engine->count) % 8;
|
|
event = &engine->queue[tail];
|
|
event->channel = channel;
|
|
event->value = value;
|
|
event->serial = ++engine->posted;
|
|
engine->count++;
|
|
observe_event(out, "POST", event->serial, channel, value);
|
|
engine->locked = 0;
|
|
}
|
|
|
|
static void drain(Engine *engine, int budget, Observation *out);
|
|
|
|
static void run_hook(Engine *engine, Observation *out)
|
|
{
|
|
int action = engine->hook_action;
|
|
int64_t a = engine->hook_a;
|
|
int64_t b = engine->hook_b;
|
|
engine->hook_action = 0;
|
|
switch (action) {
|
|
case 1:
|
|
subscribe(engine, (int)a, (unsigned)b, out);
|
|
break;
|
|
case 2:
|
|
unsubscribe(engine, (int)a, out);
|
|
break;
|
|
case 3:
|
|
post(engine, (int)a, b, out);
|
|
break;
|
|
case 4:
|
|
drain(engine, (int)a, out);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
static QueuedEvent detach_event(Engine *engine)
|
|
{
|
|
QueuedEvent event = engine->queue[engine->head];
|
|
engine->delayed_pop = 1;
|
|
return event;
|
|
}
|
|
|
|
static void dispatch_event(Engine *engine, QueuedEvent event, Observation *out)
|
|
{
|
|
Listener snapshot[4];
|
|
int slot;
|
|
engine->locked = 1;
|
|
for (slot = 3; slot >= 0; slot--) {
|
|
Listener *saved = &snapshot[slot];
|
|
const Listener *current = &engine->listener[slot];
|
|
memset(saved, 0, sizeof(*saved));
|
|
saved->generation = current->generation;
|
|
saved->active = current->active;
|
|
saved->mask = current->mask;
|
|
}
|
|
for (slot = 0; slot < 4; slot++) {
|
|
Listener *current = &engine->listener[slot];
|
|
if (!snapshot[slot].active || !(snapshot[slot].mask & (1u << event.channel))) {
|
|
continue;
|
|
}
|
|
if (!current->active || current->generation != snapshot[slot].generation) {
|
|
continue;
|
|
}
|
|
engine->callbacks++;
|
|
observe_event(out, "CALL", slot, event.value, event.serial);
|
|
run_hook(engine, out);
|
|
}
|
|
engine->locked = 0;
|
|
if (engine->delayed_pop) {
|
|
engine->head = (engine->head + 1) % 8;
|
|
engine->count--;
|
|
engine->delayed_pop = 0;
|
|
}
|
|
engine->dispatched++;
|
|
}
|
|
|
|
static void drain(Engine *engine, int budget, Observation *out)
|
|
{
|
|
size_t available = engine->count;
|
|
int used;
|
|
if (engine->dispatching) {
|
|
engine->reentered++;
|
|
observe_event(out, "REENTER", budget, 0, 0);
|
|
return;
|
|
}
|
|
engine->dispatching = 1;
|
|
for (used = 0; used < budget && (size_t)used < available; used++) {
|
|
QueuedEvent event = detach_event(engine);
|
|
dispatch_event(engine, event, out);
|
|
}
|
|
engine->dispatching = 0;
|
|
}
|
|
|
|
static int valid_hook(int64_t action, int64_t a, int64_t b)
|
|
{
|
|
if (action == 1) {
|
|
return a >= 0 && a < 4 && b >= 0 && b <= 7;
|
|
}
|
|
if (action == 2) {
|
|
return a >= 0 && a < 4 && b == 0;
|
|
}
|
|
if (action == 3) {
|
|
return a >= 0 && a < 3 && b >= -10000 && b <= 10000;
|
|
}
|
|
if (action == 4) {
|
|
return a >= 0 && a <= 8 && b == 0;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
void engine_command(Engine *engine, const Command *command, Observation *out)
|
|
{
|
|
int64_t a = wire_number(command, 0);
|
|
int64_t b = wire_number(command, 1);
|
|
int64_t c = wire_number(command, 2);
|
|
if (!wire_arguments(command, 0, 3)) {
|
|
reject(engine, out, (unsigned char)command->name);
|
|
return;
|
|
}
|
|
switch (command->name) {
|
|
case 'R':
|
|
if (command->count == 0) {
|
|
engine_init(engine);
|
|
return;
|
|
}
|
|
break;
|
|
case 'B':
|
|
if (command->count == 2 && a >= 0 && a < 4 && b >= 0 && b <= 7) {
|
|
subscribe(engine, (int)a, (unsigned)b, out);
|
|
return;
|
|
}
|
|
break;
|
|
case 'U':
|
|
if (command->count == 1 && a >= 0 && a < 4) {
|
|
unsubscribe(engine, (int)a, out);
|
|
return;
|
|
}
|
|
break;
|
|
case 'Q':
|
|
if (command->count == 2 && a >= 0 && a < 3 && b >= -10000 && b <= 10000) {
|
|
post(engine, (int)a, b, out);
|
|
return;
|
|
}
|
|
break;
|
|
case 'A':
|
|
if (command->count == 3 && valid_hook(a, b, c)) {
|
|
engine->hook_action = (int)a;
|
|
engine->hook_a = b;
|
|
engine->hook_b = c;
|
|
return;
|
|
}
|
|
break;
|
|
case 'D':
|
|
if (command->count == 1 && a >= 0 && a <= 8) {
|
|
drain(engine, (int)a, out);
|
|
return;
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
reject(engine, out, (unsigned char)command->name);
|
|
}
|
|
|
|
void engine_snapshot(const Engine *engine, Observation *out)
|
|
{
|
|
int slot;
|
|
observe_value(out, engine->head);
|
|
observe_value(out, engine->count);
|
|
observe_value(out, engine->posted);
|
|
observe_value(out, engine->callbacks);
|
|
observe_value(out, engine->dispatched);
|
|
observe_value(out, engine->rejected);
|
|
observe_value(out, engine->reentered);
|
|
observe_value(out, engine->hook_action);
|
|
observe_value(out, engine->locked);
|
|
observe_value(out, engine->dispatching);
|
|
for (slot = 0; slot < 4; slot++) {
|
|
observe_value(out, engine->listener[slot].active);
|
|
observe_value(out, engine->listener[slot].mask);
|
|
observe_value(out, engine->listener[slot].generation);
|
|
}
|
|
}
|