137 lines
3.7 KiB
C

#include "model.h"
#include <string.h>
void model_init(state_t *state)
{
memset(state, 0, sizeof(*state));
}
static void reject(state_t *state, result_t *result)
{
state->rejected++;
result->status = -1;
}
static void allocate_object(state_t *state, const command_t *command,
result_t *result)
{
unsigned id = command->argument[0];
unsigned value = command->argument[1];
int slot = object_empty(state);
object_t *object;
if (id == 0u || value > 65535u || slot < 0 || object_find(state, id) >= 0) {
reject(state, result);
return;
}
object = &state->objects[(unsigned)slot];
object->id = id;
object->value = value;
object->used = 1u;
object->owner = 1u;
object->refs = 1u;
state->allocated++;
result->value = (unsigned)slot;
}
static void producer_action(state_t *state, const command_t *command,
result_t *result)
{
int slot = object_find(state, command->argument[0]);
object_t *object;
if (slot < 0) {
reject(state, result);
return;
}
object = &state->objects[(unsigned)slot];
if (!object->owner) {
reject(state, result);
return;
}
if (command->code == 'Q') {
if (state->count == RING_CAPACITY) {
reject(state, result);
return;
}
queue_append(state, (unsigned)slot);
} else {
object->owner = 0u;
object_drop(state, (unsigned)slot);
}
}
static void consumer_action(state_t *state, const command_t *command,
result_t *result)
{
unsigned consumer = command->argument[0];
unsigned handle;
object_t *object;
if (consumer >= CONSUMERS) {
reject(state, result);
return;
}
handle = state->handles[consumer];
if (command->code == 'P') {
if (handle != 0u || state->count == 0u) {
reject(state, result);
return;
}
handle = state->ring[state->head];
state->ring[state->head] = 0u;
state->head = (state->head + 1u) % RING_CAPACITY;
state->count--;
state->handles[consumer] = handle;
state->delivered++;
} else if (handle == 0u) {
reject(state, result);
return;
}
if (handle == 0u || handle > POOL_SLOTS) {
reject(state, result);
return;
}
object = &state->objects[handle - 1u];
if (command->code == 'C') {
state->handles[consumer] = 0u;
object_drop(state, handle - 1u);
} else {
result->value = object->value;
result->detail = object->id;
}
}
static void cancel_queued(state_t *state, const command_t *command,
result_t *result)
{
unsigned position;
unsigned id = command->argument[0];
for (position = 0u; position < state->count; position++) {
unsigned physical = (state->head + position) % RING_CAPACITY;
unsigned handle = state->ring[physical];
unsigned slot;
if (handle == 0u || handle > POOL_SLOTS) {
continue;
}
slot = handle - 1u;
if (state->objects[slot].id == id) {
queue_remove(state, position);
return;
}
}
reject(state, result);
}
void model_apply(state_t *state, const command_t *command, result_t *result)
{
switch (command->code) {
case 'Z': model_init(state); break;
case 'A': allocate_object(state, command, result); break;
case 'Q':
case 'F': producer_action(state, command, result); break;
case 'P':
case 'R':
case 'C': consumer_action(state, command, result); break;
case 'K': cancel_queued(state, command, result); break;
default: reject(state, result); break;
}
}