137 lines
3.7 KiB
C
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;
|
|
}
|
|
}
|