From f8c0dc54e36cc201c657aa12e5a22029b092e1bc Mon Sep 17 00:00:00 2001 From: Aargh Rai Date: Mon, 13 Jul 2026 21:58:18 +0530 Subject: restructed all the files + uci done now also broke the symbol analyser in the process, i didn't help much, i had to pull out the pen & paper, but it made a cool graph never the less multithreading was a pain! but it got it in the end fixed the structs naming convention, if it's used outside by other files, it's typedeffed, otherwise it's not fixed the recursive imports issued i had in go_args*, where i was casting it to void* in uci to make it work now response.c doesn't deal with ipc, really happy with that change now every single thing has its own responsibility --- src/ipc/engine_message.c | 127 +++++++++++++++++++++++++++++++++++++++++++++++ src/ipc/go_args.c | 19 +++++++ src/ipc/moves.c | 23 +++++++++ src/ipc/state.c | 41 +++++++++++++++ src/ipc/threads.c | 8 +++ 5 files changed, 218 insertions(+) create mode 100644 src/ipc/engine_message.c create mode 100644 src/ipc/go_args.c create mode 100644 src/ipc/moves.c create mode 100644 src/ipc/state.c create mode 100644 src/ipc/threads.c (limited to 'src/ipc') diff --git a/src/ipc/engine_message.c b/src/ipc/engine_message.c new file mode 100644 index 0000000..76814f4 --- /dev/null +++ b/src/ipc/engine_message.c @@ -0,0 +1,127 @@ +#include "ipc/engine_message.h" +#include +#include + +atomic_flag handler_busy; + +void engine_message_handler_init(engine_message_handler_t *handle) { + engine_message_t *message = calloc(sizeof(*message), 1); + + engine_message_init(message); + + handle->oldest_valid = message; + handle->newest_valid = message; + handle->count = 1; + handle->pushed_count = 0; + handle->popped_count = 0; +} + +void engine_message_handler_acquire(engine_message_handler_t *handle) { + while (atomic_flag_test_and_set(&handler_busy)); +} + +void engine_message_handler_release(engine_message_handler_t *handle) { + atomic_flag_clear(&handler_busy); +} + +bool engine_message_handler_can_pop(engine_message_handler_t *handle) { + assert(handle != NULL); + engine_message_handler_acquire(handle); + if (handle->count == 0) { + engine_message_handler_release(handle); + return false; + } + if (handle->oldest_valid == NULL) { + printf("%d\n", handle->count); + } + bool output = engine_message_is_ready(handle->oldest_valid); + engine_message_handler_release(handle); + return output; +} + +engine_message_t *engine_message_handler_pop( + engine_message_handler_t *handle +) { + assert(handle != NULL); + engine_message_handler_acquire(handle); + + engine_message_t *output = handle->oldest_valid; + + handle->oldest_valid = handle->oldest_valid->next; + handle->count--; + handle->popped_count++; + + engine_message_handler_release(handle); + return output; +} + +engine_message_t *engine_message_handler_push( + engine_message_handler_t *handle +) { + assert(handle != NULL); + engine_message_t *output = calloc(sizeof(*output), 1); + engine_message_init(output); + + engine_message_handler_acquire(handle); + + if (handle->count > 0) { + handle->newest_valid->next = output; + } + handle->newest_valid = output; + if (handle->count == 0) { + handle->oldest_valid = output; + } + handle->count++; + handle->pushed_count++; + + engine_message_handler_release(handle); + + return output; + +} +void engine_messages_init(engine_messages_t *messages) { + assert(messages != NULL); + // idc, i don't want to exceed 10 threads anyway + messages->data = calloc(sizeof(*messages->data), 10); + for (int i = 0; i < 10; i++) { + messages->data[i] = malloc(sizeof(*messages->data[i])); + engine_message_handler_init(messages->data[i]); + } + messages->count = 0; + messages->capacity = 10; +} + +void engine_messages_refresh(engine_messages_t *messages) { + assert(messages != NULL); + for (int i = 0; i < 10; i++) { + messages->data[i] = malloc(sizeof(*messages->data[i])); + engine_message_handler_init(messages->data[i]); + } + messages->count = 0; + messages->capacity = 10; +} + +void engine_message_mark_ready(engine_message_t *message) { + atomic_store(&message->ready, 1); +} + +bool engine_message_is_ready(engine_message_t *message) { + return atomic_load(&message->ready) == 1; +} + +void engine_messages_deinit(engine_messages_t *messages) { + assert(messages != NULL); + free(messages->data); +} + +void engine_message_init(engine_message_t *message) { + assert(message != NULL); + message->ready = 0; + ipc_moves_init(&message->pv); +} + +void engine_message_deinit(engine_message_t *message) { + assert(message != NULL); + ipc_moves_deinit(&message->pv); + free(message); +} diff --git a/src/ipc/go_args.c b/src/ipc/go_args.c new file mode 100644 index 0000000..50f4b72 --- /dev/null +++ b/src/ipc/go_args.c @@ -0,0 +1,19 @@ +#include "ipc/go_args.h" +#include + +bool should_continue(engine_message_t *message, go_args_t *go) { + int depth; + int nodes; + int mate; + if (go->depth && (go->depth <= message->depth)) { + return false; + } + if (go->nodes && (go->nodes <= message->nodes)) { + message->node_limit = true; + return false; + } + if (go->mate && message->mate && (go->mate >= message->mate)) { + return false; + } + return true; +} diff --git a/src/ipc/moves.c b/src/ipc/moves.c new file mode 100644 index 0000000..acd7085 --- /dev/null +++ b/src/ipc/moves.c @@ -0,0 +1,23 @@ +#include "ipc/moves.h" +#include + +void ipc_moves_init(ipc_moves_t *moves) { + moves->data = malloc(sizeof(ipc_move_t) * 50); + moves->count = 0; + moves->capacity = 50; +} + +void ipc_moves_deinit(ipc_moves_t *moves) { + free(moves->data); +} + +void add_ipc_move(ipc_moves_t *moves, ipc_move_t move) { + if (moves->count + 1 > moves->capacity) { + moves->capacity += 50; + moves->data = realloc( + moves->data, + moves->capacity * sizeof(ipc_move_t) + ); + } + moves->data[moves->count++] = move; +} diff --git a/src/ipc/state.c b/src/ipc/state.c new file mode 100644 index 0000000..02ba38b --- /dev/null +++ b/src/ipc/state.c @@ -0,0 +1,41 @@ +#include +#include + +#define IPC_INTERNAL +#include "ipc/state.h" + +void ipc_state_init(ipc_state_t *state) { + // done by main.c in the loop + // engine_messages_init(&state->engine_messages); + uci_state_init(&state->uci_state); + state->from_position = (position_t) {0}; + ipc_moves_init(&state->moves); + state->uci_state.moves = &state->moves; + atomic_init(&state->event, EVENT_INIT); +} + +void ipc_state_deinit(ipc_state_t *state) { + engine_messages_deinit(&state->engine_messages); + uci_state_deinit(&state->uci_state); + ipc_moves_deinit(&state->moves); +} + +void ipc_state_game_reset(ipc_state_t *state) { + state->from_position = (position_t) {0}; + state->moves.count = 0; +} + +void ipc_state_wait_for_event(ipc_state_t *state, size_t event) { + assert(event < EVENTS_COUNT); + while (!ipc_state_is_event(state, event)); +} + +bool ipc_state_is_event(ipc_state_t *state, size_t event) { + assert(event < EVENTS_COUNT); + return atomic_load(&state->event) == event; +} + +void ipc_state_set_event(ipc_state_t *state, size_t event) { + assert(event < EVENTS_COUNT); + atomic_store(&state->event, event); +} diff --git a/src/ipc/threads.c b/src/ipc/threads.c new file mode 100644 index 0000000..9ed04de --- /dev/null +++ b/src/ipc/threads.c @@ -0,0 +1,8 @@ +#include "ipc/threads.h" + +void threads_link(struct threads *handler, ipc_state_t *ipc_state) { + handler->engine_messages = &ipc_state->engine_messages; + handler->go_args = &ipc_state->uci_state.go_args; + handler->position = &ipc_state->uci_state.position; +} + -- cgit v1.2.3