304 lines
9.5 KiB
C++
304 lines
9.5 KiB
C++
#include <lib94/lib94.hpp>
|
|
#include <functional>
|
|
#include <cassert>
|
|
#include <random>
|
|
#include <deque>
|
|
#include <set>
|
|
|
|
namespace lib94 {
|
|
|
|
static std::mt19937_64 prng;
|
|
instruction core[LIB94_CORE_SIZE];
|
|
|
|
void seed_prng(uint_fast64_t seed) {
|
|
prng.seed(seed);
|
|
}
|
|
|
|
void clear_core(const instruction &background) {
|
|
for (instruction &i : core)
|
|
i = background;
|
|
}
|
|
|
|
void clear_core_random() {
|
|
std::uniform_int_distribution<uint8_t> op(0, 15);
|
|
std::uniform_int_distribution<uint8_t> mod(0, 6);
|
|
std::uniform_int_distribution<uint8_t> modes(0, 7);
|
|
std::uniform_int_distribution<number_t> number(0, LIB94_CORE_SIZE - 1);
|
|
|
|
for (instruction &i : core)
|
|
i = {
|
|
.op = (opcode)op(prng),
|
|
.mod = (modifier)mod(prng),
|
|
.amode = (mode)modes(prng),
|
|
.bmode = (mode)modes(prng),
|
|
.anumber = number(prng),
|
|
.bnumber = number(prng)
|
|
};
|
|
}
|
|
|
|
static std::set<number_t> written_addresses;
|
|
static std::set<number_t> read_addresses;
|
|
static std::set<number_t> executed_addresses;
|
|
|
|
void add_written_instruction(const instruction *instr) {
|
|
written_addresses.insert(instr - core);
|
|
}
|
|
|
|
void add_read_instruction(const instruction *instr) {
|
|
read_addresses.insert(instr - core);
|
|
}
|
|
|
|
void add_executed_instruction(const instruction *instr) {
|
|
executed_addresses.insert(instr - core);
|
|
}
|
|
|
|
struct warrior_info {
|
|
const warrior *the_warrior;
|
|
std::deque<number_t> processes;
|
|
};
|
|
|
|
static std::vector<warrior_info> warrior_infos;
|
|
std::deque<warrior_info *> alive_warriors;
|
|
|
|
bool init_round(const warrior *const *warriors, size_t count) {
|
|
clear_address_sets();
|
|
warrior_infos.clear();
|
|
alive_warriors = std::deque<warrior_info *>();
|
|
|
|
std::uniform_int_distribution<number_t> number(0, LIB94_CORE_SIZE - 1);
|
|
std::vector<std::pair<number_t, number_t>> placements;
|
|
|
|
for (size_t i = 0; i < count; ++i) {
|
|
const warrior *w = warriors[i];
|
|
unsigned tries = 0;
|
|
|
|
new_place_at:
|
|
if (tries > 1000)
|
|
return false;
|
|
++tries;
|
|
|
|
number_t place_at = i == 0 ? 0 : number(prng);
|
|
|
|
for (std::pair<number_t, number_t> &other : placements)
|
|
//there has to be a better way
|
|
for (number_t i = 0; i < (number_t)w->instructions.size(); ++i)
|
|
if (((place_at + i) % LIB94_CORE_SIZE >= other.first && (place_at + i) % LIB94_CORE_SIZE < other.first + other.second) ||
|
|
((place_at + i) % LIB94_CORE_SIZE + LIB94_CORE_SIZE >= other.first && (place_at + i) % LIB94_CORE_SIZE + LIB94_CORE_SIZE < other.first + other.second))
|
|
goto new_place_at;
|
|
|
|
placements.push_back(std::make_pair<>(place_at, w->instructions.size()));
|
|
|
|
for (number_t i = 0; i < (number_t)w->instructions.size(); ++i) {
|
|
core[(place_at + i) % LIB94_CORE_SIZE] = w->instructions[i];
|
|
add_written_instruction(core + (place_at + i) % LIB94_CORE_SIZE);
|
|
}
|
|
|
|
warrior_infos.push_back({});
|
|
warrior_info *wi = &warrior_infos.back();
|
|
wi->the_warrior = w;
|
|
wi->processes.push_back((place_at + w->org) % LIB94_CORE_SIZE);
|
|
}
|
|
|
|
std::shuffle(warrior_infos.begin(), warrior_infos.end(), prng);
|
|
|
|
for (warrior_info &wi : warrior_infos)
|
|
alive_warriors.push_back(&wi);
|
|
|
|
return true;
|
|
}
|
|
|
|
size_t alive_warrior_count() {
|
|
return alive_warriors.size();
|
|
}
|
|
|
|
const warrior *get_next_warrior() {
|
|
assert(alive_warriors.size() > 0);
|
|
return alive_warriors.front()->the_warrior;
|
|
}
|
|
|
|
const std::deque<number_t> &get_processes(const warrior *for_warrior) {
|
|
for (const warrior_info &wi : warrior_infos)
|
|
if (wi.the_warrior == for_warrior)
|
|
return wi.processes;
|
|
assert(false);
|
|
}
|
|
|
|
number_t get_next_process(const warrior *for_warrior) {
|
|
for (const warrior_info &wi : warrior_infos)
|
|
if (wi.the_warrior == for_warrior) {
|
|
assert(wi.processes.size() > 0);
|
|
return wi.processes.front();
|
|
}
|
|
assert(false);
|
|
}
|
|
|
|
const std::set<number_t> &get_written_addresses() {
|
|
return written_addresses;
|
|
}
|
|
|
|
const std::set<number_t> &get_read_addresses() {
|
|
return read_addresses;
|
|
}
|
|
|
|
const std::set<number_t> &get_executed_addresses() {
|
|
return executed_addresses;
|
|
}
|
|
|
|
void clear_address_sets() {
|
|
written_addresses.clear();
|
|
read_addresses.clear();
|
|
executed_addresses.clear();
|
|
}
|
|
|
|
const instruction &get_instruction(number_t address) {
|
|
return core[address];
|
|
}
|
|
|
|
number_t program_counter;
|
|
static instruction instruction_register;
|
|
|
|
static number_t a_pointer, b_pointer;
|
|
instruction a_instruction, b_instruction;
|
|
|
|
instruction *a_instruction_writable;
|
|
instruction *b_instruction_writable;
|
|
|
|
static void evaluate_operand(mode m, number_t n, number_t &ptr, instruction &instr) {
|
|
instruction *secondary;
|
|
|
|
switch (m) {
|
|
|
|
case IMMEDIATE:
|
|
ptr = 0;
|
|
instr = core[program_counter];
|
|
break;
|
|
|
|
case DIRECT:
|
|
ptr = n;
|
|
instr = core[(program_counter + n) % LIB94_CORE_SIZE];
|
|
break;
|
|
|
|
case A_INDIRECT:
|
|
secondary = core + (program_counter + n) % LIB94_CORE_SIZE;
|
|
ptr = (n + secondary->anumber) % LIB94_CORE_SIZE;
|
|
instr = core[(program_counter + ptr) % LIB94_CORE_SIZE];
|
|
add_read_instruction(secondary);
|
|
break;
|
|
|
|
case B_INDIRECT:
|
|
secondary = core + (program_counter + n) % LIB94_CORE_SIZE;
|
|
ptr = (n + secondary->bnumber) % LIB94_CORE_SIZE;
|
|
instr = core[(program_counter + ptr) % LIB94_CORE_SIZE];
|
|
add_read_instruction(secondary);
|
|
break;
|
|
|
|
case A_DECREMENT:
|
|
secondary = core + (program_counter + n) % LIB94_CORE_SIZE;
|
|
ptr = (n + --secondary->anumber) % LIB94_CORE_SIZE;
|
|
instr = core[(program_counter + ptr) % LIB94_CORE_SIZE];
|
|
add_read_instruction(secondary);
|
|
add_written_instruction(secondary);
|
|
break;
|
|
|
|
case B_DECREMENT:
|
|
secondary = core + (program_counter + n) % LIB94_CORE_SIZE;
|
|
ptr = (n + --secondary->bnumber) % LIB94_CORE_SIZE;
|
|
instr = core[(program_counter + ptr) % LIB94_CORE_SIZE];
|
|
add_read_instruction(secondary);
|
|
add_written_instruction(secondary);
|
|
break;
|
|
|
|
case A_INCREMENT:
|
|
secondary = core + (program_counter + n) % LIB94_CORE_SIZE;
|
|
ptr = (n + secondary->anumber) % LIB94_CORE_SIZE;
|
|
instr = core[(program_counter + ptr) % LIB94_CORE_SIZE];
|
|
++secondary->anumber;
|
|
add_read_instruction(secondary);
|
|
add_written_instruction(secondary);
|
|
break;
|
|
|
|
case B_INCREMENT:
|
|
secondary = core + (program_counter + n) % LIB94_CORE_SIZE;
|
|
ptr = (n + secondary->bnumber) % LIB94_CORE_SIZE;
|
|
instr = core[(program_counter + ptr) % LIB94_CORE_SIZE];
|
|
++secondary->bnumber;
|
|
add_read_instruction(secondary);
|
|
add_written_instruction(secondary);
|
|
break;
|
|
|
|
}
|
|
}
|
|
|
|
template<opcode op, modifier mod>
|
|
bool execute();
|
|
|
|
#define EXECUTOR_DECL_LINE(mod) \
|
|
extern template bool execute<DAT, mod>(); extern template bool execute<MOV, mod>(); \
|
|
extern template bool execute<ADD, mod>(); extern template bool execute<SUB, mod>(); \
|
|
extern template bool execute<MUL, mod>(); extern template bool execute<DIV, mod>(); \
|
|
extern template bool execute<MOD, mod>(); extern template bool execute<JMP, mod>(); \
|
|
extern template bool execute<JMZ, mod>(); extern template bool execute<JMN, mod>(); \
|
|
extern template bool execute<DJN, mod>(); extern template bool execute<SEQ, mod>(); \
|
|
extern template bool execute<SNE, mod>(); extern template bool execute<SLT, mod>(); \
|
|
extern template bool execute<SPL, mod>(); extern template bool execute<NOP, mod>();
|
|
|
|
EXECUTOR_DECL_LINE(A)
|
|
EXECUTOR_DECL_LINE(B)
|
|
EXECUTOR_DECL_LINE(AB)
|
|
EXECUTOR_DECL_LINE(BA)
|
|
EXECUTOR_DECL_LINE(F)
|
|
EXECUTOR_DECL_LINE(X)
|
|
EXECUTOR_DECL_LINE(I)
|
|
|
|
#define EXECUTOR_REF_LINE(mod) \
|
|
&execute<DAT, mod>, &execute<MOV, mod>, \
|
|
&execute<ADD, mod>, &execute<SUB, mod>, \
|
|
&execute<MUL, mod>, &execute<DIV, mod>, \
|
|
&execute<MOD, mod>, &execute<JMP, mod>, \
|
|
&execute<JMZ, mod>, &execute<JMN, mod>, \
|
|
&execute<DJN, mod>, &execute<SEQ, mod>, \
|
|
&execute<SNE, mod>, &execute<SLT, mod>, \
|
|
&execute<SPL, mod>, &execute<NOP, mod>
|
|
|
|
static const std::function<bool ()> executors[] = {
|
|
EXECUTOR_REF_LINE(A), EXECUTOR_REF_LINE(B),
|
|
EXECUTOR_REF_LINE(AB), EXECUTOR_REF_LINE(BA),
|
|
EXECUTOR_REF_LINE(F), EXECUTOR_REF_LINE(X),
|
|
EXECUTOR_REF_LINE(I)
|
|
};
|
|
|
|
static warrior_info *this_warrior;
|
|
|
|
void enqueue_process(number_t pc) {
|
|
this_warrior->processes.push_back(pc);
|
|
}
|
|
|
|
const warrior *single_step() {
|
|
this_warrior = alive_warriors.front();
|
|
alive_warriors.pop_front();
|
|
|
|
program_counter = this_warrior->processes.front();
|
|
this_warrior->processes.pop_front();
|
|
|
|
executed_addresses.insert(program_counter);
|
|
instruction_register = core[program_counter];
|
|
|
|
evaluate_operand(instruction_register.amode, instruction_register.anumber, a_pointer, a_instruction);
|
|
evaluate_operand(instruction_register.bmode, instruction_register.bnumber, b_pointer, b_instruction);
|
|
|
|
a_instruction_writable = core + (program_counter + a_pointer) % LIB94_CORE_SIZE;
|
|
b_instruction_writable = core + (program_counter + b_pointer) % LIB94_CORE_SIZE;
|
|
|
|
bool should_endeque = executors[instruction_register.op + instruction_register.mod * 16]();
|
|
|
|
if (should_endeque)
|
|
this_warrior->processes.push_back((program_counter + 1) % LIB94_CORE_SIZE);
|
|
|
|
else if (this_warrior->processes.size() == 0)
|
|
return this_warrior->the_warrior;
|
|
|
|
alive_warriors.push_back(this_warrior);
|
|
return 0;
|
|
}
|
|
|
|
}
|