diff --git a/Makefile b/Makefile index 1d5cc68..a566609 100644 --- a/Makefile +++ b/Makefile @@ -20,120 +20,124 @@ # along with this program. If not, see . # #=----------------------------------------------------------------------------=# -CCOPTS=-pthread -Wall -g -Os -I/usr/include/libxml2 -LDFLAGS= -lc -lpthread -lxml2 +.PHONY: all clean install run build_system +.DELETE_ON_ERROR: $(BINDIR)/gem-graph-server +.DEFAULT_GOAL := all + +# +# Color codes +# +CL='\033[0;32m' +CL2='\033[1;36m' +CL3='\033[0m' +NC='\033[1;37m' + +# +# Variables & constants +# +NTHREADS= $(shell nproc) + +CC=gcc +WARNINGS= -Wall +DEBUG= -ggdb -fno-omit-frame-pointer -fdiagnostics-color=always -fsanitize=bounds -fstack-check + #-fsanitize=address \ + #-fsanitize=pointer-compare -fsanitize=pointer-subtract \ + #-fsanitize=leak -fsanitize=undefined -fsanitize=null -fsanitize=bounds +OPTIMIZE= -O3 +INCLUDE= $(shell pkg-config --cflags glib-2.0 libxml-2.0 gtk4) +LIBS= $(shell pkg-config --libs glib-2.0 libxml-2.0 gtk4) -lGL -lGLU -lm -lepoxy -lX11 -lGLEW BINDIR=bin -INCDIR=include +BUILDDIR=build SRCDIR=src -DEBDIR=debian +#vpath %.c $(SRCDIR) -SERVEROBJ= $(BINDIR)/scheduler.o $(BINDIR)/server.o $(BINDIR)/worker.o \ - $(BINDIR)/centers.o $(BINDIR)/cmds.o $(BINDIR)/model.o \ - $(BINDIR)/main.o $(BINDIR)/arrows.o $(BINDIR)/parsing.o -CLIOBJ= $(BINDIR)/cli.o - -SRCS=$(patsubst $(BINDIR)/%.o,$(SRCDIR)/%.c,$(SERVEROBJ)) \ - $(patsubst $(BINDIR)/%.o,$(SRCDIR)/%.c,$(CLIOBJ)) - -DEPS=$(patsubst $(BINDIR)/%.o,$(BINDIR)/%.d,$(SERVEROBJ)) \ - $(patsubst $(BINDIR)/%.o,$(BINDIR)/%.d,$(CLIOBJ)) +SOURCES= $(shell find $(SRCDIR) -maxdepth 1 -type f -name "*.c") +BUILDBINS=$(patsubst %.c,$(BUILDDIR)/%.o,$(SOURCES)) +BUILDDEPS=$(patsubst %.c,$(BUILDDIR)/%.d,$(SOURCES)) -.DEFAULT_GOAL:= all -.PHONY: all clean deb tests install run run-cli run-tests dependencies +-include /etc/os-release -# ---- Dependencies enumeration ---------------------------------------------- # +# +# Directories +# +$(BUILDDIR): + @mkdir -p $@ + @echo -e ${CL2}[$@] ${CL}folder generated.${CL3} -dependencies: $(DEPS) +$(BINDIR): + @mkdir -p $@ + @echo -e ${CL2}[$@] ${CL}folder generated.${CL3} -$(BINDIR)/%.d: $(BINDIR)/%.o $(SRCDIR)/%.c - @$(CC) $(CFLAGS) -MM -MT $< $(word 2,$^) -MF $@ +# +# Dependencies +# +-include $(BUILDDEPS) -# ---- Tests enumeration ----------------------------------------------------- # -TEST_SCHEDULER=$(BINDIR)/tests/centers -TESTS=$(TEST_SCHEDULER) +$(BUILDDIR)/%.d: %.c | $(BUILDDIR) + @mkdir -p $(shell dirname $@) + @$(CC) -MM -MT $(@:%.d=%.o) -MF $@ $< + @echo -e ${CL2}[$@] ${CL}dependencies generated.${CL3} -$(BINDIR)/tests/centers: $(SRCDIR)/tests/centers.c - @echo "Compiling $<" - @$(CC) $(CCINCLUDES) $(CCOPTS) $(CCFLAGS) $(LDFLAGS) -o $@ $< +# +# Compilation +# +$(BINDIR)/gem-graph-server: $(BUILDBINS) | $(BINDIR) + @$(CC) -o $@ $(WARNINGS) $(DEBUG) $(OPTIMIZE) $^ $(INCLUDE) $(LIBS) + @echo -e ${CL2}[$@] ${CL}built.${CL3} -# ---- General recipes ------------------------------------------------------- # -$(BINDIR)/%.o: $(SRCDIR)/%.c - @echo "Compiling $<" - @$(CC) $(CCINCLUDES) $(CCOPTS) $(CCFLAGS) -c -o $@ $< +$(BUILDDIR)/%.o: %.c | $(BUILDDIR) + @mkdir -p $(shell dirname $@) + @$(CC) $(WARNINGS) $(DEBUG) $(OPTIMIZE) $(INCLUDE) -c $< -o $@ + @echo -e ${CL2}[$@] ${CL}compiled.${CL3} -# ---- Main recipe ----------------------------------------------------------- # -$(BINDIR)/main.o: $(SRCDIR)/main.c - @echo "Compiling $<" - @$(CC) $(CCINCLUDES) $(CCOPTS) $(CCFLAGS) -c -o $@ $< -$(BINDIR)/gem-graph-server: $(SERVEROBJ) - @echo "Building program to $@" - @$(CC) -o $@ $(SERVEROBJ) $(LDFLAGS) - @echo "Success!" - -$(BINDIR)/gem-graph-ctl: $(CLIOBJ) - @echo "Building program to $@" - @$(CC) -o $@ $(CLIOBJ) $(LDFLAGS) - @echo "Success!" - -# ---- Misc recipes ---------------------------------------------------------- # +# +# Virtual recipes +# clean: - -rm -f $(SRCDIR)/*.o $(BINDIR)/* $(BINDIR)/tests/* *.deb + @rm -rf $(BINDIR) + @rm -rf $(BUILDDIR) + @echo -e ${CL2}[$@] ${CL}done.${CL3} -all: dependencies $(BINDIR)/gem-graph-server $(BINDIR)/gem-graph-ctl - -tests: $(TESTS) - -# ---- Build debian package -------------------------------------------------- # -$(BINDIR)/gem-graph-server.deb: all $(DEBDIR)/control \ - $(DEBDIR)/conffiles \ - $(DEBDIR)/etc/server.conf \ - $(DEBDIR)/copyright - mkdir -p gem-graph-server/usr/bin - mkdir -p gem-graph-server/var/lib/gem-graph-server/models - mkdir -p gem-graph-server/var/lib/gem-graph-server/users - mkdir -p gem-graph-server/etc/gem-graph-server - mkdir -p gem-graph-server/usr/share/doc/gem-graph-server - mkdir -p gem-graph-server/DEBIAN - cp $(DEBDIR)/control gem-graph-server/DEBIAN/control - cp $(DEBDIR)/conffiles gem-graph-server/DEBIAN/conffiles - cp $(DEBDIR)/etc/* gem-graph-server/etc/gem-graph-server - cp $(BINDIR)/gem-graph-server gem-graph-server/usr/bin - cp $(BINDIR)/gem-graph-ctl gem-graph-server/usr/bin - cp $(DEBDIR)/copyright \ - gem-graph-server/usr/share/doc/gem-graph-server/copyright - dpkg-deb --build gem-graph-server - rm -rf gem-graph-server - -deb: $(BINDIR)/gem-graph-server.deb - -# ---- Builder will call this to install the application before running ------ # install: echo "Installing is not supported" -# ---- Builder uses this target to run the application ----------------------- # -run: all - @bin/gem-graph-server -C debian/etc -M debian/var/models \ - -U debian/var/users -run-gdb: all +build_system: + @echo -e ${CL2}[$@] ${CL}building...${CL3} + @make $(BINDIR)/gem-graph-server -j $(NTHREADS) + @echo -e ${CL2}[$@] ${CL}done.${CL3} + +run: build_system + @echo -e ${CL2}[$@] ${CL}executing...${CL3} @gdb bin/gem-graph-server \ -ex "set args -C debian/etc -M debian/var/models -U debian/var/users" + @echo -e ${CL2}[$@] ${CL}done.${CL3} -run-valgrind: all +debug: build_system + @echo -e ${CL2}[$@] ${CL}executing...${CL3} + @gdb $(BINDIR)/gem-graph-server + @echo -e ${CL2}[$@] ${CL}done.${CL3} + +valgrind: build_system + @echo -e ${CL2}[$@] ${CL}executing...${CL3} @valgrind --leak-check=full --show-leak-kinds=all -s \ bin/gem-graph-server -C debian/etc -M debian/var/models \ -U debian/var/users + @echo -e ${CL2}[$@] ${CL}done.${CL3} -run-both: all +run-both: build_system + @echo -e ${CL2}[$@] ${CL}executing...${CL3} @bin/gem-graph-server -C debian/etc -M debian/var/models \ -U debian/var/users & sleep 1 && bin/gem-graph-ctl -run-server: all + @echo -e ${CL2}[$@] ${CL}done.${CL3} +run-server: build_system + @echo -e ${CL2}[$@] ${CL}executing...${CL3} @bin/gem-graph-server -C debian/etc -M debian/var/models \ -U debian/var/users -run-cli: all - @bin/gem-graph-ctl -run-tests: tests - @bin/tests/scheduler + @echo -e ${CL2}[$@] ${CL}done.${CL3} + +all: build_system + @echo -e ${CL2}[$@] ${CL}done.${CL3} diff --git a/bin/.placeholder b/bin/.placeholder deleted file mode 100644 index e69de29..0000000 diff --git a/bin/tests/.placeholder b/bin/tests/.placeholder deleted file mode 100644 index e69de29..0000000 diff --git a/debian/conffiles b/debian/conffiles deleted file mode 100644 index 39f0001..0000000 --- a/debian/conffiles +++ /dev/null @@ -1 +0,0 @@ -/etc/gem-graph-server/server.conf diff --git a/debian/control b/debian/control deleted file mode 100644 index 8341870..0000000 --- a/debian/control +++ /dev/null @@ -1,10 +0,0 @@ -Package: gem-graph-server -Version: 0.0.1 -Section: custom -Priority: optional -Depends: libxml2 -Architecture: amd64 -Essential: no -Installed-Size: 112760 -Maintainer: Libre en Communs (contact@a-lec.org) -Description: The wonderful gem-graph computation server diff --git a/debian/copyright b/debian/copyright deleted file mode 100644 index 60bafbd..0000000 --- a/debian/copyright +++ /dev/null @@ -1,13 +0,0 @@ -This is a packacked upstream version of gem-graph-server - -The sources may be found at . - -Copyright © 2021 Libre en Communs (contact@a-lec.org) - - This program is free software: you can redistribute it and/or modify - it under the terms of the GNU Affero General Public License as - published by the Free Software Foundation, either version 3 of the - License, or (at your option) any later version. - - You should have received a copy of the GNU Affero General Public License - along with this program. If not, see . diff --git a/debian/etc/server.conf b/debian/etc/server.conf deleted file mode 100644 index 7cb97ca..0000000 --- a/debian/etc/server.conf +++ /dev/null @@ -1,2 +0,0 @@ -# CECI EST UN FICHIER DE CONFIGURATION -server_enabled=true diff --git a/debian/var/models/.placeholder b/debian/var/models/.placeholder deleted file mode 100644 index e69de29..0000000 diff --git a/debian/var/models/example_0.2.xml b/debian/var/models/example_0.2.xml deleted file mode 100644 index 849e357..0000000 --- a/debian/var/models/example_0.2.xml +++ /dev/null @@ -1,111 +0,0 @@ - - - - - - Modèle de test - - Gaston Lagaffe - - 2 - - 1629830000 - - 1.0 - - Ref - - - - - - 0 - 9 - - - - - 1 - - 3 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/debian/var/models/schemas/.placeholder b/debian/var/models/schemas/.placeholder deleted file mode 100644 index e69de29..0000000 diff --git a/debian/var/models/schemas/model_0.2.xmls b/debian/var/models/schemas/model_0.2.xmls deleted file mode 100644 index a4f255d..0000000 --- a/debian/var/models/schemas/model_0.2.xmls +++ /dev/null @@ -1,199 +0,0 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/debian/var/users/.placeholder b/debian/var/users/.placeholder deleted file mode 100644 index e69de29..0000000 diff --git a/include/arrows.h b/include/arrows.h index ef887ff..27e9e74 100644 --- a/include/arrows.h +++ b/include/arrows.h @@ -27,33 +27,4 @@ /* -------------------------------------------------------------------------- */ -static inline int ArrowsInitLock(ArrowArray_t *arrowArray) -{ - return pthread_spin_init(&arrowArray->lock, PTHREAD_PROCESS_SHARED); -} -static inline int ArrowsDestroyLock(ArrowArray_t *arrowArray) -{ - return pthread_spin_destroy(&arrowArray->lock); -} - -static inline int ArrowsAcquireLock(ArrowArray_t *arrowArray) -{ - return pthread_spin_lock(&arrowArray->lock); -} - -static inline int ArrowsAcquireNonBlockingLock(ArrowArray_t *arrowArray) -{ - return pthread_spin_trylock(&arrowArray->lock); -} - -static inline int ArrowsReleaseLock(ArrowArray_t *arrowArray) -{ - return pthread_spin_unlock(&arrowArray->lock); -} - -Arrow_t *ArrowAdd(Scheduler_t *scheduler, int x, int y, int z, int siteId, - int weight); - -bool ArrowRemove(Scheduler_t *scheduler, int x, int y, int z, int siteId, - int weight); diff --git a/include/base.h b/include/base.h index c348dcf..8dec1f9 100644 --- a/include/base.h +++ b/include/base.h @@ -44,163 +44,4 @@ /* -------------------------------------------------------------------------- */ -struct IntArray_t { - size_t size; - int *space; -} typedef IntArray_t; -struct Arrow_t { - int x; - int y; - int z; - int siteId; - int weight; -} typedef Arrow_t; - -struct ArrowArray_t { - size_t size; - unsigned int freeSlotCount; - Arrow_t **freeSlots; - pthread_spinlock_t lock; - Arrow_t *array; -} typedef ArrowArray_t; - -struct Site_t { - char *label; - int nArrow; - Arrow_t *arrowsPtr; -} typedef Site_t; - -struct SpaceUnit_t { - int nSite; - char *label; - Site_t *sites; -} typedef SpaceUnit_t; - -struct Space_t { - int xMax; - int yMax; - int zMax; - size_t size; - SpaceUnit_t *space; -} typedef Space_t; - -/* -------------------------------------------------------------------------- */ - -// -// Scheduler -// -struct Scheduler_t { - pthread_t id; - bool pleaseStop; - Space_t *globalDrawingSpace; - IntArray_t *conditionTree; - ArrowArray_t *arrowArray; - int nMaxThread; - int nMaxCycles; - int ruleRadius; -} typedef Scheduler_t; - -/* -------------------------------------------------------------------------- */ - -// -// Local threads -// -struct Center_t { - int x; - int y; - int z; - struct Center_t *next; - struct Center_t *prev; -} typedef Center_t; - -struct Worker_t { - pthread_t id; - Center_t *localWorkAreaCenter; - Space_t *globalDrawingSpace; - IntArray_t *conditionTree; // XXX - ArrowArray_t *arrowArray; - bool pleaseStop; - bool terminated; - int returnValue; -} typedef Worker_t; - -/* -------------------------------------------------------------------------- */ - -// -// Server -// -struct Server_t { - pthread_t id; - bool pleaseStop; - int returnValue; - int sockfd; // Socket file descriptor -} typedef Server_t; - -struct ServerCommunication_t { - pthread_t id; - bool pleaseStop; - Server_t *associatedServer; - int sockfd; // Socket file descriptor - struct sockaddr_in clientAddr; - socklen_t sockLen; -} typedef ServerCommunication_t; - -/* -------------------------------------------------------------------------- */ - -// -// Supervisor -// -struct Supervisor_t { - pthread_t id; - bool pleaseStop; - int *workerCreationOccurency; // XXX ??? -} typedef Supervisor_t; - -/* -------------------------------------------------------------------------- */ - -// -// Model -// -struct Model_t { - // Identity - int id; - bool validated; // true if model has been correctly parsed - char *name; - char *owner; - char *owner_id; - time_t date; - char *version; - char *filename; - // Parameters - int space_xMax; // TODO more than 3 dimension ? - int space_yMax; - int space_zMax; - int nmaxThread; - int nmaxCycles; - int siteNumber; - // Model instance - bool isRunning; - Scheduler_t *scheduler; - Supervisor_t *supervisor; -} typedef Model_t; - -struct ModelField_t { - bool mandatory; // true if field must exist in file - char tag[25]; // XML tag attached to that field - char *destination; // data destination of that field - size_t size; // max size of data allowed - struct ModelField_t *son; // son in XML tree - struct ModelField_t *next; // brother in XML tree -} typedef ModelField_t; - -/* -------------------------------------------------------------------------- */ - -// -// Parameters -// -struct Parameters_t { - char *configDir; - char *modelDir; - char *userDir; -} typedef Parameters_t; diff --git a/include/centers.h b/include/centers.h index be2c188..27e9e74 100644 --- a/include/centers.h +++ b/include/centers.h @@ -27,12 +27,4 @@ /* -------------------------------------------------------------------------- */ -// -------------------------------------------------------------------------- // -// Add a center to the center list // -// -------------------------------------------------------------------------- // -Center_t *CenterAdd(Center_t *anyCenter, Center_t *newCenter); -// -------------------------------------------------------------------------- // -// Remove a center from the center list // -// -------------------------------------------------------------------------- // -void CenterRemove(Center_t *oldCenter); diff --git a/include/cmds.h b/include/cmds.h index 705f42b..f5e6293 100644 --- a/include/cmds.h +++ b/include/cmds.h @@ -32,19 +32,26 @@ /* -------------------------------------------------------------------------- */ -struct Command_t { +struct command_t { const char *name; char* (*execute)(char*, char**, Server_t*); const char *help; -} typedef Command_t; +} typedef command_t; /* -------------------------------------------------------------------------- */ // // Existing commands // -char *CmdModel(char*, char**, Server_t*); -char *CmdShutdown(char*, char**, Server_t*); -char *CmdHelp(char*, char**, Server_t*); +char *Cmd_model(char*, char**, Server_t*); +char *cmd_shutdown(char*, char**, Server_t*); +char *cmd_help(char*, char**, Server_t*); + +static command_t cmdList[] = +{ + {"help", cmd_help, "Help command"}, + {"model", cmd_model, "Model command"}, + {"shutdown", cmd_shutdown, "Shutdown command"}, +}; /* -------------------------------------------------------------------------- */ diff --git a/include/model.h b/include/model.h index 845b657..42d2946 100644 --- a/include/model.h +++ b/include/model.h @@ -27,6 +27,10 @@ #include #include +#include +#include +#include +#include /* -------------------------------------------------------------------------- */ @@ -47,44 +51,44 @@ // -------------------------------------------------------------------------- // // Model init function (and model discovery) // // -------------------------------------------------------------------------- // -void ModelSystemInit(Parameters_t *parameters); +void model_system_init (parameters_t *parameters); // -------------------------------------------------------------------------- // // Model stopping function // // -------------------------------------------------------------------------- // -void ModelSystemDestroy(void); +void model_system_shutdown (void); // -------------------------------------------------------------------------- // // Load a model ready to execute // // -------------------------------------------------------------------------- // -int ModelLoad(int id); +int model_load (int id); // -------------------------------------------------------------------------- // // Unload a model // // -------------------------------------------------------------------------- // -int ModelUnload(int id); +int model_unload (int id); // -------------------------------------------------------------------------- // // Add a model to the known model list // // -------------------------------------------------------------------------- // -void ModelAddToKnown(Model_t **newModel); +void model_add_to_known (model_t **newModel); // -------------------------------------------------------------------------- // // Print informations about all models (known and loaded) to the client // // -------------------------------------------------------------------------- // -void printModels(char *buf); +void print_models (char *buf); // -------------------------------------------------------------------------- // // Launch a model execution // // -------------------------------------------------------------------------- // -int ModelRun(int id); +int model_run (int id); // -------------------------------------------------------------------------- // // Stop a model execution // // -------------------------------------------------------------------------- // -int ModelStop(int id); +int model_stop (int id); // -------------------------------------------------------------------------- // // Stop and unload all loaded or running model // // -------------------------------------------------------------------------- // -void ModelShutdown(void); +void model_shutdown (void); diff --git a/include/parsing.h b/include/parsing.h index 128a1f9..06e9ec0 100644 --- a/include/parsing.h +++ b/include/parsing.h @@ -36,38 +36,4 @@ /* -------------------------------------------------------------------------- */ -struct ModelParserTableXML_t; -struct ParserTableXML_t -{ - const xmlChar *tag; - int (*parse) (xmlDoc*, - struct ModelParserTableXML_t*, - int currentParser, - xmlNode*); - void *destination; -} typedef ParserTableXML_t; - -struct ModelParserTableXML_t -{ - size_t len; - ParserTableXML_t *table; -} typedef ModelParserTableXML_t; - -/* -------------------------------------------------------------------------- */ - -int parseParentFieldXML(xmlDocPtr, - ModelParserTableXML_t*, - int, - xmlNodePtr); - -int parseTextField(xmlDocPtr, - ModelParserTableXML_t*, - int, - xmlNodePtr); - -int ParseModelXML(Model_t*); - -int ParseModelIdentityXML(Model_t*, Parameters_t*); - -/* -------------------------------------------------------------------------- */ diff --git a/include/scheduler.h b/include/scheduler.h index 83e1a95..0985ce1 100644 --- a/include/scheduler.h +++ b/include/scheduler.h @@ -32,47 +32,40 @@ // -------------------------------------------------------------------------- // // Scheduler init function // // -------------------------------------------------------------------------- // -void SchedInit(Scheduler_t *scheduler); +void sched_init(scheduler_t *scheduler); // -------------------------------------------------------------------------- // // Scheduler content destructor function // // -------------------------------------------------------------------------- // -static inline void SchedContentDestroy(Scheduler_t *scheduler) +static inline void sched_clean (scheduler_t *scheduler) { - if (scheduler) { - if (scheduler->globalDrawingSpace) { - if (scheduler->globalDrawingSpace->space) { - free(scheduler->globalDrawingSpace->space); - scheduler->globalDrawingSpace->space = NULL; - } - free(scheduler->globalDrawingSpace); - scheduler->globalDrawingSpace = NULL; + assert(scheduler); + + if (scheduler->globalDrawingSpace) { + if (scheduler->globalDrawingSpace->space) { + free(scheduler->globalDrawingSpace->space); + scheduler->globalDrawingSpace->space = NULL; } - if (scheduler->arrowArray) { - if (scheduler->arrowArray->array) { - free(scheduler->arrowArray->array); - scheduler->arrowArray->array = NULL; - } - free(scheduler->arrowArray); - scheduler->arrowArray = NULL; + free(scheduler->globalDrawingSpace); + scheduler->globalDrawingSpace = NULL; + } + + if (scheduler->arrowArray) { + if (scheduler->arrowArray->array) { + free(scheduler->arrowArray->array); + scheduler->arrowArray->array = NULL; } + free(scheduler->arrowArray); + scheduler->arrowArray = NULL; } } // -------------------------------------------------------------------------- // // Scheduler destructor function // // -------------------------------------------------------------------------- // -static inline void SchedDestroy(Scheduler_t *scheduler) +static inline void sched_shutdown (scheduler_t *scheduler) { - if (scheduler) { - free(scheduler); - } -} - -// -------------------------------------------------------------------------- // -// Scheduler wait function // -// -------------------------------------------------------------------------- // -static inline void SchedWait(Scheduler_t *scheduler) -{ - pthread_join(scheduler->id, NULL); + assert(scheduler); + free(scheduler); + scheduler = NULL; } diff --git a/include/server.h b/include/server.h index 203938d..92e53a3 100644 --- a/include/server.h +++ b/include/server.h @@ -37,12 +37,4 @@ // -------------------------------------------------------------------------- // // Server init function // // -------------------------------------------------------------------------- // -void ServerInit(Server_t *server); - -// -------------------------------------------------------------------------- // -// Server wait function // -// -------------------------------------------------------------------------- // -static inline void ServerWait(Server_t *server) -{ - pthread_join(server->id, NULL); -} +void server_init (server_t *server); diff --git a/include/supervisor.h b/include/supervisor.h index 6605c87..144d296 100644 --- a/include/supervisor.h +++ b/include/supervisor.h @@ -30,19 +30,12 @@ // -------------------------------------------------------------------------- // // Supervisor init function // // -------------------------------------------------------------------------- // -void SupervisorInit(Supervisor_t *supervisor); +void superv_init (supervisor_t *supervisor); // -------------------------------------------------------------------------- // // Supervisor destructor function // // -------------------------------------------------------------------------- // -static inline void SupervisorDestroy(Supervisor_t *supervisor) +static inline void superv_destroy (supervisor_t *supervisor) { -} - -// -------------------------------------------------------------------------- // -// Supervisor wait function // -// -------------------------------------------------------------------------- // -static inline void SupervisorWait(Supervisor_t *supervisor) -{ - pthread_join(supervisor->id, NULL); + ; } diff --git a/include/terminal.h b/include/terminal.h index 436e6b1..c897e49 100644 --- a/include/terminal.h +++ b/include/terminal.h @@ -54,14 +54,14 @@ /* -------------------------------------------------------------------------- */ -volatile struct winsize TermWindowSize; +volatile struct winsize termWinSize; /* -------------------------------------------------------------------------- */ // -------------------------------------------------------------------------- // // Get a character code from the keyboard // // -------------------------------------------------------------------------- // -static inline int TermGetch(bool nonBlocking) +static inline int term_getch(bool nonBlocking) { int buf = 0; // old terminal @@ -123,16 +123,16 @@ static inline int TermGetch(bool nonBlocking) // -------------------------------------------------------------------------- // // Get the screen size // // -------------------------------------------------------------------------- // -static inline void TermGetScreenSize(int signum) +static inline void term_get_screensize(int signum) { // Get current terminal size - ioctl(STDOUT_FILENO, TIOCGWINSZ, &TermWindowSize); + ioctl(STDOUT_FILENO, TIOCGWINSZ, &termWinSize); } // -------------------------------------------------------------------------- // // Set cursor location // // -------------------------------------------------------------------------- // -static inline void TermSetCursorLocation(char x, char y) +static inline void term_set_cursor_location(char x, char y) { printf("\x1b[%d;%dH", y, x); } @@ -140,7 +140,7 @@ static inline void TermSetCursorLocation(char x, char y) // -------------------------------------------------------------------------- // // Save cursor location // // -------------------------------------------------------------------------- // -static inline void TermSaveCursorLocation(void) +static inline void term_save_cursor_location(void) { printf(C_SAVE_CURSORPOS); } @@ -148,7 +148,7 @@ static inline void TermSaveCursorLocation(void) // -------------------------------------------------------------------------- // // Restore cursor location // // -------------------------------------------------------------------------- // -static inline void TermRestoreCursorLocation(void) +static inline void term_restore_cursor_location(void) { printf(C_RESTORE_CURSORPOS); } @@ -156,7 +156,7 @@ static inline void TermRestoreCursorLocation(void) // -------------------------------------------------------------------------- // // Move cursor location to the right // // -------------------------------------------------------------------------- // -static inline void TermMoveCursorForward(void) +static inline void term_move_cursor_forward(void) { printf(C_CURSORRIGHT); } @@ -164,7 +164,7 @@ static inline void TermMoveCursorForward(void) // -------------------------------------------------------------------------- // // Move cursor location to the left // // -------------------------------------------------------------------------- // -static inline void TermMoveCursorBackward(void) +static inline void term_move_cursor_backward(void) { printf(C_CURSORLEFT); } @@ -172,10 +172,10 @@ static inline void TermMoveCursorBackward(void) // -------------------------------------------------------------------------- // // Clear screen // // -------------------------------------------------------------------------- // -static inline void TermClearScreen(void) +static inline void term_clear_screen(void) { printf(C_CLEARSCREEN); - TermSetCursorLocation(1,1); + term_set_cursor_location(1,1); fflush(stdout); } diff --git a/include/worker.h b/include/worker.h index c80a144..bee79c6 100644 --- a/include/worker.h +++ b/include/worker.h @@ -30,12 +30,12 @@ // -------------------------------------------------------------------------- // // Worker init function // // -------------------------------------------------------------------------- // -void WorkerInit(Worker_t *worker); +void worker_init(worker_t *worker); // -------------------------------------------------------------------------- // // Worker destructor function // // -------------------------------------------------------------------------- // -static inline void WorkerDestroy(Worker_t *worker) +static inline void worker_destroy(worker_t *worker) { worker->pleaseStop = false; worker->terminated = false; @@ -45,11 +45,3 @@ static inline void WorkerDestroy(Worker_t *worker) free(worker->localWorkAreaCenter); worker->localWorkAreaCenter = NULL; } - -// -------------------------------------------------------------------------- // -// Worker wait function // -// -------------------------------------------------------------------------- // -static inline void WorkerWait(Worker_t *worker) -{ - pthread_join(worker->id, NULL); -} diff --git a/include/xml.h b/include/xml.h deleted file mode 100644 index 4809a57..0000000 --- a/include/xml.h +++ /dev/null @@ -1,35 +0,0 @@ -//=-------------------------------------------------------------------------=// -// XML management tools // -// // -// Copyright © 2021 Libre en Communs (contact@a-lec.org) // -// Copyright © 2021 Adrien Bourmault (neox@a-lec.org) // -// // -// This file is part of gem-graph. // -// // -// This program is free software: you can redistribute it and/or modify // -// it under the terms of the GNU Affero General Public License as // -// published by the Free Software Foundation, either version 3 of the // -// License, or (at your option) any later version. // -// // -// This program is distributed in the hope that it will be useful, // -// but WITHOUT ANY WARRANTY; without even the implied warranty of // -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // -// GNU Affero General Public License for more details. // -// // -// You should have received a copy of the GNU Affero General Public License // -// along with this program. If not, see . // -//=-------------------------------------------------------------------------=// - -#pragma once -#ifndef BASE_H - #include "../include/base.h" -#endif - -/* -------------------------------------------------------------------------- */ - -#include -#include -#include -#include - - diff --git a/manifest.scm b/manifest.scm new file mode 100644 index 0000000..01a3a6d --- /dev/null +++ b/manifest.scm @@ -0,0 +1,26 @@ +;; +;; Dépendances sous GNU Guix +;; + + +(specifications->manifest + (list + "bash" + "coreutils" + "gcc-toolchain" + "pkg-config" + "valgrind" + "findutils" + "gdb" + "make" + "libxml2" + "glu" + "glew" + "glfw" + "cglm" + "libepoxy" + "glib" + "mesa-headers" + "mesa" + ) +) diff --git a/src/arrows.c b/src/arrows.c index d24e219..79f8f7f 100644 --- a/src/arrows.c +++ b/src/arrows.c @@ -25,7 +25,3 @@ /* -------------------------------------------------------------------------- */ - -static inline int location(Space_t *space, int x, int y, int z) { - return x + y * (space->xMax+1) + z * (space->xMax+1) * (space->zMax+1); -} diff --git a/src/centers.c b/src/centers.c index 2eba517..f9fdcdb 100644 --- a/src/centers.c +++ b/src/centers.c @@ -24,31 +24,4 @@ /* -------------------------------------------------------------------------- */ -Center_t *CenterAdd(Center_t *anyCenter, Center_t *newCenter) -{ - if (!newCenter) return NULL; - if (anyCenter->next) { - anyCenter->next->prev = newCenter; - } - newCenter->next = anyCenter->next; - anyCenter->next = newCenter; - newCenter->prev = anyCenter; - return newCenter; -} - -void CenterRemove(Center_t *oldCenter) -{ - register Center_t *prev; - register Center_t *next; - - //printLog("Removing center %p\n", oldCenter); - if (!oldCenter) return; - - prev = oldCenter->prev; - next = oldCenter->next; - - - if (prev) prev->next = oldCenter->next; - if (next) next->prev = oldCenter->prev; -} diff --git a/src/cli.c b/src/cli/cli.c similarity index 100% rename from src/cli.c rename to src/cli/cli.c diff --git a/src/cmds.c b/src/cmds.c index 4940869..c4ea45f 100644 --- a/src/cmds.c +++ b/src/cmds.c @@ -28,195 +28,195 @@ /* -------------------------------------------------------------------------- */ -char *CmdModel(char *buf, char **argv, Server_t *args) -{ - int id, eid; - Model_t *newModel; +/* char *cmd_model(char *buf, char **argv, server_t *args) */ +/* { */ +/* int id, eid; */ +/* model_t *newModel; */ - // invalid use - if (!argv[1]) { - strcat(buf, "{create | delete | load | unload | run | stop | list |" - "info}\n"); - goto CmdModelEnd; - } +/* // invalid use */ +/* if (!argv[1]) { */ +/* strcat(buf, "{create | delete | load | unload | run | stop | list |" */ +/* "info}\n"); */ +/* goto cmd_ModelEnd; */ +/* } */ - if (strcmp(argv[1], "create") == 0) { +/* if (strcmp(argv[1], "create") == 0) { */ - if (!argv[2] || !argv[3]) { - goto createEnd; - } +/* if (!argv[2] || !argv[3]) { */ +/* goto createEnd; */ +/* } */ - if (strncmp(argv[2], "name=", 5) == 0) { +/* if (strncmp(argv[2], "name=", 5) == 0) { */ - if (strncmp(argv[3], "file=", 5) == 0) { - // TODO get the file content (sent by the client) from args +/* if (strncmp(argv[3], "file=", 5) == 0) { */ +/* // TODO get the file content (sent by the client) from args */ - // Creating model - ModelAddToKnown(&newModel); +/* // Creating model */ +/* //XXX ModelAddToKnown(&newModel); */ - // TODO modify model according to things in file +/* // TODO modify model according to things in file */ - // Write name - strcpy(newModel->name, argv[2] + 5); +/* // Write name */ +/* strcpy(newModel->name, argv[2] + 5); */ - // Write filename - strcpy(newModel->filename, argv[3] + 5); +/* // Write filename */ +/* strcpy(newModel->filename, argv[3] + 5); */ - sprintf(buf + strlen(buf), "Model %s created with id %d\n", - newModel->name, newModel->id); - goto CmdModelEnd; +/* sprintf(buf + strlen(buf), "Model %s created with id %d\n", */ +/* newModel->name, newModel->id); */ +/* goto cmd_ModelEnd; */ - } else { - goto createEnd; - } - } else { - goto createEnd; - } +/* } else { */ +/* goto createEnd; */ +/* } */ +/* } else { */ +/* goto createEnd; */ +/* } */ - createEnd: - // invalid use - strcat(buf, "Creates a model structure\n"); - strcat(buf, "Usage: model create name=NAME file=FILENAME\n"); - goto CmdModelEnd; - } +/* createEnd: */ +/* // invalid use */ +/* strcat(buf, "Creates a model structure\n"); */ +/* strcat(buf, "Usage: model create name=NAME file=FILENAME\n"); */ +/* goto cmd_ModelEnd; */ +/* } */ - else if (strcmp(argv[1], "load") == 0) { - if (!argv[2]) { - goto loadEnd; - } +/* else if (strcmp(argv[1], "load") == 0) { */ +/* if (!argv[2]) { */ +/* goto loadEnd; */ +/* } */ - id = (int) strtol(argv[2] + 3, NULL, 10); +/* id = (int) strtol(argv[2] + 3, NULL, 10); */ - if (id == 0 || (eid = ModelLoad(id)) <= 0) { - sprintf(buf + strlen(buf), "Failed to load model id %d\n", id); - goto CmdModelEnd; - } +/* if (id == 0 || (eid = ModelLoad(id)) <= 0) { */ +/* sprintf(buf + strlen(buf), "Failed to load model id %d\n", id); */ +/* goto cmd_ModelEnd; */ +/* } */ - sprintf(buf + strlen(buf), "Model id %d loaded with effective " - "id %d\n", id, eid); - goto CmdModelEnd; - loadEnd: - // invalid use - strcat(buf, "Loads a model structure\n"); - strcat(buf, "Usage: model load id=ID\n"); - goto CmdModelEnd; - } +/* sprintf(buf + strlen(buf), "Model id %d loaded with effective " */ +/* "id %d\n", id, eid); */ +/* goto cmd_ModelEnd; */ +/* loadEnd: */ +/* // invalid use */ +/* strcat(buf, "Loads a model structure\n"); */ +/* strcat(buf, "Usage: model load id=ID\n"); */ +/* goto cmd_ModelEnd; */ +/* } */ - else if (strcmp(argv[1], "unload") == 0) { - if (!argv[2]) { - goto unloadEnd; - } +/* else if (strcmp(argv[1], "unload") == 0) { */ +/* if (!argv[2]) { */ +/* goto unloadEnd; */ +/* } */ - id = (int) strtol(argv[2] + 3, NULL, 10); +/* id = (int) strtol(argv[2] + 3, NULL, 10); */ - if (id == 0 || ModelUnload(id) < 0) { - printErr("Failed to unload model id %d\n", id); - sprintf(buf + strlen(buf), "Failed to unload model id %d\n", id); - goto CmdModelEnd; - } +/* if (id == 0 || ModelUnload(id) < 0) { */ +/* printErr("Failed to unload model id %d\n", id); */ +/* sprintf(buf + strlen(buf), "Failed to unload model id %d\n", id); */ +/* goto cmd_ModelEnd; */ +/* } */ - sprintf(buf + strlen(buf), "Model id %d unloaded\n", id); - goto CmdModelEnd; - unloadEnd: - // invalid use - strcat(buf, "Unloads a model structure\n"); - strcat(buf, "Usage: model unload id=ID\n"); - goto CmdModelEnd; - } +/* sprintf(buf + strlen(buf), "Model id %d unloaded\n", id); */ +/* goto cmd_ModelEnd; */ +/* unloadEnd: */ +/* // invalid use */ +/* strcat(buf, "Unloads a model structure\n"); */ +/* strcat(buf, "Usage: model unload id=ID\n"); */ +/* goto cmd_ModelEnd; */ +/* } */ - else if (strcmp(argv[1], "delete") == 0) { - if (!argv[2]) { - goto deleteEnd; - } - // TODO delete model - deleteEnd: - // invalid use - strcat(buf, "Deletes a model structure\n"); - strcat(buf, "Usage: model delete id=ID\n"); - goto CmdModelEnd; - } +/* else if (strcmp(argv[1], "delete") == 0) { */ +/* if (!argv[2]) { */ +/* goto deleteEnd; */ +/* } */ +/* // TODO delete model */ +/* deleteEnd: */ +/* // invalid use */ +/* strcat(buf, "Deletes a model structure\n"); */ +/* strcat(buf, "Usage: model delete id=ID\n"); */ +/* goto cmd_ModelEnd; */ +/* } */ - else if (strcmp(argv[1], "run") == 0) { - if (!argv[2]) { - goto runEnd; - } +/* else if (strcmp(argv[1], "run") == 0) { */ +/* if (!argv[2]) { */ +/* goto runEnd; */ +/* } */ - id = (int) strtol(argv[2] + 3, NULL, 10); +/* id = (int) strtol(argv[2] + 3, NULL, 10); */ - if (id == 0 || (!ModelRun(id))) { - sprintf(buf + strlen(buf), "Failed to run model id %d\n", id); - goto CmdModelEnd; - } +/* if (id == 0 || (!ModelRun(id))) { */ +/* sprintf(buf + strlen(buf), "Failed to run model id %d\n", id); */ +/* goto cmd_ModelEnd; */ +/* } */ - sprintf(buf + strlen(buf), "Model id %d is running\n", id); - goto CmdModelEnd; - runEnd: - // invalid use - strcat(buf, "Run a model simulation\n"); - strcat(buf, "Usage: model run id=ID\n"); - goto CmdModelEnd; - } +/* sprintf(buf + strlen(buf), "Model id %d is running\n", id); */ +/* goto cmd_ModelEnd; */ +/* runEnd: */ +/* // invalid use */ +/* strcat(buf, "Run a model simulation\n"); */ +/* strcat(buf, "Usage: model run id=ID\n"); */ +/* goto cmd_ModelEnd; */ +/* } */ - else if (strcmp(argv[1], "stop") == 0) { - if (!argv[2]) { - goto stopEnd; - } +/* else if (strcmp(argv[1], "stop") == 0) { */ +/* if (!argv[2]) { */ +/* goto stopEnd; */ +/* } */ - id = (int) strtol(argv[2] + 3, NULL, 10); +/* id = (int) strtol(argv[2] + 3, NULL, 10); */ - if (id == 0 || (!ModelStop(id))) { - sprintf(buf + strlen(buf), "Failed to stop model id %d\n", id); - goto CmdModelEnd; - } +/* if (id == 0 || (!ModelStop(id))) { */ +/* sprintf(buf + strlen(buf), "Failed to stop model id %d\n", id); */ +/* goto cmd_ModelEnd; */ +/* } */ - sprintf(buf + strlen(buf), "Model id %d is running\n", id); - goto CmdModelEnd; - stopEnd: - // invalid use - strcat(buf, "Stop a model simulation\n"); - strcat(buf, "Usage: model stop id=ID\n"); - goto CmdModelEnd; - } +/* sprintf(buf + strlen(buf), "Model id %d is running\n", id); */ +/* goto cmd_ModelEnd; */ +/* stopEnd: */ +/* // invalid use */ +/* strcat(buf, "Stop a model simulation\n"); */ +/* strcat(buf, "Usage: model stop id=ID\n"); */ +/* goto cmd_ModelEnd; */ +/* } */ - else if (strcmp(argv[1], "list") == 0) { - strcat(buf, "You asked for us to list models\n"); - printModels(buf); - } +/* else if (strcmp(argv[1], "list") == 0) { */ +/* strcat(buf, "You asked for us to list models\n"); */ +/* printModels(buf); */ +/* } */ - else if (strcmp(argv[1], "info") == 0) { - if (!argv[2]) { - goto infoEnd; - } - // TODO info model - infoEnd: - // invalid use - strcat(buf, "Print info about a model\n"); - strcat(buf, "Usage: model info id=ID\n"); - goto CmdModelEnd; - } +/* else if (strcmp(argv[1], "info") == 0) { */ +/* if (!argv[2]) { */ +/* goto infoEnd; */ +/* } */ +/* // TODO info model */ +/* infoEnd: */ +/* // invalid use */ +/* strcat(buf, "Print info about a model\n"); */ +/* strcat(buf, "Usage: model info id=ID\n"); */ +/* goto cmd_ModelEnd; */ +/* } */ - // invalid use - else strcat(buf, "{create | delete | load | unload | run | stop | list |" - "info}\n"); +/* // invalid use */ +/* else strcat(buf, "{create | delete | load | unload | run | stop | list |" */ +/* "info}\n"); */ -CmdModelEnd: - return buf; -} +/* cmd_ModelEnd: */ +/* return buf; */ +/* } */ -char *CmdShutdown(char *buf, char **argv, Server_t *args) -{ - args->pleaseStop = true; - strcat(buf, "Server stopping\n"); +/* char *cmd_shutdown(char *buf, char **argv, server_t *args) */ +/* { */ +/* args->pleaseStop = true; */ +/* strcat(buf, "Server stopping\n"); */ - ModelShutdown(); - strcat(buf, "All model shutted down\n"); +/* //XXX ModelShutdown(); */ +/* strcat(buf, "All model shutted down\n"); */ - return buf; -} +/* return buf; */ +/* } */ -char *CmdHelp(char *buf, char **argv, Server_t *args) -{ - strcat(buf, "List of known commands:\n"); +/* char *cmd_help(char *buf, char **argv, server_t *args) */ +/* { */ +/* strcat(buf, "List of known commands:\n"); */ - return buf; -} +/* return buf; */ +/* } */ diff --git a/src/main.c b/src/main.c index 42ded6c..2c004dd 100644 --- a/src/main.c +++ b/src/main.c @@ -26,23 +26,23 @@ /* -------------------------------------------------------------------------- */ -static Server_t *server; +static server_t *server; -static void sigtermHandler(int signum) -{ - server->pleaseStop = true; - printLog("Server stopping\n"); +/* static void sig_term_handler(int signum) */ +/* { */ +/* server->pleaseStop = true; */ +/* printLog("Server stopping\n"); */ - ModelShutdown(); - printLog("All model shutted down\n"); -} +/* //XXX ModelShutdown(); */ +/* printLog("All model shutted down\n"); */ +/* } */ int main(int argc, char **argv) { int options; time_t t; int returnValue = 0; - Parameters_t parameters; + parameters_t parameters; while ((options = getopt(argc, argv, ":C:M:U:")) != -1) { switch (options) { @@ -108,30 +108,30 @@ int main(int argc, char **argv) // Go! printLog("Starting gem-graph-server...\n"); - // Register new interrupt handler - signal(SIGINT, sigtermHandler); - signal(SIGTERM, sigtermHandler); + /* // Register new interrupt handler */ + /* signal(SIGINT, sig_term_handler); */ + /* signal(SIGTERM, sig_term_handler); */ - // Initializing random generator - t = time(&t); - srand((unsigned) t); + /* // Initializing random generator */ + /* t = time(&t); */ + /* srand((unsigned) t); */ - server = calloc(1, sizeof(*server)); + /* server = calloc(1, sizeof(*server)); */ - // Initializing model system - ModelSystemInit(¶meters); + /* // Initializing model system */ + /* model_system_init(¶meters); */ - // Launching server - ServerInit(server); + /* // Launching server */ + /* server_init(server); */ - // Waiting for termination - ServerWait(server); + /* // Waiting for termination */ + /* server_wait(server); */ - // Exiting - returnValue |= server->returnValue; - ModelSystemDestroy(); - free(server); - server = NULL; + /* // Exiting */ + /* returnValue |= server->returnValue; */ + /* ModelSystemDestroy(); */ + /* free(server); */ + /* server = NULL; */ free(parameters.userDir); free(parameters.modelDir); diff --git a/src/model.c b/src/model.c index db08dbd..0070ade 100644 --- a/src/model.c +++ b/src/model.c @@ -25,286 +25,4 @@ #include "../include/arrows.h" #include "../include/scheduler.h" -static Model_t **loadedModel; -static int loadedModelSize; // begins to 1 -static Model_t **knownModel; -static int knownModelSize; // begins to 1 - -Model_t *lastModel; -Model_t **lastModelAddr; - -/* -------------------------------------------------------------------------- */ - -void printModels(char *buf) -{ - sprintf(buf + strlen(buf),"Known models\n"); - for (int i = 0; i <= knownModelSize-1; i++) { - sprintf(buf + strlen(buf), "id: %d, addr: %p, name: %s, date: %lu, " - "owner: %s\n", - knownModel[i]->id, - knownModel[i], - knownModel[i]->name, - knownModel[i]->date, - knownModel[i]->owner - ); - } - - sprintf(buf + strlen(buf), "\nLoaded models\n"); - for (int i = 0; i <= loadedModelSize-1; i++) { - sprintf(buf + strlen(buf), "id: %d, addr: %p, name: %s\n", - loadedModel[i]->id, loadedModel[i], loadedModel[i]->name); - } -} - -int ModelLoad(int id) -{ - if (id <= 0 || id > knownModelSize) { - return -1; - } - - printLog("Loading model id %d (/%d models)...\n", id, knownModelSize); - - - // Creating structure for the Scheduler - knownModel[id-1]->scheduler = - calloc(1, sizeof(*knownModel[id-1]->scheduler)); - - loadedModelSize++; - - loadedModel = - (Model_t**) realloc(loadedModel, loadedModelSize * sizeof(Model_t*)); - - loadedModel[loadedModelSize-1] = knownModel[id-1]; - - // Parse model - ParseModelXML(loadedModel[loadedModelSize-1]); - - return loadedModelSize; -} - -int ModelUnload(int id) -{ - // Destroy scheduler - if (id > loadedModelSize) - return -1; - - SchedContentDestroy(loadedModel[id-1]->scheduler); - - SchedDestroy(loadedModel[id-1]->scheduler); - loadedModel[id-1]->scheduler = NULL; - - // Prevent fragmentation by moving data in the newly freed slot - if (id-1 < loadedModelSize) { - memmove(&loadedModel[id-1], - &loadedModel[id-1] + sizeof(Model_t*), - loadedModelSize - id); - } - - // Decrement loaded model index - loadedModelSize--; - - // Resize loaded model list - loadedModel = - (Model_t**) realloc(loadedModel, loadedModelSize * sizeof(Model_t*)); - - return 0; -} -/* -------------------------------------------------------------------------- */ - -int ModelRun(int id) -{ - if (id <= 0 || id > loadedModelSize) - return -1; - - if (!loadedModel[id-1]->scheduler) - return -2; - - if (loadedModel[id-1]->isRunning) - return -3; - - loadedModel[id-1]->scheduler->nMaxThread = knownModel[id-1]->nmaxThread; - loadedModel[id-1]->scheduler->nMaxCycles = knownModel[id-1]->nmaxCycles; - loadedModel[id-1]->scheduler->pleaseStop = false; - loadedModel[id-1]->isRunning = true; - - SchedInit(loadedModel[id-1]->scheduler); - - printLog("Model %d launched\n", id); - return 0; -} - -int ModelStop(int id) -{ - if (id <= 0 || id > loadedModelSize) { - return -1; - } - if (!loadedModel[id-1]->scheduler) { - return -2; - } - if (!loadedModel[id-1]->isRunning) { - return -3; - } - - // Stop model scheduler - loadedModel[id-1]->scheduler->pleaseStop = true; - printLog("Model %d stop bit set\n", id); - - // Wait for Shceduler to stop - SchedWait(loadedModel[id-1]->scheduler); - - // Disable running bit - loadedModel[id-1]->isRunning = false; - return 0; -} - -/* -------------------------------------------------------------------------- */ - -void ModelAddToKnown(Model_t **newModel) -{ - // increment index - knownModelSize++; - // create socket - knownModel = - (Model_t**) realloc(knownModel, knownModelSize * sizeof(*knownModel)); - // populate socket - knownModel[knownModelSize-1] = calloc(1, sizeof(**knownModel)); - // populate model - knownModel[knownModelSize-1]->id = knownModelSize; - // return value - *newModel = knownModel[knownModelSize-1]; - lastModel = knownModel[knownModelSize-1]; - lastModelAddr = &knownModel[knownModelSize-1]; - - // continue. model population - knownModel[knownModelSize-1]->name = - calloc(1, sizeof(char) * MODEL_STRING_SIZE); - - knownModel[knownModelSize-1]->filename = - calloc(1, sizeof(char) * MODEL_STRING_SIZE); - - knownModel[knownModelSize-1]->owner = - calloc(1, sizeof(char) * MODEL_STRING_SIZE); - - knownModel[knownModelSize-1]->version = - calloc(1, sizeof(char) * MODEL_STRING_SIZE); - - knownModel[knownModelSize-1]->space_xMax = XMAX; - knownModel[knownModelSize-1]->space_yMax = YMAX; - knownModel[knownModelSize-1]->space_zMax = ZMAX; - knownModel[knownModelSize-1]->nmaxThread = MAX_THREAD; - knownModel[knownModelSize-1]->nmaxCycles = MAX_CYCLES; - knownModel[knownModelSize-1]->siteNumber = 0; -} - -void ModelDelete(int id) //XXX fragmentation -{ - // Free a model structure - free(knownModel[id-1]->name); - knownModel[id-1]->name = NULL; - - free(knownModel[id-1]->filename); - knownModel[id-1]->filename = NULL; - - free(knownModel[id-1]->owner); - knownModel[id-1]->owner = NULL; - - free(knownModel[id-1]->version); - knownModel[id-1]->version = NULL; - - free(knownModel[id-1]); - knownModel[id-1] = NULL; -} - -void ModelShutdown(void) -{ - // Stop each model from running - for (int i = 0; i < loadedModelSize; i++) { - ModelStop(i); - ModelUnload(i); - } -} - -/* -------------------------------------------------------------------------- */ - -void ModelSystemInit(Parameters_t *parameters) -{ - struct dirent *modelDirEntry = NULL; - DIR *modelDir = NULL; - Model_t *newModel; - char *extensionPosition; - - loadedModel = calloc(1, sizeof(*loadedModel)); - - knownModel = calloc(1, sizeof(*knownModel)); - - knownModelSize = 0; - loadedModelSize = 0; - - printLog("Model system initiated with folder : %s\n", parameters->modelDir); - - // Open model directory - if ((modelDir = opendir(parameters->modelDir)) <= 0) { - printErr("Could not open %s\n", parameters->modelDir); - ModelSystemDestroy(); - kill(getpid(), SIGTERM); - return; - } - - while ((modelDirEntry = readdir(modelDir)) != NULL) { - if ((extensionPosition = strstr(modelDirEntry->d_name, ".xml"))) { - - // Creating model - ModelAddToKnown(&newModel); - - // Write file path in filename - strncpy(newModel->filename, parameters->modelDir, - strlen(parameters->modelDir)); - // Add a / separator - strcat(newModel->filename - + strlen(parameters->modelDir), - "/"); - // Add the file relative name - strncpy(newModel->filename - + strlen(parameters->modelDir) - + 1, - modelDirEntry->d_name, - strlen(modelDirEntry->d_name)); - - // Write model name - strncpy(newModel->name, modelDirEntry->d_name, - extensionPosition - modelDirEntry->d_name); - - // Ask to parse the new model - if (ParseModelIdentityXML(newModel, parameters) != 0) { - printErr("Deleting invalid model %s from known list\n", - newModel->name); - ModelDelete(newModel->id); - continue; - }; - - // Check model is valid and/or parsed - if (newModel->validated == false) { - printErr("Deleting invalid model %s from known list\n", - newModel->name); - ModelDelete(newModel->id); - continue; - } - - // Succeeded ! - printLog("Loaded model %s\n", newModel->name); - } - } - free(modelDir); -} - -void ModelSystemDestroy(void) -{ - for (int i = 0; i < loadedModelSize; i++) { - ModelDelete(i); - } - free(loadedModel); - loadedModel = NULL; - free(knownModel); - knownModel = NULL; -} diff --git a/src/parsing.c b/src/parsing.c index 35839cb..ec88c89 100644 --- a/src/parsing.c +++ b/src/parsing.c @@ -24,560 +24,4 @@ #include "../include/arrows.h" #include "../include/model.h" -// -------------------------------------------------------------------------- // -// Parsing NOTHING (but yeah that prints) // -// -------------------------------------------------------------------------- // -int parseStubFieldXML (xmlDocPtr doc, - ModelParserTableXML_t *ModelTable, - int currentParser, - xmlNodePtr currentNode) -{ - xmlChar *content, *contentText, *contentValueAttribute; - contentText = xmlNodeListGetString(doc, currentNode->xmlChildrenNode, 1); - contentValueAttribute = xmlGetProp(currentNode, - (xmlChar*)"value"); - - if (contentText) { - content = contentText; - } else if (contentValueAttribute) { - content = contentValueAttribute; - - // Detect children - if (currentNode->xmlChildrenNode) { - printLog("%s (stub) has children\n", - ModelTable->table[currentParser].tag); - } - } - - printLog("%s (stub): %s\n", ModelTable->table[currentParser].tag, - content); - - if (!content) { - xmlFree(contentText); - xmlFree(contentValueAttribute); - return -1; - } - - xmlFree(contentText); - xmlFree(contentValueAttribute); - - return 0; -} - -// -------------------------------------------------------------------------- // -// Parsing an arrow (but yeah that prints) // -// -------------------------------------------------------------------------- // -int parseArrowFieldXML (xmlDocPtr doc, - ModelParserTableXML_t *ModelTable, - int currentParser, - xmlNodePtr currentNode) -{ - Model_t *destination = ModelTable->table[currentParser].destination; - xmlChar *x, *y, *z, *siteId, *weight; - - x = xmlGetProp(currentNode, (xmlChar*)"x"); - y = xmlGetProp(currentNode, (xmlChar*)"y"); - z = xmlGetProp(currentNode, (xmlChar*)"z"); - siteId = xmlGetProp(currentNode, (xmlChar*)"siteId"); - weight = xmlGetProp(currentNode, (xmlChar*)"weight"); - - // Detect children - if (currentNode->xmlChildrenNode) { - printLog("%s (stub) has children\n", - ModelTable->table[currentParser].tag); - } - - printLog("%s: x:%s, y:%s, z:%s\n", ModelTable->table[currentParser].tag, - x, y, z); - - if (!x || !y || !z) { - xmlFree(x); - xmlFree(y); - xmlFree(z); - return -1; - } - - // Create arrow in model - if (destination->scheduler) { - ArrowAdd(destination->scheduler, - atoi((char*)x), atoi((char*)y), atoi((char*)z), - atoi((char*)siteId), atoi((char*)weight)); - } else { - xmlFree(x); - xmlFree(y); - xmlFree(z); - - return -1; - } - - xmlFree(x); - xmlFree(y); - xmlFree(z); - - return 0; -} - -int parseSpaceSizeFieldXML (xmlDocPtr doc, - ModelParserTableXML_t *ModelTable, - int currentParser, - xmlNodePtr currentNode) -{ - xmlChar *x, *y, *z; - Model_t *destination = - (Model_t*)ModelTable->table[currentParser].destination; - - x = xmlGetProp(currentNode, (xmlChar*)"x"); - y = xmlGetProp(currentNode, (xmlChar*)"y"); - z = xmlGetProp(currentNode, (xmlChar*)"z"); - - // Detect children - if (currentNode->xmlChildrenNode) { - printLog("%s (stub) has children\n", - ModelTable->table[currentParser].tag); - } - - printLog("%s: x:%s, y:%s, z:%s\n", ModelTable->table[currentParser].tag, - x, y, z); - - if (!x || !y || !z) { - xmlFree(x); - xmlFree(y); - xmlFree(z); - return -1; - } - - // Store space size - destination->space_xMax = atoi((const char*)x); - destination->space_yMax = atoi((const char*)y); - destination->space_zMax = atoi((const char*)z); - - xmlFree(x); - xmlFree(y); - xmlFree(z); - - return 0; -} - -// -------------------------------------------------------------------------- // -// Parsing a text field // -// -------------------------------------------------------------------------- // -int parseTextFieldXML (xmlDocPtr doc, - ModelParserTableXML_t *ModelTable, - int currentParser, - xmlNodePtr currentNode) -{ - xmlChar *content, *contentText, *contentValueAttribute; - char *destination = (char*)ModelTable->table[currentParser].destination; - - contentText = xmlNodeListGetString(doc, currentNode->xmlChildrenNode, 1); - contentValueAttribute = xmlGetProp(currentNode, - (xmlChar*)"value"); - - if (contentText) { - content = contentText; - } else if (contentValueAttribute) { - content = contentValueAttribute; - - // Detect children - if (currentNode->xmlChildrenNode) { - printLog("%s has children\n", ModelTable->table[currentParser].tag); - } - } - - printLog("%s: %s\n", ModelTable->table[currentParser].tag, - content); - - if (!content) { - xmlFree(contentText); - xmlFree(contentValueAttribute); - return -1; - } - - strcat(destination, " "); - strncpy(destination + strlen(destination), - (char *)content, MODEL_STRING_SIZE - strlen(destination)); - - xmlFree(contentText); - xmlFree(contentValueAttribute); - - return 0; -} - -// -------------------------------------------------------------------------- // -// Parsing an integer field // -// -------------------------------------------------------------------------- // -int parseIntFieldXML (xmlDocPtr doc, - ModelParserTableXML_t *ModelTable, - int currentParser, - xmlNodePtr currentNode) -{ - xmlChar *content, *contentText, *contentValueAttribute; - int *destination = (int*)ModelTable->table[currentParser].destination; - - contentText = xmlNodeListGetString(doc, currentNode->xmlChildrenNode, 1); - contentValueAttribute = xmlGetProp(currentNode, - (xmlChar*)"value"); - - if (contentText) { - content = contentText; - } else if (contentValueAttribute) { - content = contentValueAttribute; - - // Detect children - if (currentNode->xmlChildrenNode) { - printLog("%s has children\n", ModelTable->table[currentParser].tag); - } - } - - printLog("%s: %s\n", ModelTable->table[currentParser].tag, - content); - - if (!content) { - xmlFree(contentText); - xmlFree(contentValueAttribute); - return -1; - } - - *destination = (int)atoi((char*)content); - - xmlFree(content); - return 0; -} - -// -------------------------------------------------------------------------- // -// Parsing a field that contains children fields // -// -------------------------------------------------------------------------- // -int parseParentFieldXML (xmlDocPtr doc, - ModelParserTableXML_t *ModelTable, - int currentParser, - xmlNodePtr currentNode) -{ - printLog("%s parsed\n", - ModelTable->table[currentParser].tag); - - // Getting children content - currentNode = currentNode->xmlChildrenNode; - while (currentNode != NULL) { - for (int i = 0; i < ModelTable->len; i++) { - if ((!xmlStrcmp(currentNode->name, - ModelTable->table[i].tag))) { - ModelTable->table[i].parse(doc, - ModelTable, - i, - currentNode); - break; - } - } - currentNode = currentNode->next; - } - return 0; -} - -// -------------------------------------------------------------------------- // -// Parsing a field that contains children fields with props // -// -------------------------------------------------------------------------- // -int parseParentFieldPropsXML (xmlDocPtr doc, - ModelParserTableXML_t *ModelTable, - int currentParser, - xmlNodePtr currentNode) -{ - xmlChar *id, *date, *author; - // (truc*)destination = (truc*)ModelTable->table[currentParser].destination; - - // Getting field identity - id = xmlGetProp(currentNode, (xmlChar*)"id"); - date = xmlGetProp(currentNode, (xmlChar*)"date"); - author = xmlGetProp(currentNode, (xmlChar*)"author"); - - printLog("%s parsed (id=%s, date=%s, author=%s)\n", - ModelTable->table[currentParser].tag, id, date, author); - - // Getting children content - currentNode = currentNode->xmlChildrenNode; - while (currentNode != NULL) { - for (int i = 0; i < ModelTable->len; i++) { - if ((!xmlStrcmp(currentNode->name, - ModelTable->table[i].tag))) { - ModelTable->table[i].parse(doc, - ModelTable, - i, - currentNode); - break; - } - } - currentNode = currentNode->next; - } - - free(id); - free(date); - free(author); - - return 0; -} - -// -------------------------------------------------------------------------- // -// Preparsing a model file // -// -------------------------------------------------------------------------- // -int ParseModelIdentityXML(Model_t *model, Parameters_t *params) -{ - xmlDocPtr xmlDocument; - xmlNodePtr currentNode; - xmlChar *version = NULL; - xmlSchemaPtr schemPtr; - xmlSchemaValidCtxtPtr schemValidator; - xmlSchemaParserCtxtPtr schemFile; - char *schemPath; - - ParserTableXML_t table[] = - { - // IDENTITY - {(const xmlChar *)"identity", parseParentFieldXML, NULL}, - {(const xmlChar *)"name", parseTextFieldXML, model->name}, - {(const xmlChar *)"owner", parseTextFieldXML, model->owner}, - - // TODO lacking implementation (model side) - {(const xmlChar *)"owner_id", parseStubFieldXML, model->owner_id}, - - {(const xmlChar *)"date", parseIntFieldXML, &model->date}, - {(const xmlChar *)"version", parseTextFieldXML, model->version}, - - // PARAMETERS - {(const xmlChar *)"parameters", parseParentFieldPropsXML, model}, - // MODELIZATION - {(const xmlChar *)"modelization", parseParentFieldXML, model}, - {(const xmlChar *)"max_thread", parseStubFieldXML, model}, - {(const xmlChar *)"max_cycles", parseStubFieldXML, model}, - // SPACE - {(const xmlChar *)"space_param", parseParentFieldXML, model}, - {(const xmlChar *)"dimension", parseStubFieldXML, model}, - {(const xmlChar *)"size", parseSpaceSizeFieldXML, model}, - {(const xmlChar *)"site_multiplicity", parseIntFieldXML, - &model->siteNumber}, - - // TODO lacking implementation (model side) - {(const xmlChar *)"boundaries", parseStubFieldXML, model}, - }; - - ModelParserTableXML_t identityParserTable = - { - LEN(table), - &table[0] - }; - - // Allocating space for schema file path - schemPath = calloc(1, strlen(params->modelDir) - + strlen("/schemas/model_ .xmls")); - - printLog("Preparsing model %s\n", model->name); - - // Opening document - xmlDocument = xmlReadFile(model->filename, NULL, 0); - - if (xmlDocument == NULL) { - printErr("Can't parse model file at '%s'.\n", model->filename); - return -1; - } - - // Getting root from XML model file - currentNode = xmlDocGetRootElement(xmlDocument); - - if (currentNode == NULL) { - printErr("Invalid model file at '%s', document empty !\n", - model->filename); - xmlFreeDoc(xmlDocument); - free(schemPath); - return -2; - } - - // Checking that XML file is actually a model - if (xmlStrcmp(currentNode->name, (const xmlChar *) "gem-graph-model")) { - printErr("Invalid model file at '%s', " - "root node is not !\n", - model->filename); - xmlFreeDoc(xmlDocument); - free(schemPath); - return -3; - } - - // Get gem-graph model version to parse - version = xmlGetProp(currentNode, (xmlChar*)"version"); - // Check version is present - if (!version) { - printErr("Missing version for model %s \n", model->name); - xmlFreeDoc(xmlDocument); - free(schemPath); - return -4; - } else if (strlen((char*)version) > MODEL_STRING_SIZE) { - printErr("Invalid version number for model %s \n", model->name); - free(version); - xmlFreeDoc(xmlDocument); - free(schemPath); - } - printLog("Gem-graph model version %s detected\n", version); - - // Retrieving schema file - sprintf(schemPath, "%s/schemas/model_%s.xmls", params->modelDir, version); - printLog("Loading schema %s\n", schemPath); - - // Loading schema file - schemFile = xmlSchemaNewParserCtxt(schemPath); - if (schemFile == NULL) { - printErr("Invalid gem-graph version %s in model %s: no schema present", - version, model->name); - free(version); - xmlFreeDoc(xmlDocument); - free(schemPath); - return -5; - } - - // Loading schema file content - schemPtr = xmlSchemaParse(schemFile); - if (schemPtr == NULL) { - printErr("Invalid schema file, version %s\n", version); - xmlSchemaFreeParserCtxt(schemFile); - free(version); - xmlFreeDoc(xmlDocument); - free(schemPath); - return -6; - } - - // Creating validating context - schemValidator = xmlSchemaNewValidCtxt(schemPtr); - if (schemValidator == NULL) { - xmlSchemaFreeParserCtxt(schemFile); - xmlSchemaFree(schemPtr); - free(version); - xmlFreeDoc(xmlDocument); - free(schemPath); - printErr("An error occured preparing schema file, version %s\n", version); - return -7; - } - - // Validate (and print errors) ! - xmlSchemaSetValidErrors(schemValidator, - (xmlSchemaValidityErrorFunc) fprintf, - (xmlSchemaValidityWarningFunc) fprintf, stderr); - - // Get the validation status - model->validated = - xmlSchemaValidateDoc(schemValidator, xmlDocument) == 0 ? true : false; - - // Reset node - currentNode = xmlDocGetRootElement(xmlDocument); - - // Parsing identity - currentNode = currentNode->xmlChildrenNode; - while (currentNode != NULL) { - for (int i = 0; i < identityParserTable.len; i++) { - if ((!xmlStrcmp(currentNode->name, - identityParserTable.table[i].tag))) { - identityParserTable.table[i].parse(xmlDocument, - &identityParserTable, - i, - currentNode); - } - } - currentNode = currentNode->next; - } - - xmlSchemaFreeParserCtxt(schemFile); - xmlSchemaFreeValidCtxt(schemValidator); - xmlSchemaFree(schemPtr); - free(version); - xmlFreeDoc(xmlDocument); - free(schemPath); - xmlCleanupParser(); - - return 0; -} - -// -------------------------------------------------------------------------- // -// Parsing a model file // -// -------------------------------------------------------------------------- // -int ParseModelXML(Model_t *model) -{ - xmlDocPtr xmlDocument; - xmlNodePtr currentNode; - - ParserTableXML_t table[] = - { - // OBJECTS - // {(const xmlChar *)"objects", parseParentFieldXML, model}, - // {(const xmlChar *)"object", parseParentFieldPropsXML, model}, - - // SAVESTATES - {(const xmlChar *)"savestates", parseParentFieldPropsXML, model}, - // SPACE - {(const xmlChar *)"space", parseParentFieldPropsXML, model}, - - // TRANSITIONS - {(const xmlChar *)"transitions", parseParentFieldPropsXML, model}, - // TRANSITION - // TODO probability - {(const xmlChar *)"transition", parseParentFieldPropsXML, model}, - {(const xmlChar *)"if", parseParentFieldXML, model}, - {(const xmlChar *)"then", parseParentFieldXML, model}, - - // ARROW - {(const xmlChar *)"arrow", parseArrowFieldXML, model}, - - // REF - {(const xmlChar *)"ref", parseStubFieldXML, model}, - - // QUOTE - {(const xmlChar *)"quote", parseStubFieldXML, model}, - }; - - ModelParserTableXML_t modelParserTable = - { - LEN(table), - &table[0] - }; - - printLog("Parsing model %s\n", model->name); - - xmlDocument = xmlReadFile(model->filename, NULL, 0); - - if (xmlDocument == NULL) { - printErr("Can't parse model file at '%s'.\n", model->filename); - return -1; - } - - currentNode = xmlDocGetRootElement(xmlDocument); - - if (currentNode == NULL) { - printErr("Invalid model file at '%s', document empty !\n", - model->filename); - xmlFreeDoc(xmlDocument); - return -2; - } - - if (xmlStrcmp(currentNode->name, (const xmlChar *) "gem-graph-model")) { - printErr("Invalid model file at '%s', " - "root node is not !\n", - model->filename); - xmlFreeDoc(xmlDocument); - return -3; - } - - currentNode = currentNode->xmlChildrenNode; - while (currentNode != NULL) { - for (int i = 0; i < modelParserTable.len; i++) { - if ((!xmlStrcmp(currentNode->name, - modelParserTable.table[i].tag))) { - modelParserTable.table[i].parse(xmlDocument, - &modelParserTable, - i, - currentNode); - } - } - - currentNode = currentNode->next; - } - - xmlFreeDoc(xmlDocument); - xmlCleanupParser(); - - return 0; -} diff --git a/src/scheduler.c b/src/scheduler.c index 1b317bd..402e744 100644 --- a/src/scheduler.c +++ b/src/scheduler.c @@ -27,202 +27,4 @@ #include -/* -------------------------------------------------------------------------- */ -static void *schedulerMain(void *scheduler); - -/* -------------------------------------------------------------------------- */ - -// -------------------------------------------------------------------------- // -// Scheduler init function // -// -------------------------------------------------------------------------- // -void SchedInit(Scheduler_t *scheduler) -{ - pthread_create(&scheduler->id, NULL, schedulerMain, scheduler); -} - -/* -------------------------------------------------------------------------- */ - -// -------------------------------------------------------------------------- // -// Scheduler area finder function // -// -------------------------------------------------------------------------- // -static Center_t *findWorkArea(Center_t *centersList, Arrow_t *electedArrow, - int ruleRadius, int xmax, int ymax, int zmax) -{ - register Center_t *currentCenter, *newCenter; - - currentCenter = centersList->next; - newCenter = malloc(sizeof(Center_t)); - - while (currentCenter){ - if ( (xmax && (abs(electedArrow->x - currentCenter->x) <= ruleRadius)) - || (ymax && (abs(electedArrow->y - currentCenter->y) <= ruleRadius)) - || (zmax && (abs(electedArrow->z - currentCenter->z) <= ruleRadius)) - ){ - free(newCenter); - newCenter = NULL; - //printLog("Can't find a free area\n"); - return NULL; - } - currentCenter = currentCenter->next; - } - - newCenter->x = electedArrow->x; - newCenter->y = electedArrow->y; - newCenter->z = electedArrow->z; - return newCenter; -} - -/* -------------------------------------------------------------------------- */ - -// -------------------------------------------------------------------------- // -// Scheduler thread main function // -// -------------------------------------------------------------------------- // -static void *schedulerMain(void *scheduler) -{ - Scheduler_t *args; - Worker_t *workerArray; - // A center is a structure that defines, with a radius, a cubic preempted - // area for a worker to operate on (as an approximation of a spheric one) - Center_t *centersList, *workArea; - Arrow_t *electedArrow; - - int ncpu, nworker, err; - - // Getting scheduler argument structure - args = (Scheduler_t*) scheduler; - printLog("Scheduler #%lu online\n", args->id); - - if (!args->nMaxThread) { // nmaxthread = 0 => no minimum - ncpu = get_nprocs(); // allocating all the cpus available - } else { // n thread = min(cpu, nmaxthread) - ncpu = MIN(get_nprocs(), args->nMaxThread); - } - printLog("%d threads available.\n", ncpu); - - // Data structures - workerArray = calloc(ncpu, sizeof(*workerArray)); - nworker = 0; - centersList = calloc(1, sizeof(*centersList)); - - // Initiate the arrowArray lock - if (err = ArrowsInitLock(args->arrowArray), err != 0) { - printErr("Impossible to create the arrow array lock (error %d)\n", err); - return NULL; - } - // - // MAIN LOOP - // - while (!args->pleaseStop && 0 <= args->nMaxCycles) { //XXX count cycles - //printLog("Scheduler #%lu online: cycle %d\n", *args->id, ncycles); - // - - // TODO statistics here - - // Create a new thread - if (nworker < ncpu) { - - workArea = NULL; - - // Acquiring lock to consistently read the arrowArray - if (ArrowsAcquireNonBlockingLock(args->arrowArray)) { - // Random choice of an arrow - electedArrow = - &args->arrowArray->array[rand() % args->arrowArray->size]; // XXX - - // Find a local area - workArea = findWorkArea(centersList, - electedArrow, - args->ruleRadius, - args->globalDrawingSpace->xMax, - args->globalDrawingSpace->yMax, - args->globalDrawingSpace->zMax - ); - ArrowsReleaseLock(args->arrowArray); - } - - // If a free area exists, - if (workArea) { - // preempt it, - CenterAdd(centersList, workArea); - // find a worker socket, - for (int i = 0; i < ncpu; i++) { - // if a location is empty - if (workerArray[i].id == 0) { - // prepare the worker for the area, - workerArray[i].localWorkAreaCenter = workArea; - workerArray[i].globalDrawingSpace = - args->globalDrawingSpace; - workerArray[i].conditionTree = - args->conditionTree; - workerArray[i].arrowArray = - args->arrowArray; - // create the worker, - WorkerInit(&workerArray[i]); - // and increment worker count. - nworker++; - printLog("Added worker at rank %d with center %p, now %d worker(s)\n", - i, - workArea, - nworker - ); - // Increment partial cycle TODO - break; - } - } - } - } - - // Delete finished workers - for (int i = 0; i < ncpu; i++) { - if (workerArray[i].id) { - //printLog("Checking termination of worker #%lu\n", *workerArray[i].id); - // Check worker termination - if (workerArray[i].terminated) { - // Join the thread to act his termination - WorkerWait(&workerArray[i]); - // Remove preemption on space - CenterRemove(workerArray[i].localWorkAreaCenter); - printLog("Worker #%lu terminated with return %d. Cleaning...\n", - workerArray[i].id, - workerArray[i].returnValue - ); - // Remove Worker - WorkerDestroy(&workerArray[i]); - nworker--; - } - } - } - } - - // Exiting scheduler properly - printLog("Stopping scheduler... (waiting for workers)\n"); - // Waiting for remaining workers - for (int i = 0; i < ncpu; i++) { - if (workerArray[i].id) { - printLog("Waiting for termination of worker #%lu\n", workerArray[i].id); - // Join the thread to wait for his termination - WorkerWait(&workerArray[i]); - // Remove preemption on space - CenterRemove(workerArray[i].localWorkAreaCenter); - printLog("Worker #%lu terminated with return %d. Cleaning...\n", - workerArray[i].id, - workerArray[i].returnValue - ); - // Remove Worker - WorkerDestroy(&workerArray[i]); - } - } - - printLog("Scheduler #%lu offline\n", args->id); - - - ArrowsDestroyLock(args->arrowArray); - - free(workerArray); - workerArray = NULL; - free(centersList); - centersList = NULL; - - return NULL; -} diff --git a/src/server.c b/src/server.c index ff738a8..a82fc68 100644 --- a/src/server.c +++ b/src/server.c @@ -25,37 +25,22 @@ /* -------------------------------------------------------------------------- */ -static Command_t cmdList[] = -{ - {"help", CmdHelp, "Help command"}, - {"model", CmdModel, "Model command"}, - {"shutdown", CmdShutdown, "Shutdown command"}, -}; - -static void *serverMain(void *server); +static void *server_main(void *server); /* -------------------------------------------------------------------------- */ -// -------------------------------------------------------------------------- // -// Server init function // -// -------------------------------------------------------------------------- // -void ServerInit(Server_t *server) -{ - pthread_create(&server->id, NULL, serverMain, server); -} - #define SEND_BUFFER_SIZE 80 * 24 #define RECEIVE_BUFFER_SIZE 80 -void *serverCommunicationInstance(void *serverCom) +void *server_communication_instance(void *serverCom) { - ServerCommunication_t *args; + servercom_t *args; char **argv = NULL; char receiveBuff[RECEIVE_BUFFER_SIZE]; char sendBuff[SEND_BUFFER_SIZE]; int tokenIndex, bytesReceived, clientPort; char clientIP[16]; - args = (ServerCommunication_t*) serverCom; + args = (servercom_t*) serverCom; // Get ip address from client inet_ntop(AF_INET, @@ -132,7 +117,7 @@ void *serverCommunicationInstance(void *serverCom) #define PORT 9000 #define MAX_CONNECTION 100 -static void *serverMain(void *server) +static void *server_main(void *server) { Server_t *args; ServerCommunication_t serverSlots[MAX_CONNECTION] = {0}; @@ -235,7 +220,7 @@ static void *serverMain(void *server) // Create thread threadStatus = pthread_create(&serverSlots[serverSlotIndex].id, NULL, - serverCommunicationInstance, + server_communication_instance, (void*)&serverSlots[serverSlotIndex]); if(threadStatus != 0) { printErr("Error from pthread: %d (%s)\n", diff --git a/src/supervisor.c b/src/supervisor.c index 03cf758..3d8fae5 100644 --- a/src/supervisor.c +++ b/src/supervisor.c @@ -24,22 +24,4 @@ /* -------------------------------------------------------------------------- */ -static void *supervisorMain(void *supervisor); -/* -------------------------------------------------------------------------- */ - -// -------------------------------------------------------------------------- // -// Supervisor init function // -// -------------------------------------------------------------------------- // -void SupervisorInit(Supervisor_t *supervisor) -{ - pthread_create(&supervisor->id, NULL, supervisorMain, supervisor); -} - -// -------------------------------------------------------------------------- // -// Supervisor thread main function // -// -------------------------------------------------------------------------- // -static void *supervisorMain(void *supervisor) -{ - return NULL; -} diff --git a/src/tests/getchar b/src/tests/getchar deleted file mode 100755 index 79b5550..0000000 Binary files a/src/tests/getchar and /dev/null differ diff --git a/src/tests/test_realloc b/src/tests/test_realloc deleted file mode 100755 index 03248fc..0000000 Binary files a/src/tests/test_realloc and /dev/null differ diff --git a/src/tests/xml b/src/tests/xml deleted file mode 100755 index b082672..0000000 Binary files a/src/tests/xml and /dev/null differ diff --git a/src/worker.c b/src/worker.c index 19d9b5c..f758ed5 100644 --- a/src/worker.c +++ b/src/worker.c @@ -24,40 +24,4 @@ /* -------------------------------------------------------------------------- */ -static void *WorkerMain(void *worker); -/* -------------------------------------------------------------------------- */ - -// -------------------------------------------------------------------------- // -// Worker init function // -// -------------------------------------------------------------------------- // -void WorkerInit(Worker_t *worker) -{ - if (pthread_create(&worker->id, NULL, WorkerMain, worker)) { - printLog("Worker #%lu can't be initialized!\n", worker->id); - return; - } -} - -// -------------------------------------------------------------------------- // -// Worker thread main function // -// -------------------------------------------------------------------------- // -static void *WorkerMain(void *worker) -{ - Worker_t *args; - int a = rand()%__INT_MAX__; - - args = (Worker_t*) worker; - printLog("Worker #%lu online\n", args->id); - - int size = args->globalDrawingSpace->size; - - // TODO execute rule comparison - - args->returnValue = a; - args->terminated = true; - - printLog("Worker #%lu offline\n", args->id); - - return NULL; -}