From f08c635390dbca0656895e109e0cc3c2a8bcfeb0 Mon Sep 17 00:00:00 2001 From: "Semere M. Mebrahtom" Date: Thu, 26 Mar 2026 10:54:24 +0100 Subject: [PATCH] refactored main; monitoring & scheduling not done yet --- Makefile | 6 +- coders/codexion.h | 7 ++- coders/main.c | 147 ++++++++++++++++++++++++++-------------------- coders/utils.c | 10 +--- 4 files changed, 93 insertions(+), 77 deletions(-) diff --git a/Makefile b/Makefile index 60a39d5..d79873d 100644 --- a/Makefile +++ b/Makefile @@ -6,8 +6,8 @@ INCLUDES = coders/codexion.h OBJS = $(SRCS:.c=.o) CC = cc -CFLAGS = -Wall -Wextra -Werror -pthread -# CFLAGS = -Wall -Wextra -Werror -pthread -g -fsanitize=thread +# CFLAGS = -Wall -Wextra -Werror -pthread -g +CFLAGS = -Wall -Wextra -Werror -pthread -g -fsanitize=thread all: $(NAME) @@ -27,7 +27,7 @@ $(NAME): $(OBJS) # scheduler test: $(NAME) - ./$(NAME) 2 800 200 100 10 5 0 edf + ./$(NAME) 2 800 200 100 10 3 0 edf test-val: $(NAME) valgrind --leak-check=full --show-leak-kinds=all ./$(NAME) 2 800 200 100 10 5 0 edf diff --git a/coders/codexion.h b/coders/codexion.h index b805b4a..5a37b72 100644 --- a/coders/codexion.h +++ b/coders/codexion.h @@ -13,6 +13,7 @@ #ifndef CODEXION_H # define CODEXION_H # include +# include # include typedef struct s_state t_state; @@ -34,14 +35,14 @@ typedef struct s_args typedef struct s_dongle { - int index; + int idx; pthread_mutex_t lock; long last_used; } t_dongle; typedef struct s_coder { - int coder_id; + int idx; pthread_t thread; t_dongle *right_dongle; t_dongle *left_dongle; @@ -56,7 +57,7 @@ typedef struct s_state t_coder *coders; t_dongle *dongles; long start; - int is_over; + bool is_over; pthread_mutex_t over_mutex; pthread_mutex_t print_mutex; pthread_t monitor; diff --git a/coders/main.c b/coders/main.c index 237dc6c..d473047 100644 --- a/coders/main.c +++ b/coders/main.c @@ -12,6 +12,7 @@ #include "codexion.h" #include +#include #include #include #include @@ -25,10 +26,19 @@ long now(void) return (current.tv_sec * 1000L + current.tv_usec / 1000); } +void print(char *str, t_state *state, int coder_idx) +{ + pthread_mutex_lock(&state->print_mutex); + printf(str, now() - state->start, coder_idx + 1); + pthread_mutex_unlock(&state->print_mutex); +} + void compile_op(t_coder *coder, t_state *state) { - t_dongle *first, *second; - if (coder->right_dongle->index < coder->left_dongle->index) + t_dongle *first; + t_dongle *second; + + if (coder->right_dongle->idx < coder->left_dongle->idx) { first = coder->left_dongle; second = coder->right_dongle; @@ -38,26 +48,15 @@ void compile_op(t_coder *coder, t_state *state) first = coder->right_dongle; second = coder->left_dongle; } - // acquire first dongle pthread_mutex_lock(&first->lock); first->last_used = now(); - pthread_mutex_lock(&state->print_mutex); - printf("%ld %d has taken a dongle\n", now() - state->start, - coder->coder_id); - pthread_mutex_unlock(&state->print_mutex); - // acquire second dongle + print("%ld %d has taken a dongle\n", state, coder->idx); pthread_mutex_lock(&second->lock); second->last_used = now(); - pthread_mutex_lock(&state->print_mutex); - printf("%ld %d has taken a dongle\n", now() - state->start, - coder->coder_id); - pthread_mutex_unlock(&state->print_mutex); + print("%ld %d has taken a dongle\n", state, coder->idx); coder->last_compile = now(); - pthread_mutex_lock(&state->print_mutex); - printf("%ld %d is compiling\n", now() - state->start, coder->coder_id); - pthread_mutex_unlock(&state->print_mutex); + print("%ld %d is compiling\n", state, coder->idx); usleep(state->args.time_to_compile * 1000L); - // release dongles pthread_mutex_unlock(&first->lock); pthread_mutex_unlock(&second->lock); coder->compiles_done += 1; @@ -65,17 +64,13 @@ void compile_op(t_coder *coder, t_state *state) void debug_op(t_coder *coder, t_state *state) { - pthread_mutex_lock(&state->print_mutex); - printf("%ld %d is debugging\n", now() - state->start, coder->coder_id); - pthread_mutex_unlock(&state->print_mutex); + print("%ld %d is debugging\n", state, coder->idx); usleep(state->args.time_to_debug * 1000L); } void refactor_op(t_coder *coder, t_state *state) { - pthread_mutex_lock(&state->print_mutex); - printf("%ld %d is refactoring\n", now() - state->start, coder->coder_id); - pthread_mutex_unlock(&state->print_mutex); + print("%ld %d is refactoring\n", state, coder->idx); usleep(state->args.time_to_refactor * 1000L); } @@ -115,55 +110,79 @@ int cleanup(t_args *args, t_coder *coders, t_dongle *dongles) return (0); } -int main(int argc, char **argv) +t_state init_state(t_args *args) +{ + t_state state; + + state.start = now(); + state.args = *args; + state.is_over = false; + pthread_mutex_init(&state.print_mutex, NULL); + pthread_mutex_init(&state.over_mutex, NULL); + return (state); +} + +t_dongle *init_dongles(t_args *args, t_state *state) { int i; - t_args *args; - t_coder *coders; t_dongle *dongles; - t_state state; + + dongles = malloc(sizeof(t_dongle) * args->number_of_coders); + if (!dongles) + return (NULL); + i = -1; + while (++i < args->number_of_coders) + { + dongles[i].idx = i; + pthread_mutex_init(&dongles[i].lock, NULL); + dongles[i].last_used = state->start - args->dongle_cooldown; + } + return (dongles); +} + +t_coder *init_coders(t_args *args, t_state *state) +{ + t_coder *coders; + int i; + + coders = malloc(sizeof(t_coder) * args->number_of_coders); + if (!coders) + return (NULL); + i = -1; + while (++i < args->number_of_coders) + { + coders[i].idx = i; + coders[i].compiles_done = 0; + coders[i].last_compile = state->start; + coders[i].left_dongle = &state->dongles[i]; + coders[i].right_dongle = &state->dongles[(i + 1) + % args->number_of_coders]; + coders[i].state = state; + } + return (coders); +} + +int main(int argc, char **argv) +{ + int i; + t_args *args; + t_state state; args = parse_arguments(argc - 1, &argv[1]); if (!args) return (cleanup(args, NULL, NULL)); - coders = malloc(sizeof(t_coder) * args->number_of_coders); - dongles = malloc(sizeof(t_dongle) * args->number_of_coders); - if (!coders || !dongles) - return (cleanup(args, coders, dongles)); - state.start = now(); - state.args = *args; - state.is_over = 0; - state.coders = coders; - state.dongles = dongles; - pthread_mutex_init(&state.print_mutex, NULL); - pthread_mutex_init(&state.over_mutex, NULL); - i = 0; - while (i < args->number_of_coders) - { - dongles[i].index = i; - pthread_mutex_init(&dongles[i].lock, NULL); - dongles[i].last_used = state.start - args->dongle_cooldown; - i++; - } - i = 0; - while (i < args->number_of_coders) - { - coders[i].coder_id = i + 1; - coders[i].compiles_done = 0; - coders[i].last_compile = state.start; - coders[i].left_dongle = &dongles[i]; - coders[i].right_dongle = &dongles[(i + 1) % args->number_of_coders]; - coders[i].state = &state; - pthread_create(&coders[i].thread, NULL, run, &coders[i]); - i++; - } + state = init_state(args); + state.dongles = init_dongles(args, &state); + state.coders = init_coders(args, &state); + if (!state.coders || !state.dongles) + return (cleanup(args, state.coders, state.dongles)); + i = -1; + while (++i < args->number_of_coders) + pthread_create(&state.coders[i].thread, NULL, run, &state.coders[i]); pthread_create(&state.monitor, NULL, monitor, &state); - i = 0; - while (i < args->number_of_coders) - { - pthread_join(coders[i].thread, NULL); - i++; - } + i = -1; + while (++i < args->number_of_coders) + pthread_join(state.coders[i].thread, NULL); pthread_join(state.monitor, NULL); - cleanup(args, coders, dongles); + cleanup(args, state.coders, state.dongles); } diff --git a/coders/utils.c b/coders/utils.c index 291b463..b222fc3 100644 --- a/coders/utils.c +++ b/coders/utils.c @@ -38,18 +38,14 @@ t_args *parse_arguments(int count, char **args) data = malloc(sizeof(t_args)); if (!data) return (NULL); - i = 0; - while (i < 7) + i = -1; + while (++i < 7) { if (!isnumeric(args[i])) return (NULL); args_int[i] = atoi(args[i]); - i++; } - if (!strcmp(args[7], "fifo")) - data->scheduler = "fifo"; - else if (!strcmp(args[7], "edf")) - data->scheduler = "edf"; + data->scheduler = args[7]; data->number_of_coders = args_int[0]; data->time_to_burnout = args_int[1]; data->time_to_compile = args_int[2];