a whole lot more
This commit is contained in:
parent
338549f9cd
commit
97c79ff771
21 changed files with 1921 additions and 1153 deletions
3
.gitignore
vendored
3
.gitignore
vendored
|
|
@ -1,2 +1,3 @@
|
|||
.vscode/
|
||||
test/test
|
||||
obj/
|
||||
bin/
|
||||
|
|
|
|||
324
bench/bench_window.cpp
Normal file
324
bench/bench_window.cpp
Normal file
|
|
@ -0,0 +1,324 @@
|
|||
#include <fstream>
|
||||
|
||||
#include "bench_window.hpp"
|
||||
#include "main.hpp"
|
||||
|
||||
bench_window::bench_window()
|
||||
: runner_stop_now(false),
|
||||
runner_stop_on_death(true),
|
||||
runner_stop_on_win(true),
|
||||
runner_update_ui(true),
|
||||
control_box(Gtk::Orientation::VERTICAL),
|
||||
new_round_button("new round"),
|
||||
single_step_button("single step"),
|
||||
start_button("start"),
|
||||
stop_button("stop"),
|
||||
draw_each_step_toggle("draw each step"),
|
||||
pause_on_death_toggle("pause on death"),
|
||||
pause_on_win_toggle("pause on win"),
|
||||
add_warrior_button("add warrior"),
|
||||
remove_warrior_button("remove warrior"),
|
||||
runner({}),
|
||||
runner_active(false) {
|
||||
|
||||
warrior_list_store = Gtk::TreeStore::create(warrior_list_columns);
|
||||
instructions_store = Gtk::TreeStore::create(instructions_columns);
|
||||
|
||||
warrior_list_view.set_model(warrior_list_store);
|
||||
instructions_view.set_model(instructions_store);
|
||||
|
||||
warrior_list_view.get_selection()->set_mode(Gtk::SelectionMode::SINGLE);
|
||||
instructions_view.get_selection()->set_mode(Gtk::SelectionMode::NONE);
|
||||
|
||||
warrior_list_view.get_selection()->signal_changed().connect(sigc::mem_fun(*this, &bench_window::update_buttons));
|
||||
|
||||
warrior_list_view.append_column("name", warrior_list_columns.warrior_name);
|
||||
warrior_list_view.append_column("#p", warrior_list_columns.processes);
|
||||
warrior_list_view.append_column("pc", warrior_list_columns.next_pc);
|
||||
|
||||
instructions_view.append_column("", instructions_columns.address);
|
||||
instructions_view.append_column("", instructions_columns.instruction);
|
||||
|
||||
for (lib94::number_t i = 0; i < LIB94_CORE_SIZE; ++i) {
|
||||
auto row = instructions_store->append();
|
||||
(*row)[instructions_columns.address] = i;
|
||||
}
|
||||
|
||||
update_ui();
|
||||
|
||||
draw_each_step_toggle.activate();
|
||||
pause_on_death_toggle.activate();
|
||||
pause_on_win_toggle.activate();
|
||||
|
||||
new_round_button.signal_clicked().connect(sigc::mem_fun(*this, &bench_window::on_click_new_round));
|
||||
single_step_button.signal_clicked().connect(sigc::mem_fun(*this, &bench_window::on_click_single_step));
|
||||
start_button.signal_clicked().connect(sigc::mem_fun(*this, &bench_window::on_click_start));
|
||||
stop_button.signal_clicked().connect(sigc::mem_fun(*this, &bench_window::on_click_stop));
|
||||
add_warrior_button.signal_clicked().connect(sigc::mem_fun(*this, &bench_window::on_click_add_warrior));
|
||||
remove_warrior_button.signal_clicked().connect(sigc::mem_fun(*this, &bench_window::on_click_remove_warrior));
|
||||
|
||||
draw_each_step_toggle.signal_toggled().connect(sigc::mem_fun(*this, &bench_window::on_toggle_draw_each_step));
|
||||
pause_on_death_toggle.signal_toggled().connect(sigc::mem_fun(*this, &bench_window::on_toggle_pause_on_death));
|
||||
pause_on_win_toggle.signal_toggled().connect(sigc::mem_fun(*this, &bench_window::on_toggle_pause_on_win));
|
||||
|
||||
control_box.append(new_round_button);
|
||||
control_box.append(single_step_button);
|
||||
control_box.append(start_button);
|
||||
control_box.append(stop_button);
|
||||
control_box.append(draw_each_step_toggle);
|
||||
control_box.append(pause_on_death_toggle);
|
||||
control_box.append(pause_on_win_toggle);
|
||||
control_box.append(add_warrior_button);
|
||||
control_box.append(remove_warrior_button);
|
||||
|
||||
warrior_list_scroll.set_child(warrior_list_view);
|
||||
warrior_list_scroll.set_policy(Gtk::PolicyType::NEVER, Gtk::PolicyType::AUTOMATIC);
|
||||
warrior_list_scroll.set_vexpand();
|
||||
|
||||
control_box.append(warrior_list_scroll);
|
||||
|
||||
control_box.append(core_rate_label);
|
||||
control_box.append(core_render_label);
|
||||
|
||||
instructions_scroll.set_child(instructions_view);
|
||||
instructions_scroll.set_policy(Gtk::PolicyType::NEVER, Gtk::PolicyType::AUTOMATIC);
|
||||
|
||||
control_box.set_size_request(200, -1);
|
||||
core.set_expand();
|
||||
instructions_scroll.set_size_request(200, -1);
|
||||
|
||||
main_box.append(control_box);
|
||||
main_box.append(core);
|
||||
main_box.append(instructions_scroll);
|
||||
|
||||
set_child(main_box);
|
||||
set_title("lib94 bench");
|
||||
|
||||
runner_update_ui_dispatcher.connect(sigc::mem_fun(*this, &bench_window::update_ui));
|
||||
runner_stopping_dispatcher.connect(sigc::mem_fun(*this, &bench_window::on_runner_stopping));
|
||||
}
|
||||
|
||||
void bench_window::add_modified_for_instruction_view(std::set<lib94::number_t> the_set) {
|
||||
for (lib94::number_t n : the_set)
|
||||
modified_addresses_for_instructions_view.insert(n);
|
||||
}
|
||||
|
||||
const lib94::warrior *bench_window::do_step() {
|
||||
auto time = std::chrono::system_clock::now();
|
||||
last_core_step_distance = time - last_core_step_start;
|
||||
last_core_step_start = time;
|
||||
|
||||
const lib94::warrior *result = lib94::single_step();
|
||||
|
||||
core.mut.lock();
|
||||
core.age_all();
|
||||
core.add_new_writes(lib94::get_written_addresses());
|
||||
core.add_new_reads(lib94::get_read_addresses());
|
||||
core.add_new_executions(lib94::get_executed_addresses());
|
||||
core.mut.unlock();
|
||||
|
||||
add_modified_for_instruction_view(lib94::get_written_addresses());
|
||||
add_modified_for_instruction_view(lib94::get_read_addresses());
|
||||
add_modified_for_instruction_view(lib94::get_executed_addresses());
|
||||
|
||||
lib94::clear_address_sets();
|
||||
return result;
|
||||
}
|
||||
|
||||
void bench_window::runner_main() {
|
||||
std::chrono::system_clock::time_point last_step = std::chrono::system_clock::now();
|
||||
|
||||
core_mutex.lock();
|
||||
while (!runner_stop_now) {
|
||||
bool death = do_step() != 0;
|
||||
|
||||
if (runner_stop_on_death && death)
|
||||
break;
|
||||
if (runner_stop_on_win && death && lib94::alive_warrior_count() == 1)
|
||||
break;
|
||||
if (runner_update_ui)
|
||||
runner_update_ui_dispatcher.emit();
|
||||
|
||||
core_mutex.unlock();
|
||||
std::this_thread::sleep_until(last_step + time_between_steps);
|
||||
last_step = std::chrono::system_clock::now();
|
||||
core_mutex.lock();
|
||||
}
|
||||
|
||||
runner_stopping_dispatcher.emit();
|
||||
core_mutex.unlock();
|
||||
}
|
||||
|
||||
void bench_window::on_click_single_step() {
|
||||
do_step();
|
||||
update_ui();
|
||||
}
|
||||
|
||||
void bench_window::on_click_new_round() {
|
||||
lib94::clear_core({
|
||||
.op = lib94::DAT,
|
||||
.mod = lib94::F,
|
||||
.amode = lib94::DIRECT,
|
||||
.bmode = lib94::DIRECT,
|
||||
.anumber = 0,
|
||||
.bnumber = 0
|
||||
});
|
||||
|
||||
lib94::init_round(warriors.data(), warriors.size());
|
||||
|
||||
core.mut.lock();
|
||||
core.age_scale = std::pow(2.0 / 3.0, 1.0 / (float)warriors.size());
|
||||
core.clear_all();
|
||||
core.mut.unlock();
|
||||
|
||||
modified_addresses_for_instructions_view.clear();
|
||||
for (lib94::number_t i = 0; i < LIB94_CORE_SIZE; ++i)
|
||||
instructions_store->children()[i][instructions_columns.instruction]
|
||||
= lib94::instruction_to_string(lib94::get_instruction(i));
|
||||
|
||||
update_ui();
|
||||
}
|
||||
|
||||
void bench_window::on_click_start() {
|
||||
runner_active = true;
|
||||
update_ui();
|
||||
runner_stop_now = false;
|
||||
runner = std::thread(sigc::mem_fun(*this, &bench_window::runner_main));
|
||||
}
|
||||
|
||||
void bench_window::on_click_stop() {
|
||||
runner_stop_now = true;
|
||||
}
|
||||
|
||||
void bench_window::on_toggle_draw_each_step() {
|
||||
runner_update_ui = draw_each_step_toggle.get_active();
|
||||
}
|
||||
|
||||
void bench_window::on_toggle_pause_on_death() {
|
||||
runner_stop_on_death = pause_on_death_toggle.get_active();
|
||||
}
|
||||
|
||||
void bench_window::on_toggle_pause_on_win() {
|
||||
runner_stop_on_win = pause_on_win_toggle.get_active();
|
||||
}
|
||||
|
||||
void bench_window::on_add_warrior_dialog_response(int response_id, Gtk::FileChooserDialog *dialog) {
|
||||
if (response_id == Gtk::ResponseType::OK) {
|
||||
|
||||
Glib::RefPtr<Gio::File> file = dialog->get_file();
|
||||
char *contents;
|
||||
gsize length;
|
||||
file->load_contents(contents, length);
|
||||
|
||||
auto w = lib94::compile_warrior(std::string(contents, length));
|
||||
|
||||
delete contents;
|
||||
|
||||
if (std::holds_alternative<lib94::warrior *>(w)) {
|
||||
warriors.push_back(std::get<lib94::warrior *>(w));
|
||||
on_click_new_round();
|
||||
}
|
||||
|
||||
else {
|
||||
Gtk::MessageDialog *md = new Gtk::MessageDialog(std::string("Failed to compile: ") + std::get<std::string>(w));
|
||||
md->set_transient_for(*this);
|
||||
md->set_modal();
|
||||
md->signal_response().connect([md](int) {delete md;});
|
||||
md->show();
|
||||
}
|
||||
}
|
||||
|
||||
delete dialog;
|
||||
}
|
||||
|
||||
void bench_window::on_click_add_warrior() {
|
||||
Gtk::FileChooserDialog *dialog = new Gtk::FileChooserDialog("select a warrior");
|
||||
|
||||
dialog->set_transient_for(*this);
|
||||
dialog->set_modal();
|
||||
dialog->signal_response().connect(sigc::bind(sigc::mem_fun(*this, &bench_window::on_add_warrior_dialog_response), dialog));
|
||||
dialog->add_button("add", Gtk::ResponseType::OK);
|
||||
dialog->add_button("cancel", Gtk::ResponseType::CANCEL);
|
||||
|
||||
Glib::RefPtr<Gtk::FileFilter> text_filter = Gtk::FileFilter::create();
|
||||
text_filter->add_mime_type("text/plain");
|
||||
text_filter->set_name("text files");
|
||||
dialog->add_filter(text_filter);
|
||||
|
||||
Glib::RefPtr<Gtk::FileFilter> any_filter = Gtk::FileFilter::create();
|
||||
any_filter->add_pattern("*");
|
||||
any_filter->set_name("all files");
|
||||
dialog->add_filter(any_filter);
|
||||
|
||||
dialog->show();
|
||||
}
|
||||
|
||||
void bench_window::on_click_remove_warrior() {
|
||||
auto iter = warrior_list_view.get_selection()->get_selected();
|
||||
if (iter) {
|
||||
|
||||
while (!(*iter)[warrior_list_columns.warrior])
|
||||
iter = iter->parent();
|
||||
|
||||
const lib94::warrior *w = (*iter)[warrior_list_columns.warrior];
|
||||
|
||||
for (auto i = warriors.begin(); i != warriors.end(); ++i)
|
||||
if (*i == w) {
|
||||
warriors.erase(i);
|
||||
break;
|
||||
}
|
||||
|
||||
on_click_new_round();
|
||||
|
||||
delete w;
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
void bench_window::update_buttons() {
|
||||
new_round_button.set_sensitive(!runner_active && warriors.size() > 0);
|
||||
single_step_button.set_sensitive(!runner_active && lib94::alive_warrior_count() > 0);
|
||||
start_button.set_sensitive(!runner_active && lib94::alive_warrior_count() > 0);
|
||||
stop_button.set_sensitive(runner_active);
|
||||
add_warrior_button.set_sensitive(!runner_active);
|
||||
remove_warrior_button.set_sensitive(!runner_active && warrior_list_view.get_selection()->get_selected());
|
||||
}
|
||||
|
||||
void bench_window::update_ui() {
|
||||
if (runner_active)
|
||||
core_mutex.lock();
|
||||
|
||||
update_buttons();
|
||||
|
||||
core_render_label.set_text("core render: " + ns_to_string(core.last_draw_time));
|
||||
core_rate_label.set_text("core rate: " + hz_to_string(1000000000.0 / (double)last_core_step_distance.count()));
|
||||
|
||||
core.queue_draw();
|
||||
|
||||
warrior_list_store->clear();
|
||||
|
||||
for (const lib94::warrior *w : warriors) {
|
||||
auto w_row = warrior_list_store->append();
|
||||
(*w_row)[warrior_list_columns.warrior] = w;
|
||||
(*w_row)[warrior_list_columns.warrior_name] = w->name;
|
||||
auto procs = lib94::get_processes(w);
|
||||
(*w_row)[warrior_list_columns.processes] = procs.size();
|
||||
(*w_row)[warrior_list_columns.next_pc] = procs.size() ? std::to_string(procs[0]) : "";
|
||||
}
|
||||
|
||||
//warrior_list_view.expand_all();
|
||||
|
||||
for (lib94::number_t i : modified_addresses_for_instructions_view)
|
||||
instructions_store->children()[i][instructions_columns.instruction]
|
||||
= lib94::instruction_to_string(lib94::get_instruction(i));
|
||||
modified_addresses_for_instructions_view.clear();
|
||||
|
||||
if (runner_active)
|
||||
core_mutex.unlock();
|
||||
}
|
||||
|
||||
void bench_window::on_runner_stopping() {
|
||||
runner.join();
|
||||
runner_active = false;
|
||||
update_ui();
|
||||
}
|
||||
112
bench/bench_window.hpp
Normal file
112
bench/bench_window.hpp
Normal file
|
|
@ -0,0 +1,112 @@
|
|||
#ifndef LIB94_BENCH_BENCH_WINDOW_HPP
|
||||
#define LIB94_BENCH_BENCH_WINDOW_HPP
|
||||
|
||||
#include <gtkmm.h>
|
||||
#include <thread>
|
||||
|
||||
#include "core_widget.hpp"
|
||||
|
||||
class bench_window : public Gtk::Window {
|
||||
public:
|
||||
bench_window();
|
||||
|
||||
Glib::Dispatcher runner_update_ui_dispatcher;
|
||||
Glib::Dispatcher runner_stopping_dispatcher;
|
||||
|
||||
bool runner_stop_now;
|
||||
bool runner_stop_on_death;
|
||||
bool runner_stop_on_win;
|
||||
bool runner_update_ui;
|
||||
|
||||
core_widget core;
|
||||
|
||||
private:
|
||||
class warrior_list_columns_record : public Gtk::TreeModelColumnRecord {
|
||||
public:
|
||||
Gtk::TreeModelColumn<Glib::ustring> warrior_name;
|
||||
Gtk::TreeModelColumn<size_t> processes;
|
||||
Gtk::TreeModelColumn<Glib::ustring> next_pc;
|
||||
Gtk::TreeModelColumn<const lib94::warrior *> warrior;
|
||||
|
||||
warrior_list_columns_record() {
|
||||
add(warrior_name);
|
||||
add(processes);
|
||||
add(next_pc);
|
||||
add(warrior);
|
||||
}
|
||||
};
|
||||
|
||||
class instructions_columns_record : public Gtk::TreeModelColumnRecord {
|
||||
public:
|
||||
Gtk::TreeModelColumn<lib94::number_t> address;
|
||||
Gtk::TreeModelColumn<Glib::ustring> instruction;
|
||||
|
||||
instructions_columns_record() {
|
||||
add(address);
|
||||
add(instruction);
|
||||
}
|
||||
};
|
||||
|
||||
Gtk::ScrolledWindow warrior_list_scroll;
|
||||
Gtk::ScrolledWindow instructions_scroll;
|
||||
|
||||
warrior_list_columns_record warrior_list_columns;
|
||||
instructions_columns_record instructions_columns;
|
||||
|
||||
Glib::RefPtr<Gtk::TreeStore> warrior_list_store;
|
||||
Glib::RefPtr<Gtk::TreeStore> instructions_store;
|
||||
|
||||
Gtk::TreeView warrior_list_view;
|
||||
Gtk::TreeView instructions_view;
|
||||
|
||||
std::set<lib94::number_t> modified_addresses_for_instructions_view;
|
||||
|
||||
void add_modified_for_instruction_view(std::set<lib94::number_t> the_set);
|
||||
|
||||
Gtk::Box main_box;
|
||||
Gtk::Box control_box;
|
||||
|
||||
Gtk::Button new_round_button;
|
||||
Gtk::Button single_step_button;
|
||||
Gtk::Button start_button;
|
||||
Gtk::Button stop_button;
|
||||
|
||||
Gtk::CheckButton draw_each_step_toggle;
|
||||
Gtk::CheckButton pause_on_death_toggle;
|
||||
Gtk::CheckButton pause_on_win_toggle;
|
||||
|
||||
Gtk::Button add_warrior_button;
|
||||
Gtk::Button remove_warrior_button;
|
||||
|
||||
std::chrono::system_clock::time_point last_core_step_start;
|
||||
std::chrono::nanoseconds last_core_step_distance;
|
||||
Gtk::Label core_rate_label;
|
||||
Gtk::Label core_render_label;
|
||||
|
||||
const lib94::warrior *do_step();
|
||||
void runner_main();
|
||||
|
||||
void on_click_new_round();
|
||||
void on_click_single_step();
|
||||
void on_click_start();
|
||||
void on_click_stop();
|
||||
|
||||
void on_toggle_draw_each_step();
|
||||
void on_toggle_pause_on_death();
|
||||
void on_toggle_pause_on_win();
|
||||
|
||||
void on_click_add_warrior();
|
||||
void on_click_remove_warrior();
|
||||
|
||||
std::thread runner;
|
||||
bool runner_active;
|
||||
|
||||
void update_buttons();
|
||||
void update_ui();
|
||||
|
||||
void on_runner_stopping();
|
||||
|
||||
void on_add_warrior_dialog_response(int response_id, Gtk::FileChooserDialog *dialog);
|
||||
};
|
||||
|
||||
#endif
|
||||
162
bench/core_widget.cpp
Normal file
162
bench/core_widget.cpp
Normal file
|
|
@ -0,0 +1,162 @@
|
|||
#include "core_widget.hpp"
|
||||
|
||||
core_widget::core_widget() {
|
||||
clear_all();
|
||||
}
|
||||
|
||||
void core_widget::clear_all() {
|
||||
for (int i = 0; i < LIB94_CORE_SIZE; ++i) {
|
||||
|
||||
if (write_values[i] != 0)
|
||||
to_draw_write.insert(i);
|
||||
write_values[i] = 0;
|
||||
|
||||
if (read_values[i] != 0)
|
||||
to_draw_read.insert(i);
|
||||
read_values[i] = 0;
|
||||
|
||||
if (execute_values[i] != 0)
|
||||
to_draw_execute.insert(i);
|
||||
execute_values[i] = 0;
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
void core_widget::age_all() {
|
||||
for (int i = 0; i < LIB94_CORE_SIZE; ++i) {
|
||||
|
||||
if (write_values[i] != 0) {
|
||||
to_draw_write.insert(i);
|
||||
write_values[i] = (uint8_t)((float)write_values[i] * age_scale);
|
||||
}
|
||||
|
||||
if (read_values[i] != 0) {
|
||||
to_draw_read.insert(i);
|
||||
read_values[i] = (uint8_t)((float)read_values[i] * age_scale);
|
||||
}
|
||||
|
||||
if (execute_values[i] != 0) {
|
||||
to_draw_execute.insert(i);
|
||||
execute_values[i] = (uint8_t)((float)execute_values[i] * age_scale);
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
void core_widget::add_new_writes(const std::set<lib94::number_t> &writes) {
|
||||
for (lib94::number_t n : writes) {
|
||||
write_values[n] = 255;
|
||||
to_draw_write.insert(n);
|
||||
}
|
||||
}
|
||||
|
||||
void core_widget::add_new_reads(const std::set<lib94::number_t> &reads) {
|
||||
for (lib94::number_t n : reads) {
|
||||
read_values[n] = 255;
|
||||
to_draw_read.insert(n);
|
||||
}
|
||||
}
|
||||
|
||||
void core_widget::add_new_executions(const std::set<lib94::number_t> &executions) {
|
||||
for (lib94::number_t n : executions) {
|
||||
execute_values[n] = 255;
|
||||
to_draw_execute.insert(n);
|
||||
}
|
||||
}
|
||||
|
||||
void core_widget::measure_vfunc(Gtk::Orientation, int for_size, int &minimum, int &natural, int &minimum_baseline, int &natural_baseline) const {
|
||||
minimum = (LIB94_CORE_SIZE - 1) / for_size + 1;
|
||||
natural = (LIB94_CORE_SIZE - 1) / for_size + 1;
|
||||
minimum_baseline = -1;
|
||||
natural_baseline = -1;
|
||||
}
|
||||
|
||||
void core_widget::draw(int width, int height) {
|
||||
mut.lock();
|
||||
|
||||
if (width == last_width && height == last_height) {
|
||||
|
||||
uint8_t *buffer = (uint8_t *)pixbuf->property_pixels().get_value();
|
||||
|
||||
for (lib94::number_t i : to_draw_write) {
|
||||
int cy = i / cpr * scale + ypad;
|
||||
int cx = i % cpr * scale + xpad;
|
||||
for (int dy = 0; dy < scale; ++dy)
|
||||
for (int dx = 0; dx < scale; ++dx)
|
||||
buffer[(cy + dy) * pixbuf->property_rowstride() + (cx + dx) * 4] = write_values[i];
|
||||
}
|
||||
|
||||
for (lib94::number_t i : to_draw_read) {
|
||||
int cy = i / cpr * scale + ypad;
|
||||
int cx = i % cpr * scale + xpad;
|
||||
for (int dy = 0; dy < scale; ++dy)
|
||||
for (int dx = 0; dx < scale; ++dx)
|
||||
buffer[(cy + dy) * pixbuf->property_rowstride() + (cx + dx) * 4 + 2] = read_values[i];
|
||||
}
|
||||
|
||||
for (lib94::number_t i : to_draw_execute) {
|
||||
int cy = i / cpr * scale + ypad;
|
||||
int cx = i % cpr * scale + xpad;
|
||||
for (int dy = 0; dy < scale; ++dy)
|
||||
for (int dx = 0; dx < scale; ++dx)
|
||||
buffer[(cy + dy) * pixbuf->property_rowstride() + (cx + dx) * 4 + 1] = execute_values[i];
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
else {
|
||||
|
||||
pixbuf = Gdk::Pixbuf::create(Gdk::Colorspace::RGB, true, 8, width, height);
|
||||
last_width = width;
|
||||
last_height = height;
|
||||
|
||||
scale = 1;
|
||||
while (true) {
|
||||
++scale;
|
||||
if ((width / scale) * (height / scale) < LIB94_CORE_SIZE) {
|
||||
--scale;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
cpr = width / scale;
|
||||
xpad = (width % scale) / 2;
|
||||
ypad = (height % scale) / 2;
|
||||
|
||||
uint8_t *buffer = (uint8_t *)pixbuf->property_pixels().get_value();
|
||||
|
||||
for (lib94::number_t i = 0; i < LIB94_CORE_SIZE; ++i) {
|
||||
int cy = i / cpr * scale + ypad;
|
||||
int cx = i % cpr * scale + xpad;
|
||||
for (int dy = 0; dy < scale; ++dy)
|
||||
for (int dx = 0; dx < scale; ++dx) {
|
||||
buffer[(cy + dy) * pixbuf->property_rowstride() + (cx + dx) * 4] = write_values[i];
|
||||
buffer[(cy + dy) * pixbuf->property_rowstride() + (cx + dx) * 4 + 2] = read_values[i];
|
||||
buffer[(cy + dy) * pixbuf->property_rowstride() + (cx + dx) * 4 + 1] = execute_values[i];
|
||||
buffer[(cy + dy) * pixbuf->property_rowstride() + (cx + dx) * 4 + 3] = 255;
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
to_draw_write.clear();
|
||||
to_draw_read.clear();
|
||||
to_draw_execute.clear();
|
||||
|
||||
mut.unlock();
|
||||
}
|
||||
|
||||
void core_widget::snapshot_vfunc(const Glib::RefPtr<Gtk::Snapshot> &snapshot) {
|
||||
auto start_time = std::chrono::system_clock::now();
|
||||
|
||||
Gtk::Allocation allocation = get_allocation();
|
||||
Gdk::Rectangle allocation_rect(0, 0, allocation.get_width(), allocation.get_height());
|
||||
|
||||
draw(allocation.get_width(), allocation.get_height());
|
||||
|
||||
auto texture = Gdk::Texture::create_for_pixbuf(pixbuf);
|
||||
snapshot->append_texture(texture, allocation_rect);
|
||||
|
||||
auto end_time = std::chrono::system_clock::now();
|
||||
last_draw_time = end_time - start_time;
|
||||
}
|
||||
46
bench/core_widget.hpp
Normal file
46
bench/core_widget.hpp
Normal file
|
|
@ -0,0 +1,46 @@
|
|||
#ifndef LIB94_BENCH_CORE_WIDGET_HPP
|
||||
#define LIB94_BENCH_CORE_WIDGET_HPP
|
||||
|
||||
#include <lib94/lib94.hpp>
|
||||
#include <gtkmm.h>
|
||||
|
||||
class core_widget : public Gtk::Widget {
|
||||
public:
|
||||
core_widget();
|
||||
void clear_all();
|
||||
void age_all();
|
||||
void add_new_writes(const std::set<lib94::number_t> &writes);
|
||||
void add_new_reads(const std::set<lib94::number_t> &reads);
|
||||
void add_new_executions(const std::set<lib94::number_t> &executions);
|
||||
|
||||
void measure_vfunc(Gtk::Orientation orientation, int for_size, int &minimum, int &natural, int &minimum_baseline, int &natural_baseline) const override;
|
||||
void snapshot_vfunc(const Glib::RefPtr<Gtk::Snapshot> &snapshot);
|
||||
|
||||
float age_scale;
|
||||
|
||||
std::chrono::nanoseconds last_draw_time;
|
||||
|
||||
std::mutex mut;
|
||||
|
||||
private:
|
||||
uint8_t write_values[LIB94_CORE_SIZE];
|
||||
uint8_t read_values[LIB94_CORE_SIZE];
|
||||
uint8_t execute_values[LIB94_CORE_SIZE];
|
||||
|
||||
std::set<lib94::number_t> to_draw_write;
|
||||
std::set<lib94::number_t> to_draw_read;
|
||||
std::set<lib94::number_t> to_draw_execute;
|
||||
|
||||
Glib::RefPtr<Gdk::Pixbuf> pixbuf;
|
||||
|
||||
int last_width;
|
||||
int last_height;
|
||||
int scale;
|
||||
int cpr;
|
||||
int xpad;
|
||||
int ypad;
|
||||
|
||||
void draw(int width, int height);
|
||||
};
|
||||
|
||||
#endif
|
||||
31
bench/main.cpp
Normal file
31
bench/main.cpp
Normal file
|
|
@ -0,0 +1,31 @@
|
|||
#include "bench_window.hpp"
|
||||
#include "main.hpp"
|
||||
|
||||
std::vector<lib94::warrior *> warriors;
|
||||
std::chrono::milliseconds time_between_steps(50);
|
||||
std::mutex core_mutex;
|
||||
|
||||
int main(int argc, char **argv) {
|
||||
auto app = Gtk::Application::create("net.benjidial.lib94.bench");
|
||||
return app->make_window_and_run<bench_window>(argc, argv);
|
||||
}
|
||||
|
||||
std::string ns_to_string(std::chrono::nanoseconds dur) {
|
||||
if (dur.count() >= 10000000000)
|
||||
return std::to_string((dur.count() + 500000000) / 1000000000) + "s";
|
||||
if (dur.count() >= 10000000)
|
||||
return std::to_string((dur.count() + 500000) / 1000000) + "ms";
|
||||
if (dur.count() >= 10000)
|
||||
return std::to_string((dur.count() + 500) / 1000) + "μs";
|
||||
return std::to_string(dur.count()) + "ns";
|
||||
}
|
||||
|
||||
std::string hz_to_string(double rate) {
|
||||
if (rate >= 10000000.0)
|
||||
return std::to_string((int)std::round(rate / 1000000.0)) + "MHz";
|
||||
if (rate >= 10000.0)
|
||||
return std::to_string((int)std::round(rate / 1000.0)) + "kHz";
|
||||
if (rate >= 10.0)
|
||||
return std::to_string((int)std::round(rate)) + "Hz";
|
||||
return std::to_string((int)std::round(rate * 1000.0)) + "mHz";
|
||||
}
|
||||
16
bench/main.hpp
Normal file
16
bench/main.hpp
Normal file
|
|
@ -0,0 +1,16 @@
|
|||
#ifndef LIB94_BENCH_MAIN_HPP
|
||||
#define LIB94_BENCH_MAIN_HPP
|
||||
|
||||
#include <lib94/lib94.hpp>
|
||||
#include <chrono>
|
||||
#include <vector>
|
||||
#include <mutex>
|
||||
|
||||
extern std::vector<lib94::warrior *> warriors;
|
||||
extern std::chrono::milliseconds time_between_steps;
|
||||
extern std::mutex core_mutex;
|
||||
|
||||
std::string ns_to_string(std::chrono::nanoseconds dur);
|
||||
std::string hz_to_string(double rate);
|
||||
|
||||
#endif
|
||||
|
|
@ -1,5 +1,5 @@
|
|||
#ifndef LIB94_HPP
|
||||
#define LIB94_HPP
|
||||
#ifndef LIB94_LIB94_HPP
|
||||
#define LIB94_LIB94_HPP
|
||||
|
||||
#include <filesystem>
|
||||
#include <optional>
|
||||
|
|
@ -7,14 +7,16 @@
|
|||
#include <string>
|
||||
#include <random>
|
||||
#include <vector>
|
||||
#include <queue>
|
||||
#include <deque>
|
||||
#include <set>
|
||||
|
||||
#ifndef CORE_SIZE
|
||||
#define CORE_SIZE 8000
|
||||
#ifndef LIB94_CORE_SIZE
|
||||
#define LIB94_CORE_SIZE 8000
|
||||
#endif
|
||||
|
||||
typedef uint32_t number_t;
|
||||
namespace lib94 {
|
||||
|
||||
typedef int_least32_t number_t;
|
||||
|
||||
enum opcode : uint8_t {
|
||||
DAT, MOV, ADD, SUB,
|
||||
|
|
@ -55,6 +57,8 @@ struct warrior {
|
|||
|
||||
void seed_prng(uint_fast64_t seed);
|
||||
|
||||
std::string instruction_to_string(const instruction &instr);
|
||||
|
||||
std::variant<warrior *, std::string> compile_warrior(std::string source);
|
||||
bool save_warrior(const warrior &w, const std::filesystem::path &to);
|
||||
std::optional<warrior *> load_warrior(const std::filesystem::path &from);
|
||||
|
|
@ -64,25 +68,27 @@ void clear_core_random();
|
|||
|
||||
//warrior pointers need to remain valid for other
|
||||
//functions to return valid things during the round
|
||||
bool init_round(const std::vector<const warrior *> &warriors);
|
||||
bool init_round(const warrior *const *warriors, size_t count);
|
||||
|
||||
size_t alive_warrior_count();
|
||||
|
||||
//asserts that there is a next warrior
|
||||
const warrior *get_next_warrior();
|
||||
const std::queue<number_t> &get_processes(const warrior *for_warrior);
|
||||
const std::deque<number_t> &get_processes(const warrior *for_warrior);
|
||||
//asserts that there is a next process
|
||||
number_t get_next_process(const warrior *for_warrior);
|
||||
|
||||
const std::set<number_t> &get_modified_addresses();
|
||||
void clear_modified_addresses();
|
||||
const std::set<number_t> &get_written_addresses();
|
||||
const std::set<number_t> &get_read_addresses();
|
||||
const std::set<number_t> &get_executed_addresses();
|
||||
void clear_address_sets();
|
||||
|
||||
const instruction &get_instruction(number_t address);
|
||||
|
||||
//asserts that there is a next warrior
|
||||
void single_step();
|
||||
//assumes that there is a next warrior
|
||||
//returns a warrior if it dies
|
||||
const warrior *single_step();
|
||||
|
||||
const warrior *run_until_warrior_death();
|
||||
const warrior *run_until_winner();
|
||||
}
|
||||
|
||||
#endif
|
||||
|
|
|
|||
176
lib94/core.cpp
176
lib94/core.cpp
|
|
@ -2,11 +2,13 @@
|
|||
#include <functional>
|
||||
#include <cassert>
|
||||
#include <random>
|
||||
#include <queue>
|
||||
#include <deque>
|
||||
#include <set>
|
||||
|
||||
namespace lib94 {
|
||||
|
||||
static std::mt19937_64 prng;
|
||||
instruction core[CORE_SIZE];
|
||||
instruction core[LIB94_CORE_SIZE];
|
||||
|
||||
void seed_prng(uint_fast64_t seed) {
|
||||
prng.seed(seed);
|
||||
|
|
@ -21,7 +23,7 @@ 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, CORE_SIZE - 1);
|
||||
std::uniform_int_distribution<number_t> number(0, LIB94_CORE_SIZE - 1);
|
||||
|
||||
for (instruction &i : core)
|
||||
i = {
|
||||
|
|
@ -34,25 +36,40 @@ void clear_core_random() {
|
|||
};
|
||||
}
|
||||
|
||||
static std::set<number_t> modified_addresses;
|
||||
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::queue<number_t> processes;
|
||||
std::deque<number_t> processes;
|
||||
};
|
||||
|
||||
static std::vector<warrior_info> warrior_infos;
|
||||
std::queue<warrior_info *> alive_warriors;
|
||||
std::deque<warrior_info *> alive_warriors;
|
||||
|
||||
bool init_round(const std::vector<const warrior *> &warriors) {
|
||||
modified_addresses.clear();
|
||||
bool init_round(const warrior *const *warriors, size_t count) {
|
||||
clear_address_sets();
|
||||
warrior_infos.clear();
|
||||
alive_warriors = std::queue<warrior_info *>();
|
||||
alive_warriors = std::deque<warrior_info *>();
|
||||
|
||||
std::uniform_int_distribution<number_t> number(0, CORE_SIZE - 1);
|
||||
std::uniform_int_distribution<number_t> number(0, LIB94_CORE_SIZE - 1);
|
||||
std::vector<std::pair<number_t, number_t>> placements;
|
||||
|
||||
for (const warrior *w : warriors) {
|
||||
for (size_t i = 0; i < count; ++i) {
|
||||
const warrior *w = warriors[i];
|
||||
unsigned tries = 0;
|
||||
|
||||
new_place_at:
|
||||
|
|
@ -60,30 +77,32 @@ bool init_round(const std::vector<const warrior *> &warriors) {
|
|||
return false;
|
||||
++tries;
|
||||
|
||||
number_t place_at = number(prng);
|
||||
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 < w->instructions.size(); ++i)
|
||||
if (((place_at + i) % CORE_SIZE >= other.first && (place_at + i) % CORE_SIZE < other.first + other.second) ||
|
||||
((place_at + i) % CORE_SIZE + CORE_SIZE >= other.first && (place_at + i) % CORE_SIZE + CORE_SIZE < other.first + other.second))
|
||||
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 < w->instructions.size(); ++i)
|
||||
core[(place_at + i) % CORE_SIZE] = w->instructions[i];
|
||||
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((place_at + w->org) % CORE_SIZE);
|
||||
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(&wi);
|
||||
alive_warriors.push_back(&wi);
|
||||
|
||||
return true;
|
||||
}
|
||||
|
|
@ -97,7 +116,7 @@ const warrior *get_next_warrior() {
|
|||
return alive_warriors.front()->the_warrior;
|
||||
}
|
||||
|
||||
const std::queue<number_t> &get_processes(const warrior *for_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;
|
||||
|
|
@ -113,46 +132,28 @@ number_t get_next_process(const warrior *for_warrior) {
|
|||
assert(false);
|
||||
}
|
||||
|
||||
const std::set<number_t> &get_modified_addresses() {
|
||||
return modified_addresses;
|
||||
const std::set<number_t> &get_written_addresses() {
|
||||
return written_addresses;
|
||||
}
|
||||
|
||||
void clear_modified_addresses() {
|
||||
modified_addresses.clear();
|
||||
const std::set<number_t> &get_read_addresses() {
|
||||
return read_addresses;
|
||||
}
|
||||
|
||||
void add_modified_instruction(const instruction *instr) {
|
||||
modified_addresses.insert(instr - core);
|
||||
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];
|
||||
}
|
||||
|
||||
static const warrior *single_step_return_dead();
|
||||
|
||||
void single_step() {
|
||||
single_step_return_dead();
|
||||
}
|
||||
|
||||
const warrior *run_until_warrior_death() {
|
||||
while (true) {
|
||||
const warrior *w = single_step_return_dead();
|
||||
if (w)
|
||||
return w;
|
||||
}
|
||||
}
|
||||
|
||||
const warrior *run_until_winner() {
|
||||
while (true) {
|
||||
const warrior *w = single_step_return_dead();
|
||||
if (w && alive_warriors.size() == 1)
|
||||
for (const warrior_info &wi : warrior_infos)
|
||||
if (wi.processes.size() > 0)
|
||||
return wi.the_warrior;
|
||||
}
|
||||
}
|
||||
|
||||
number_t program_counter;
|
||||
static instruction instruction_register;
|
||||
|
||||
|
|
@ -174,49 +175,55 @@ static void evaluate_operand(mode m, number_t n, number_t &ptr, instruction &ins
|
|||
|
||||
case DIRECT:
|
||||
ptr = n;
|
||||
instr = core[(program_counter + n) % CORE_SIZE];
|
||||
instr = core[(program_counter + n) % LIB94_CORE_SIZE];
|
||||
break;
|
||||
|
||||
case A_INDIRECT:
|
||||
secondary = core + (program_counter + n) % CORE_SIZE;
|
||||
ptr = (n + secondary->anumber) % CORE_SIZE;
|
||||
instr = core[(program_counter + ptr) % CORE_SIZE];
|
||||
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) % CORE_SIZE;
|
||||
ptr = (n + secondary->bnumber) % CORE_SIZE;
|
||||
instr = core[(program_counter + ptr) % CORE_SIZE];
|
||||
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) % CORE_SIZE;
|
||||
ptr = (n + --secondary->anumber) % CORE_SIZE;
|
||||
instr = core[(program_counter + ptr) % CORE_SIZE];
|
||||
add_modified_instruction(secondary);
|
||||
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) % CORE_SIZE;
|
||||
ptr = (n + --secondary->bnumber) % CORE_SIZE;
|
||||
instr = core[(program_counter + ptr) % CORE_SIZE];
|
||||
add_modified_instruction(secondary);
|
||||
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) % CORE_SIZE;
|
||||
ptr = (n + secondary->anumber) % CORE_SIZE;
|
||||
instr = core[(program_counter + ptr) % CORE_SIZE];
|
||||
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_modified_instruction(secondary);
|
||||
add_read_instruction(secondary);
|
||||
add_written_instruction(secondary);
|
||||
break;
|
||||
|
||||
case B_INCREMENT:
|
||||
secondary = core + (program_counter + n) % CORE_SIZE;
|
||||
ptr = (n + secondary->bnumber) % CORE_SIZE;
|
||||
instr = core[(program_counter + ptr) % CORE_SIZE];
|
||||
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_modified_instruction(secondary);
|
||||
add_read_instruction(secondary);
|
||||
add_written_instruction(secondary);
|
||||
break;
|
||||
|
||||
}
|
||||
|
|
@ -263,32 +270,35 @@ static const std::function<bool ()> executors[] = {
|
|||
static warrior_info *this_warrior;
|
||||
|
||||
void enqueue_process(number_t pc) {
|
||||
this_warrior->processes.push(pc);
|
||||
this_warrior->processes.push_back(pc);
|
||||
}
|
||||
|
||||
static const warrior *single_step_return_dead() {
|
||||
const warrior *single_step() {
|
||||
this_warrior = alive_warriors.front();
|
||||
alive_warriors.pop();
|
||||
alive_warriors.pop_front();
|
||||
|
||||
program_counter = this_warrior->processes.front();
|
||||
this_warrior->processes.pop();
|
||||
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) % CORE_SIZE;
|
||||
b_instruction_writable = core + (program_counter + b_pointer) % CORE_SIZE;
|
||||
a_instruction_writable = core + (program_counter + a_pointer) % LIB94_CORE_SIZE;
|
||||
b_instruction_writable = core + (program_counter + b_pointer) % LIB94_CORE_SIZE;
|
||||
|
||||
bool enqueue_process = executors[instruction_register.op + instruction_register.mod * 16]();
|
||||
bool should_endeque = executors[instruction_register.op + instruction_register.mod * 16]();
|
||||
|
||||
if (enqueue_process)
|
||||
this_warrior->processes.push((program_counter + 1) % CORE_SIZE);
|
||||
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(this_warrior);
|
||||
alive_warriors.push_back(this_warrior);
|
||||
return 0;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
|||
|
|
@ -2,15 +2,20 @@
|
|||
#include <functional>
|
||||
#include <cassert>
|
||||
|
||||
#include <cstdio>
|
||||
|
||||
namespace lib94 {
|
||||
|
||||
void enqueue_process(number_t pc);
|
||||
|
||||
extern instruction core[CORE_SIZE];
|
||||
extern instruction core[LIB94_CORE_SIZE];
|
||||
extern number_t program_counter;
|
||||
extern instruction a_instruction, b_instruction;
|
||||
extern instruction *a_instruction_writable;
|
||||
extern instruction *b_instruction_writable;
|
||||
|
||||
void add_modified_instruction(const instruction *instr);
|
||||
void add_written_instruction(const instruction *instr);
|
||||
void add_read_instruction(const instruction *instr);
|
||||
|
||||
struct single_target {
|
||||
number_t *ptr;
|
||||
|
|
@ -208,7 +213,8 @@ bool execute() {
|
|||
return false;
|
||||
|
||||
else if constexpr (op == MOV) {
|
||||
add_modified_instruction(b_instruction_writable);
|
||||
add_read_instruction(a_instruction_writable);
|
||||
add_written_instruction(b_instruction_writable);
|
||||
if constexpr (mod == I) {
|
||||
dest_out.instr->op = src_in.instr->op;
|
||||
dest_out.instr->mod = src_in.instr->mod;
|
||||
|
|
@ -216,33 +222,42 @@ bool execute() {
|
|||
dest_out.instr->bmode = src_in.instr->bmode;
|
||||
}
|
||||
return dest_out.assign(dest_in, src_in, [](number_t a, number_t b) -> std::optional<number_t> {
|
||||
(void)a;
|
||||
return b;
|
||||
});
|
||||
}
|
||||
|
||||
else if constexpr (op == ADD) {
|
||||
add_modified_instruction(b_instruction_writable);
|
||||
add_read_instruction(a_instruction_writable);
|
||||
add_read_instruction(b_instruction_writable);
|
||||
add_written_instruction(b_instruction_writable);
|
||||
return dest_out.assign(dest_in, src_in, [](number_t a, number_t b) -> std::optional<number_t> {
|
||||
return (a + b) % CORE_SIZE;
|
||||
return (a + b) % LIB94_CORE_SIZE;
|
||||
});
|
||||
}
|
||||
|
||||
else if constexpr (op == SUB) {
|
||||
add_modified_instruction(b_instruction_writable);
|
||||
add_read_instruction(a_instruction_writable);
|
||||
add_read_instruction(b_instruction_writable);
|
||||
add_written_instruction(b_instruction_writable);
|
||||
return dest_out.assign(dest_in, src_in, [](number_t a, number_t b) -> std::optional<number_t> {
|
||||
return (a + CORE_SIZE - b) % CORE_SIZE;
|
||||
return (a + LIB94_CORE_SIZE - b) % LIB94_CORE_SIZE;
|
||||
});
|
||||
}
|
||||
|
||||
else if constexpr (op == MUL) {
|
||||
add_modified_instruction(b_instruction_writable);
|
||||
add_read_instruction(a_instruction_writable);
|
||||
add_read_instruction(b_instruction_writable);
|
||||
add_written_instruction(b_instruction_writable);
|
||||
return dest_out.assign(dest_in, src_in, [](number_t a, number_t b) -> std::optional<number_t> {
|
||||
return (a * b) % CORE_SIZE;
|
||||
return (a * b) % LIB94_CORE_SIZE;
|
||||
});
|
||||
}
|
||||
|
||||
else if constexpr (op == DIV) {
|
||||
add_modified_instruction(b_instruction_writable);
|
||||
add_read_instruction(a_instruction_writable);
|
||||
add_read_instruction(b_instruction_writable);
|
||||
add_written_instruction(b_instruction_writable);
|
||||
return dest_out.assign(dest_in, src_in, [](number_t a, number_t b) -> std::optional<number_t> {
|
||||
if (b == 0)
|
||||
return {};
|
||||
|
|
@ -251,7 +266,9 @@ bool execute() {
|
|||
}
|
||||
|
||||
else if constexpr (op == MOD) {
|
||||
add_modified_instruction(b_instruction_writable);
|
||||
add_read_instruction(a_instruction_writable);
|
||||
add_read_instruction(b_instruction_writable);
|
||||
add_written_instruction(b_instruction_writable);
|
||||
return dest_out.assign(dest_in, src_in, [](number_t a, number_t b) -> std::optional<number_t> {
|
||||
if (b == 0)
|
||||
return {};
|
||||
|
|
@ -260,50 +277,64 @@ bool execute() {
|
|||
}
|
||||
|
||||
else if constexpr (op == JMP) {
|
||||
program_counter = (a_instruction_writable - core + CORE_SIZE - 1) % CORE_SIZE;
|
||||
add_read_instruction(a_instruction_writable);
|
||||
program_counter = (a_instruction_writable - core + LIB94_CORE_SIZE - 1) % LIB94_CORE_SIZE;
|
||||
return true;
|
||||
}
|
||||
|
||||
else if constexpr (op == JMZ) {
|
||||
add_read_instruction(a_instruction_writable);
|
||||
add_read_instruction(b_instruction_writable);
|
||||
if (dest_in.is_zero())
|
||||
program_counter = (a_instruction_writable - core + CORE_SIZE - 1) % CORE_SIZE;
|
||||
program_counter = (a_instruction_writable - core + LIB94_CORE_SIZE - 1) % LIB94_CORE_SIZE;
|
||||
return true;
|
||||
}
|
||||
|
||||
else if constexpr (op == JMN) {
|
||||
add_read_instruction(a_instruction_writable);
|
||||
add_read_instruction(b_instruction_writable);
|
||||
if (!dest_in.is_zero())
|
||||
program_counter = (a_instruction_writable - core + CORE_SIZE - 1) % CORE_SIZE;
|
||||
program_counter = (a_instruction_writable - core + LIB94_CORE_SIZE - 1) % LIB94_CORE_SIZE;
|
||||
return true;
|
||||
}
|
||||
|
||||
else if constexpr (op == DJN) {
|
||||
add_modified_instruction(b_instruction_writable);
|
||||
add_read_instruction(a_instruction_writable);
|
||||
add_read_instruction(b_instruction_writable);
|
||||
add_written_instruction(b_instruction_writable);
|
||||
if (dest_in.dec_not_zero())
|
||||
program_counter = (a_instruction_writable - core + CORE_SIZE - 1) % CORE_SIZE;
|
||||
program_counter = (a_instruction_writable - core + LIB94_CORE_SIZE - 1) % LIB94_CORE_SIZE;
|
||||
return true;
|
||||
}
|
||||
|
||||
else if constexpr (op == SEQ) {
|
||||
add_read_instruction(a_instruction_writable);
|
||||
add_read_instruction(b_instruction_writable);
|
||||
if (src_in.equal_to(dest_in))
|
||||
program_counter = (program_counter + 1) % CORE_SIZE;
|
||||
program_counter = (program_counter + 1) % LIB94_CORE_SIZE;
|
||||
return true;
|
||||
}
|
||||
|
||||
else if constexpr (op == SNE) {
|
||||
add_read_instruction(a_instruction_writable);
|
||||
add_read_instruction(b_instruction_writable);
|
||||
if (!src_in.equal_to(dest_in))
|
||||
program_counter = (program_counter + 1) % CORE_SIZE;
|
||||
program_counter = (program_counter + 1) % LIB94_CORE_SIZE;
|
||||
return true;
|
||||
}
|
||||
|
||||
else if constexpr (op == SLT) {
|
||||
add_read_instruction(a_instruction_writable);
|
||||
add_read_instruction(b_instruction_writable);
|
||||
if (src_in.less_than(dest_in))
|
||||
program_counter = (program_counter + 1) % CORE_SIZE;
|
||||
program_counter = (program_counter + 1) % LIB94_CORE_SIZE;
|
||||
return true;
|
||||
}
|
||||
|
||||
else if constexpr (op == SPL) {
|
||||
enqueue_process((program_counter + 1) % CORE_SIZE);
|
||||
program_counter = (a_instruction_writable - core + CORE_SIZE - 1) % CORE_SIZE;
|
||||
add_read_instruction(a_instruction_writable);
|
||||
enqueue_process((program_counter + 1) % LIB94_CORE_SIZE);
|
||||
program_counter = (a_instruction_writable - core + LIB94_CORE_SIZE - 1) % LIB94_CORE_SIZE;
|
||||
return true;
|
||||
}
|
||||
|
||||
|
|
@ -330,3 +361,5 @@ EXECUTOR_INST_LINE(BA)
|
|||
EXECUTOR_INST_LINE(F)
|
||||
EXECUTOR_INST_LINE(X)
|
||||
EXECUTOR_INST_LINE(I)
|
||||
|
||||
}
|
||||
|
|
|
|||
|
|
@ -6,6 +6,30 @@
|
|||
#include <memory>
|
||||
#include <map>
|
||||
|
||||
namespace lib94 {
|
||||
|
||||
static const std::string opcode_strings[] = {
|
||||
"dat", "mov", "add", "sub", "mul", "div", "mod", "jmp",
|
||||
"jmz", "jmn", "djn", "seq", "sne", "slt", "spl", "nop"
|
||||
};
|
||||
|
||||
static const std::string modifier_strings[] = {
|
||||
"a", "b", "ab", "ba", "f", "x", "i"
|
||||
};
|
||||
|
||||
static const char mode_chars[] = "#$*@{<}>";
|
||||
|
||||
std::string instruction_to_string(const instruction &instr) {
|
||||
return
|
||||
opcode_strings[instr.op] + '.' + modifier_strings[instr.mod] + ' ' +
|
||||
mode_chars[instr.amode] + std::to_string(instr.anumber) + ", " +
|
||||
mode_chars[instr.bmode] + std::to_string(instr.bnumber);
|
||||
}
|
||||
|
||||
number_t real_mod(number_t input) {
|
||||
return (input % LIB94_CORE_SIZE + LIB94_CORE_SIZE) % LIB94_CORE_SIZE;
|
||||
}
|
||||
|
||||
struct number_expr {
|
||||
virtual std::optional<number_t> to_number(const std::map<std::string, number_t> &label_offsets, number_t this_offset) = 0;
|
||||
};
|
||||
|
|
@ -17,7 +41,7 @@ struct label_number_expr : public number_expr {
|
|||
auto result = label_offsets.find(label);
|
||||
if (result == label_offsets.end())
|
||||
return {};
|
||||
return result->second - this_offset;
|
||||
return real_mod(result->second - this_offset);
|
||||
}
|
||||
};
|
||||
|
||||
|
|
@ -25,7 +49,9 @@ struct number_number_expr : public number_expr {
|
|||
number_t value;
|
||||
|
||||
virtual std::optional<number_t> to_number(const std::map<std::string, number_t> &label_offsets, number_t this_offset) {
|
||||
return value;
|
||||
(void)label_offsets;
|
||||
(void)this_offset;
|
||||
return real_mod(value);
|
||||
}
|
||||
};
|
||||
|
||||
|
|
@ -37,8 +63,11 @@ struct op_number_expr : public number_expr {
|
|||
virtual std::optional<number_t> to_number(const std::map<std::string, number_t> &label_offsets, number_t this_offset) {
|
||||
std::optional<number_t> left_result = left->to_number(label_offsets, this_offset);
|
||||
std::optional<number_t> right_result = right->to_number(label_offsets, this_offset);
|
||||
if (left_result.has_value() && right_result.has_value())
|
||||
return op(left_result.value(), right_result.value());
|
||||
if (left_result.has_value() && right_result.has_value()) {
|
||||
std::optional<number_t> op_result = op(left_result.value(), right_result.value());
|
||||
if (op_result.has_value())
|
||||
return real_mod(op_result.value());
|
||||
}
|
||||
return {};
|
||||
}
|
||||
};
|
||||
|
|
@ -60,12 +89,12 @@ bool valid_label(std::string candidate) {
|
|||
size_t find_respecting_parentheses(std::string part, std::string candidates) {
|
||||
size_t layers = 0;
|
||||
|
||||
for (size_t i = 0; i < part.size(); ++i)
|
||||
for (int i = part.size() - 1; i >= 0; --i)
|
||||
if (layers == 0 && candidates.find(part[i]) != std::string::npos)
|
||||
return i;
|
||||
else if (part[i] == '(')
|
||||
++layers;
|
||||
else if (part[i] == ')')
|
||||
++layers;
|
||||
else if (part[i] == '(')
|
||||
--layers;
|
||||
|
||||
return std::string::npos;
|
||||
|
|
@ -90,8 +119,16 @@ std::optional<std::unique_ptr<number_expr>> make_op_expr(std::string part, size_
|
|||
case '+': expr->op = [](number_t a, number_t b) {return a + b;}; break;
|
||||
case '-': expr->op = [](number_t a, number_t b) {return a - b;}; break;
|
||||
case '*': expr->op = [](number_t a, number_t b) {return a * b;}; break;
|
||||
case '/': expr->op = [](number_t a, number_t b) {return a / b;}; break;
|
||||
case '%': expr->op = [](number_t a, number_t b) {return a % b;}; break;
|
||||
case '/': expr->op = [](number_t a, number_t b) -> std::optional<number_t> {
|
||||
if (b == 0)
|
||||
return {};
|
||||
return a / b;
|
||||
}; break;
|
||||
case '%': expr->op = [](number_t a, number_t b) -> std::optional<number_t> {
|
||||
if (b == 0)
|
||||
return {};
|
||||
return a % b;
|
||||
}; break;
|
||||
}
|
||||
|
||||
return expr;
|
||||
|
|
@ -119,6 +156,7 @@ std::optional<std::unique_ptr<number_expr>> to_number_expr(std::string part) {
|
|||
if (part[0] == '(' && part[part.size() - 1] == ')')
|
||||
return to_number_expr(part.substr(1, part.size() - 2));
|
||||
|
||||
try {
|
||||
size_t count;
|
||||
number_t number = std::stoul(part, &count);
|
||||
if (count == part.size()) {
|
||||
|
|
@ -126,6 +164,8 @@ std::optional<std::unique_ptr<number_expr>> to_number_expr(std::string part) {
|
|||
expr->value = number;
|
||||
return expr;
|
||||
}
|
||||
}
|
||||
catch (const std::exception &e) {}
|
||||
|
||||
if (valid_label(part)) {
|
||||
std::unique_ptr<label_number_expr> expr = std::make_unique<label_number_expr>();
|
||||
|
|
@ -167,7 +207,7 @@ static const std::map<std::string, opcode> opcode_names = {
|
|||
{"mul", MUL}, {"div", DIV}, {"mod", MOD}, {"jmp", JMP},
|
||||
{"jmz", JMZ}, {"jmn", JMN}, {"djn", DJN}, {"seq", SEQ},
|
||||
{"sne", SNE}, {"slt", SLT}, {"spl", SPL}, {"nop", NOP},
|
||||
{"cmp", SEQ}
|
||||
{"cmp", SEQ}, {"jnz", JMN}
|
||||
};
|
||||
|
||||
struct future_instruction {
|
||||
|
|
@ -190,8 +230,8 @@ std::variant<warrior *, std::string> compile_warrior(std::string source) {
|
|||
std::vector<future_instruction> instructions;
|
||||
std::map<std::string, number_t> label_offsets;
|
||||
std::optional<std::unique_ptr<number_expr>> org = {};
|
||||
number_t org_offset;
|
||||
size_t org_source_line;
|
||||
number_t org_offset = -1;
|
||||
size_t org_source_line = -1;
|
||||
|
||||
size_t on_line = 0;
|
||||
|
||||
|
|
@ -404,7 +444,7 @@ std::variant<warrior *, std::string> compile_warrior(std::string source) {
|
|||
return std::string("bad expression on line ") + std::to_string(org_source_line);
|
||||
}
|
||||
|
||||
for (int i = 0; i < instructions.size(); ++i) {
|
||||
for (size_t i = 0; i < instructions.size(); ++i) {
|
||||
const future_instruction &instr = instructions[i];
|
||||
std::optional<number_t> anumber = instr.anumber->to_number(label_offsets, i);
|
||||
std::optional<number_t> bnumber = instr.bnumber->to_number(label_offsets, i);
|
||||
|
|
@ -412,8 +452,7 @@ std::variant<warrior *, std::string> compile_warrior(std::string source) {
|
|||
return std::string("bad expression on line ") + std::to_string(instr.source_line);
|
||||
w->instructions.push_back({
|
||||
.op = instr.op, .mod = instr.mod, .amode = instr.amode, .bmode = instr.bmode,
|
||||
.anumber = ((anumber.value() % CORE_SIZE) + CORE_SIZE) % CORE_SIZE,
|
||||
.bnumber = ((bnumber.value() % CORE_SIZE) + CORE_SIZE) % CORE_SIZE
|
||||
.anumber = anumber.value(), .bnumber = bnumber.value()
|
||||
});
|
||||
}
|
||||
|
||||
|
|
@ -469,8 +508,10 @@ std::optional<warrior *> load_warrior(const std::filesystem::path &from) {
|
|||
|
||||
for (const instruction &i : w->instructions)
|
||||
if (i.op > NOP || i.mod > I || i.amode > B_INCREMENT || i.bmode > B_INCREMENT ||
|
||||
i.anumber >= CORE_SIZE || i.bnumber >= CORE_SIZE)
|
||||
i.anumber >= LIB94_CORE_SIZE || i.bnumber >= LIB94_CORE_SIZE)
|
||||
return {};
|
||||
|
||||
return w.release();
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
|||
23
makefile
Normal file
23
makefile
Normal file
|
|
@ -0,0 +1,23 @@
|
|||
CPP_ARGS = -std=c++20 -O2 -Wall -Wextra -Iinclude
|
||||
GTKMM_CPP_ARGS = $(shell pkg-config --cflags gtkmm-4.0)
|
||||
GTKMM_LD_ARGS = $(shell pkg-config --libs gtkmm-4.0)
|
||||
|
||||
default: bin/bench
|
||||
|
||||
clean:
|
||||
rm -r obj bin
|
||||
|
||||
bin/bench: obj/bench/main.o obj/bench/bench_window.o obj/bench/core_widget.o obj/lib94.o
|
||||
@mkdir -p $(dir $@)
|
||||
g++ ${CPP_ARGS} $^ ${GTKMM_LD_ARGS} -o $@
|
||||
|
||||
obj/lib94.o: obj/lib94/core.o obj/lib94/executors.o obj/lib94/warrior.o
|
||||
ld -r $^ -o $@
|
||||
|
||||
obj/bench/%.o: bench/%.cpp
|
||||
@mkdir -p $(dir $@)
|
||||
g++ -c ${CPP_ARGS} ${GTKMM_CPP_ARGS} $^ -o $@
|
||||
|
||||
obj/%.o: %.cpp
|
||||
@mkdir -p $(dir $@)
|
||||
g++ -c ${CPP_ARGS} $^ -o $@
|
||||
|
|
@ -1 +0,0 @@
|
|||
g++ -O2 --std=c++20 -DCORE_SIZE=16 test.cpp ../lib94/*.cpp -I ../include -o test
|
||||
|
|
@ -1,10 +0,0 @@
|
|||
;author Standard
|
||||
;name Dwarf
|
||||
|
||||
org 1
|
||||
|
||||
dat 1, 1 ;not 0, 0 so i can see it change
|
||||
|
||||
mov 0-1, 3
|
||||
add.ab #4, 0-1
|
||||
jmp 0-2
|
||||
|
|
@ -1,4 +0,0 @@
|
|||
;author Standard
|
||||
;name Imp
|
||||
|
||||
mov 0, 1
|
||||
|
|
@ -1,85 +0,0 @@
|
|||
#include <lib94/lib94.hpp>
|
||||
#include <iostream>
|
||||
#include <cassert>
|
||||
#include <fstream>
|
||||
#include <chrono>
|
||||
#include <thread>
|
||||
|
||||
const char *const opcodes[] = {
|
||||
"dat", "mov", "add", "sub",
|
||||
"mul", "div", "mod", "jmp",
|
||||
"jmz", "jmn", "djn", "seq",
|
||||
"sne", "slt", "spl", "nop"
|
||||
};
|
||||
|
||||
const char *const modifiers[] = {
|
||||
"a ", "b ", "ab", "ba", "f ", "x ", "i "
|
||||
};
|
||||
|
||||
const char *modes = "#$*@{<}>";
|
||||
|
||||
int main(int argc, const char **argv) {
|
||||
assert(argc > 1);
|
||||
|
||||
seed_prng(time(0));
|
||||
|
||||
std::vector<const warrior *> ws;
|
||||
|
||||
for (int i = 1; i < argc; ++i) {
|
||||
std::string source;
|
||||
std::ifstream f(argv[i]);
|
||||
std::getline(f, source, '\0');
|
||||
f.close();
|
||||
|
||||
auto result = compile_warrior(source);
|
||||
if (std::holds_alternative<std::string>(result)) {
|
||||
std::cout << "Error in " << argv[i] << ": " << std::get<std::string>(result) << std::endl;
|
||||
return 0;
|
||||
}
|
||||
|
||||
ws.push_back(std::get<warrior *>(result));
|
||||
}
|
||||
|
||||
std::vector<number_t> wps;
|
||||
wps.resize(ws.size());
|
||||
|
||||
clear_core({.op = DAT, .mod = F, .amode = DIRECT, .bmode = DIRECT, .anumber = 0, .bnumber = 0});
|
||||
init_round(ws);
|
||||
|
||||
while (true) {
|
||||
for (int i = 0; i < ws.size(); ++i)
|
||||
if (get_processes(ws[i]).size() == 0)
|
||||
wps[i] = -1;
|
||||
else
|
||||
wps[i] = get_next_process(ws[i]);
|
||||
|
||||
auto mod = get_modified_addresses();
|
||||
|
||||
printf("\x1b[H\x1b[2J");
|
||||
|
||||
for (int a = 0; a < CORE_SIZE; ++a) {
|
||||
const instruction &i = get_instruction(a);
|
||||
|
||||
printf("%d: %s.%s %c%d, %c%d",
|
||||
a, opcodes[i.op], modifiers[i.mod],
|
||||
modes[i.amode], i.anumber,
|
||||
modes[i.bmode], i.bnumber);
|
||||
|
||||
if (mod.contains(a))
|
||||
printf(" *");
|
||||
|
||||
for (int w = 0; w < ws.size(); ++w)
|
||||
if (a == wps[w])
|
||||
printf(" < %s", ws[w]->name.c_str());
|
||||
|
||||
putchar('\n');
|
||||
}
|
||||
|
||||
std::this_thread::sleep_for(std::chrono::milliseconds(250));
|
||||
|
||||
clear_modified_addresses();
|
||||
single_step();
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
20
warriors/big-nothing.red
Normal file
20
warriors/big-nothing.red
Normal file
|
|
@ -0,0 +1,20 @@
|
|||
;author blah
|
||||
;name big-nothing
|
||||
|
||||
start:
|
||||
nop
|
||||
nop
|
||||
nop
|
||||
nop
|
||||
nop
|
||||
nop
|
||||
nop
|
||||
nop
|
||||
nop
|
||||
nop
|
||||
nop
|
||||
nop
|
||||
nop
|
||||
nop
|
||||
nop
|
||||
jmp start
|
||||
6
warriors/dwarf.red
Normal file
6
warriors/dwarf.red
Normal file
|
|
@ -0,0 +1,6 @@
|
|||
;author standard
|
||||
;name dwarf
|
||||
|
||||
mov 0-1, 3
|
||||
add.ab #4, 0-1
|
||||
jmp 0-2
|
||||
4
warriors/imp.red
Normal file
4
warriors/imp.red
Normal file
|
|
@ -0,0 +1,4 @@
|
|||
;author standard
|
||||
;name imp
|
||||
|
||||
mov 0, 1
|
||||
5
warriors/splitter.red
Normal file
5
warriors/splitter.red
Normal file
|
|
@ -0,0 +1,5 @@
|
|||
;author blah
|
||||
;name splitter
|
||||
|
||||
spl 0
|
||||
jmp 0-1
|
||||
28
warriors/trap.red
Normal file
28
warriors/trap.red
Normal file
|
|
@ -0,0 +1,28 @@
|
|||
;author benji
|
||||
;name trap
|
||||
|
||||
org start
|
||||
|
||||
trap:
|
||||
spl 1
|
||||
jmp trap
|
||||
|
||||
start:
|
||||
mov.i bomb, bomb + 8
|
||||
add.ab #8, start
|
||||
sub.ab #8, bomb
|
||||
sne.ab #bomb - 8 - start, start
|
||||
jmp core_clear
|
||||
jmp start
|
||||
|
||||
bomb:
|
||||
jmp trap - 8
|
||||
|
||||
core_clear:
|
||||
mov background, background + 1
|
||||
add.ab #1, core_clear
|
||||
jnz.b core_clear, core_clear
|
||||
mov.ab #background + 1 - core_clear, core_clear
|
||||
jmp core_clear
|
||||
|
||||
background:
|
||||
Loading…
Add table
Reference in a new issue