diff options
Diffstat (limited to 'src')
| -rw-r--r-- | src/common.c | 22 | ||||
| -rw-r--r-- | src/evolver.c | 44 | ||||
| -rw-r--r-- | src/instset.c | 18 | ||||
| -rw-r--r-- | src/memory.c | 80 | ||||
| -rw-r--r-- | src/process.c | 479 | ||||
| -rw-r--r-- | src/render.c | 53 | ||||
| -rw-r--r-- | src/salis.c | 42 |
7 files changed, 439 insertions, 299 deletions
diff --git a/src/common.c b/src/common.c index 402320e..a2fc559 100644 --- a/src/common.c +++ b/src/common.c @@ -8,8 +8,9 @@ static Receiver g_receiver; void sal_comm_set_sender(Sender sender) { - /* Set sender functor. Whenever an organism calls the SEND instruction, - this function will get called. When unset, SEND instruction is ignored. + /* + * Set sender functor. Whenever an organism calls the SEND instruction, + * this function will get called. When unset, SEND instruction is ignored. */ assert(sender); g_sender = sender; @@ -17,8 +18,9 @@ void sal_comm_set_sender(Sender sender) void sal_comm_set_receiver(Receiver receiver) { - /* Set receiver functor. Whenever an organism calls the RCVE instruction, - this function will get called. When unset, RCVE instruction is ignored. + /* + * Set receiver functor. Whenever an organism calls the RCVE instruction, + * this function will get called. When unset, RCVE instruction is ignored. */ assert(receiver); g_receiver = receiver; @@ -26,8 +28,9 @@ void sal_comm_set_receiver(Receiver receiver) void _sal_comm_send(uint8 inst) { - /* Send a single byte (instruction) to the sender. This function is called - by processes that execute the SEND instruction. + /* + * Send a single byte (instruction) to the sender. This function is called + * by processes that execute the SEND instruction. */ assert(sal_is_inst(inst)); @@ -38,9 +41,10 @@ void _sal_comm_send(uint8 inst) uint8 _sal_comm_receive(void) { - /* Receive a single byte (instruction) from the receiver. This function is - called by processes that execute the RCVE instruction. It returns NOP0 is - receiver is unset. + /* + * Receive a single byte (instruction) from the receiver. This function is + * called by processes that execute the RCVE instruction. It returns NOP0 is + * receiver is unset. */ if (g_receiver) { uint8 inst = g_receiver(); diff --git a/src/evolver.c b/src/evolver.c index e3b6ef7..dfba958 100644 --- a/src/evolver.c +++ b/src/evolver.c @@ -16,8 +16,9 @@ static uint32 g_state[4]; void _sal_evo_init(void) { - /* Start up the evolver module. We simply set the 128 bits into a random - state by calling 'rand()'. + /* + * Start up the evolver module. We simply set the 128 bits into a random + * state by calling 'rand()'. */ assert(!g_is_init); srand((uint32)time(NULL)); @@ -30,7 +31,8 @@ void _sal_evo_init(void) void _sal_evo_quit(void) { - /* Quit the evolver module. Reset everything back to zero. + /* + * Quit the evolver module. Reset everything back to zero. */ assert(g_is_init); g_is_init = FALSE; @@ -41,7 +43,8 @@ void _sal_evo_quit(void) void _sal_evo_load_from(FILE *file) { - /* Load evolver state from a binary file. + /* + * Load evolver state from a binary file. */ assert(!g_is_init); assert(file); @@ -53,7 +56,8 @@ void _sal_evo_load_from(FILE *file) void _sal_evo_save_into(FILE *file) { - /* Save evolver state into a binary file. + /* + * Save evolver state into a binary file. */ assert(g_is_init); assert(file); @@ -63,15 +67,17 @@ void _sal_evo_save_into(FILE *file) fwrite(&g_state, sizeof(uint32), 4, file); } -/* Getter methods for the evolver module. +/* +* Getter methods for the evolver module. */ UINT32_GETTER(evo, last_changed_address) UINT32_GETTER(evo, calls_on_last_cycle) uint32 sal_evo_get_state(uint8 state_index) { - /* Get part of the evolver's internal state (32 bits of 128 total bits) as - an unsigned int. + /* + * Get part of the evolver's internal state (32 bits of 128 total bits) as + * an unsigned int. */ assert(g_is_init); assert(state_index < 4); @@ -80,10 +86,11 @@ uint32 sal_evo_get_state(uint8 state_index) static uint32 generate_random_number(void) { - /* Generate a single 32 bit random number. This module makes use of the - XOR-Shift pseudo-rng. We use XOR-Shift because it's extremely lightweight - and fast, while providing quite good results. Find more info about it here: - >>> https://en.wikipedia.org/wiki/Xorshift + /* + * Generate a single 32 bit random number. This module makes use of the + * XOR-Shift pseudo-rng. We use XOR-Shift because it's extremely lightweight + * and fast, while providing quite good results. Find more info about it at: + * https://en.wikipedia.org/wiki/Xorshift */ uint32 tmp1; uint32 tmp2; @@ -103,7 +110,8 @@ static uint32 generate_random_number(void) void _sal_evo_randomize_at(uint32 address) { - /* Place a random instruction into a given address. + /* + * Place a random instruction into a given address. */ uint8 inst; assert(g_is_init); @@ -115,11 +123,11 @@ void _sal_evo_randomize_at(uint32 address) void _sal_evo_cycle(void) { - /* During each simulation cycle, a random 32 bit integer is generated. If - this integer represents a 'valid' address in memory - (i.e. new_rand < memory_size), this address becomes hit by a cosmic ray - (randomized). This simple mutation scheme is enough to drive evolution in - Salis. + /* + * During each simulation cycle, a random 32 bit integer is generated. If + * this integer represents a 'valid' address in memory (new_rand < mem_size), + * this address becomes hit by a cosmic ray (randomized). This simple + * mutation scheme is enough to drive evolution in Salis. */ uint32 address; assert(g_is_init); diff --git a/src/instset.c b/src/instset.c index 2ab127a..94c3df7 100644 --- a/src/instset.c +++ b/src/instset.c @@ -4,15 +4,17 @@ boolean sal_is_inst(uint32 word) { - /* Test if a given 32 bit integer contains a valid Salis instruction. + /* + * Test if a given 32 bit integer contains a valid Salis instruction. */ return word < INST_COUNT; } static boolean is_in_between(uint32 inst, uint32 low, uint32 hi) { - /* Test whether a Salis instruction lies within a given range. This is - useful for identifying template instructions and/or register modifiers. + /* + * Test whether a Salis instruction lies within a given range. This is + * useful for identifying template instructions and/or register modifiers. */ assert(sal_is_inst(inst)); assert(sal_is_inst(low)); @@ -22,8 +24,9 @@ static boolean is_in_between(uint32 inst, uint32 low, uint32 hi) boolean sal_is_template(uint32 inst) { - /* Test whether a given instruction is a template element - (i.e. NOP0 or NOP1). + /* + * Test whether a given instruction is a template element (i.e. NOP0 or + * NOP1). */ assert(sal_is_inst(inst)); return is_in_between(inst, NOP0, NOP1); @@ -31,8 +34,9 @@ boolean sal_is_template(uint32 inst) boolean sal_is_mod(uint32 inst) { - /* Test whether a given instruction is a register modifier - (i.e. MODA, MODB, MODC or MODD). + /* + * Test whether a given instruction is a register modifier (i.e. MODA, MODB, + * MODC or MODD). */ assert(sal_is_inst(inst)); return is_in_between(inst, MODA, MODD); diff --git a/src/memory.c b/src/memory.c index b02a5b9..7f51df4 100644 --- a/src/memory.c +++ b/src/memory.c @@ -17,9 +17,10 @@ static uint8_p g_memory; void _sal_mem_init(uint32 order) { - /* Set memory module to its initial state. We calculate memory size based - on its order (size = 1 << order) and allocate an array of such size. We - also initialize the array completely to zero. + /* + * Set memory module to its initial state. We calculate memory size based + * on its order (size = 1 << order) and allocate an array of such size. We + * also initialize the array completely to zero. */ assert(!g_is_init); assert(order < 32); @@ -34,8 +35,9 @@ void _sal_mem_init(uint32 order) void _sal_mem_quit(void) { - /* Reset memory module entirely back to zero. That way, we can load several - simulations without restarting the application entirely. + /* + * Reset memory module entirely back to zero. That way, we can load several + * simulations without restarting the application entirely. */ assert(g_is_init); free(g_memory); @@ -50,7 +52,8 @@ void _sal_mem_quit(void) void _sal_mem_load_from(FILE *file) { - /* Load memory state from a binary file. + /* + * Load memory state from a binary file. */ assert(!g_is_init); assert(file); @@ -67,7 +70,8 @@ void _sal_mem_load_from(FILE *file) void _sal_mem_save_into(FILE *file) { - /* Save memory state to a binary file. + /* + * Save memory state to a binary file. */ assert(g_is_init); assert(file); @@ -80,7 +84,8 @@ void _sal_mem_save_into(FILE *file) fwrite(g_memory, sizeof(uint8), g_size, file); } -/* Getter methods for the memory module. +/* +* Getter methods for the memory module. */ UINT32_GETTER(mem, order) UINT32_GETTER(mem, size) @@ -89,8 +94,9 @@ UINT32_GETTER(mem, capacity) uint32 sal_mem_get_inst_count(uint8 inst) { - /* Return number of times a certain instruction appears in memory. The - instruction counter gets updated dynamically during each cycle. + /* + * Return number of times a certain instruction appears in memory. The + * instruction counter gets updated dynamically during each cycle. */ assert(g_is_init); assert(sal_is_inst(inst)); @@ -99,8 +105,9 @@ uint32 sal_mem_get_inst_count(uint8 inst) boolean sal_mem_is_over_capacity(void) { - /* Check if memory is filled above 50%. If so, old organisms will be popped - out of the reaper queue! + /* + * Check if memory is filled above 50%. If so, old organisms will be popped + * out of the reaper queue! */ assert(g_is_init); return g_allocated > g_capacity; @@ -108,7 +115,8 @@ boolean sal_mem_is_over_capacity(void) boolean sal_mem_is_address_valid(uint32 address) { - /* Check if given address is valid. + /* + * Check if given address is valid. */ assert(g_is_init); return address < g_size; @@ -116,7 +124,8 @@ boolean sal_mem_is_address_valid(uint32 address) boolean sal_mem_is_allocated(uint32 address) { - /* Check if given address is allocated. + /* + * Check if given address is allocated. */ assert(g_is_init); assert(sal_mem_is_address_valid(address)); @@ -125,7 +134,8 @@ boolean sal_mem_is_allocated(uint32 address) void _sal_mem_set_allocated(uint32 address) { - /* Set allocated flag on a given address. + /* + * Set allocated flag on a given address. */ assert(g_is_init); assert(sal_mem_is_address_valid(address)); @@ -138,7 +148,8 @@ void _sal_mem_set_allocated(uint32 address) void _sal_mem_unset_allocated(uint32 address) { - /* Unset allocated flag on a given address. + /* + * Unset allocated flag on a given address. */ assert(g_is_init); assert(sal_mem_is_address_valid(address)); @@ -151,8 +162,9 @@ void _sal_mem_unset_allocated(uint32 address) uint8 sal_mem_get_inst(uint32 address) { - /* Get instruction currently set on a specified address, with the allocated - bit flag turned off. + /* + * Get instruction currently set on a specified address, with the allocated + * bit flag turned off. */ assert(g_is_init); assert(sal_mem_is_address_valid(address)); @@ -161,8 +173,9 @@ uint8 sal_mem_get_inst(uint32 address) void sal_mem_set_inst(uint32 address, uint8 inst) { - /* Set instruction at given address. This is useful when performing manual - memory manipulations (like compiling organism genomes). + /* + * Set instruction at given address. This is useful when performing manual + * memory manipulations (like compiling organism genomes). */ assert(g_is_init); assert(sal_mem_is_address_valid(address)); @@ -175,8 +188,9 @@ void sal_mem_set_inst(uint32 address, uint8 inst) uint8 sal_mem_get_byte(uint32 address) { - /* Get unadulterated byte at given address. This could be used, for - example, to render nice images of the memory state. + /* + * Get unadulterated byte at given address. This could be used, for example, + * to render nice images of the memory state. */ assert(g_is_init); assert(sal_mem_is_address_valid(address)); @@ -185,8 +199,9 @@ uint8 sal_mem_get_byte(uint32 address) static boolean inst_count_is_correct(void) { - /* Check that the instruction counter is in a valid state - (i.e. SUM inst_counter[0..(INST_COUNT - 1)] == memory_size). + /* + * Check that the instruction counter is in a valid state (i.e. + * SUM inst_counter[0..(INST_COUNT - 1)] == memory_size). */ uint32 i; uint32 sum = 0; @@ -202,9 +217,10 @@ static boolean inst_count_is_correct(void) static boolean module_is_valid(void) { - /* Check for validity of memory module. This function only gets called when - Salis is running in debug mode. It makes Salis **very** slow in comparison - to when running optimized, but it is also **very** useful for debugging! + /* + * Check for validity of memory module. This function only gets called when + * Salis is running in debug mode. It makes Salis **very** slow in comparison + * to when running optimized, but it is also **very** useful for debugging! */ uint32 bidx; uint32 allocated = 0; @@ -212,8 +228,9 @@ static boolean module_is_valid(void) assert(g_capacity <= g_size / 2); assert(inst_count_is_correct()); - /* Iterate through all memory, counting the flags set on each address. We - then compare the sum to the flag counters to assert module validity. + /* + * Iterate through all memory, counting the flags set on each address. We + * then compare the sum to the flag counters to assert module validity. */ for (bidx = 0; bidx < g_size; bidx++) { if (sal_mem_is_allocated(bidx)) { @@ -227,8 +244,9 @@ static boolean module_is_valid(void) void _sal_mem_cycle(void) { - /* Cycle memory module. Simply assert validity when running in debug mode. - When running optimized, this function does nothing. + /* + * Cycle memory module. Simply assert validity when running in debug mode. + * When running optimized, this function does nothing. */ assert(g_is_init); assert(module_is_valid()); diff --git a/src/process.c b/src/process.c index eb89a8d..3a674c1 100644 --- a/src/process.c +++ b/src/process.c @@ -19,10 +19,11 @@ static Process *g_procs; void _sal_proc_init(void) { - /* Initialize process module to its initial state. We initialize the reaper - queue with a capacity of 1. 'First' and 'last' organism pointers are - initialized to (uint32)-1 (to indicate they point to no organism, as no - organism exists yet). + /* + * Initialize process module to its initial state. We initialize the reaper + * queue with a capacity of 1. 'First' and 'last' organism pointers are + * initialized to (uint32)-1 (to indicate they point to no organism, as no + * organism exists yet). */ assert(!g_is_init); g_is_init = TRUE; @@ -35,7 +36,8 @@ void _sal_proc_init(void) void _sal_proc_quit(void) { - /* Reset process module back to zero; free up the process queue. + /* + * Reset process module back to zero; free up the process queue. */ assert(g_is_init); free(g_procs); @@ -49,7 +51,8 @@ void _sal_proc_quit(void) void _sal_proc_load_from(FILE *file) { - /* Load process module state from a binary file. + /* + * Load process module state from a binary file. */ assert(!g_is_init); assert(file); @@ -65,7 +68,8 @@ void _sal_proc_load_from(FILE *file) void _sal_proc_save_into(FILE *file) { - /* Save process module state to a binary file. + /* + * Save process module state to a binary file. */ assert(g_is_init); assert(file); @@ -77,7 +81,8 @@ void _sal_proc_save_into(FILE *file) fwrite(g_procs, sizeof(Process), g_capacity, file); } -/* Getter methods for the process module. +/* +* Getter methods for the process module. */ UINT32_GETTER(proc, count) UINT32_GETTER(proc, capacity) @@ -86,18 +91,20 @@ UINT32_GETTER(proc, last) boolean sal_proc_is_free(uint32 proc_id) { - /* In Salis, the reaper queue is implemented as a circular queue. Thus, at - any given time, a process ID (which actually denotes a process 'address' - or, more correctly, a process 'container address') might contain a living - process or be empty. This function checks for the 'living' state of a given - process ID. + /* + * In Salis, the reaper queue is implemented as a circular queue. Thus, at + * any given time, a process ID (which actually denotes a process 'address' + * or, more correctly, a process 'container address') might contain a living + * process or be empty. This function checks for the 'living' state of a + * given process ID. */ assert(g_is_init); assert(proc_id < g_capacity); if (!g_procs[proc_id].mb1s) { - /* When running in debug mode, we make sure that non-living processes - are completely set to zero, as this is the expected state. + /* + * When running in debug mode, we make sure that non-living processes + * are completely set to zero, as this is the expected state. */ #ifndef NDEBUG Process dummy_proc; @@ -113,8 +120,9 @@ boolean sal_proc_is_free(uint32 proc_id) Process sal_proc_get_proc(uint32 proc_id) { - /* Get a **copy** (not a reference) of the process with the given ID. Note, - this might be a non-living process. + /* + * Get a **copy** (not a reference) of the process with the given ID. Note, + * this might be a non-living process. */ assert(g_is_init); assert(proc_id < g_capacity); @@ -123,11 +131,12 @@ Process sal_proc_get_proc(uint32 proc_id) void sal_proc_get_proc_data(uint32 proc_id, uint32_p buffer) { - /* Get a **copy** (not a reference) of the process with the given ID - (represented as a string of 32 bit integers) written into the given buffer. - The buffer must be pre-allocated to a large enough size - (i.e. malloc(sizeof(Process))). Note, copied process might be in a - non-living state. + /* + * Get a **copy** (not a reference) of the process with the given ID + * (represented as a string of 32 bit integers) written into the given + * buffer. The buffer must be pre-allocated to a large enough size (i.e. + * malloc(sizeof(Process))). Note, copied process might be in a non-living + * state. */ assert(g_is_init); assert(proc_id < g_capacity); @@ -137,8 +146,9 @@ void sal_proc_get_proc_data(uint32 proc_id, uint32_p buffer) static boolean block_is_free_and_valid(uint32 address, uint32 size) { - /* Iterate all addresses in the given memory block and check that they lie - within memory bounds and have the ALLOCATED flag unset. + /* + * Iterate all addresses in the given memory block and check that they lie + * within memory bounds and have the ALLOCATED flag unset. */ uint32 offset; @@ -153,13 +163,14 @@ static boolean block_is_free_and_valid(uint32 address, uint32 size) static void realloc_queue(uint32 queue_lock) { - /* Reallocate reaper queue into a new circular queue with double the - capacity. This function gets called whenever the reaper queue fills up - with new organisms. - - A queue_lock parameter may be provided, which 'centers' the reallocation on - a given process ID. This means that, after reallocating the queue, the - process with that ID will keep still have the same ID on the new queue. + /* + * Reallocate reaper queue into a new circular queue with double the + * capacity. This function gets called whenever the reaper queue fills up + * with new organisms. + * + * A queue_lock parameter may be provided, which 'centers' the reallocation + * on a given process ID. This means that, after reallocating the queue, the + * process with that ID will keep still have the same ID on the new queue. */ uint32 new_capacity; Process *new_queue; @@ -174,7 +185,8 @@ static void realloc_queue(uint32 queue_lock) fwrd_idx = queue_lock; back_idx = (queue_lock - 1) % new_capacity; - /* Copy all organisms that lie forward from queue lock. + /* + * Copy all organisms that lie forward from queue lock. */ while (TRUE) { uint32 old_idx = fwrd_idx % g_capacity; @@ -188,9 +200,10 @@ static void realloc_queue(uint32 queue_lock) } } - /* Copy all organisms that lie backwards from queue lock, making sure to - loop around the queue (with modulo '%') whenever the process index goes - below zero. + /* + * Copy all organisms that lie backwards from queue lock, making sure to + * loop around the queue (with modulo '%') whenever the process index goes + * below zero. */ if (queue_lock != g_first) { while (TRUE) { @@ -207,7 +220,8 @@ static void realloc_queue(uint32 queue_lock) } } - /* Free old reaper queue and re-link global pointer to new queue. + /* + * Free old reaper queue and re-link global pointer to new queue. */ free(g_procs); g_capacity = new_capacity; @@ -216,12 +230,14 @@ static void realloc_queue(uint32 queue_lock) static uint32 get_new_proc_from_queue(uint32 queue_lock) { - /* Retrieve an unoccupied process ID from the reaper queue. This function - gets called whenever a new organism is generated (born). + /* + * Retrieve an unoccupied process ID from the reaper queue. This function + * gets called whenever a new organism is generated (born). */ assert(g_is_init); - /* If reaper queue is full, reallocate to double its current size. + /* + * If reaper queue is full, reallocate to double its current size. */ if (g_count == g_capacity) { realloc_queue(queue_lock); @@ -243,18 +259,20 @@ static uint32 get_new_proc_from_queue(uint32 queue_lock) static void proc_create(uint32 address, uint32 size, uint32 queue_lock, boolean allocate) { - /* Give birth to a new process! We must specify the address and size of the - new organism. + /* + * Give birth to a new process! We must specify the address and size of the + * new organism. */ uint32 pidx; assert(g_is_init); assert(sal_mem_is_address_valid(address)); assert(sal_mem_is_address_valid(address + size - 1)); - /* When organisms are generated manually (by an user), we must explicitly - allocate its entire memory block. When organisms replicate by themselves, - we assume they have already allocated the child's memory, so we don't need - to do it here. + /* + * When organisms are generated manually (by an user), we must explicitly + * allocate its entire memory block. When organisms replicate by themselves, + * we assume they have already allocated the child's memory, so we don't + * need to do it here. */ if (allocate) { uint32 offset; @@ -266,8 +284,9 @@ static void proc_create(uint32 address, uint32 size, uint32 queue_lock, } } - /* Get a new process ID for the child process. Also, set initial state of - the child process data structure. + /* + * Get a new process ID for the child process. Also, set initial state of + * the child process data structure. */ pidx = get_new_proc_from_queue(queue_lock); g_procs[pidx].mb1a = address; @@ -278,8 +297,9 @@ static void proc_create(uint32 address, uint32 size, uint32 queue_lock, void sal_proc_create(uint32 address, uint32 mb1s) { - /* API function to create a new process. Memory address and size of new - process must be provided. + /* + * API function to create a new process. Memory address and size of new + * process must be provided. */ assert(g_is_init); assert(block_is_free_and_valid(address, mb1s)); @@ -288,7 +308,8 @@ void sal_proc_create(uint32 address, uint32 mb1s) static void free_memory_block(uint32 address, uint32 size) { - /* Deallocate a memory block. + /* + * Deallocate a memory block. */ uint32 offset; assert(sal_mem_is_address_valid(address)); @@ -306,7 +327,8 @@ static void free_memory_block(uint32 address, uint32 size) static void free_memory_owned_by(uint32 pidx) { - /* Free memory specifically owned by the process with the given ID. + /* + * Free memory specifically owned by the process with the given ID. */ assert(g_is_init); assert(pidx < g_capacity); @@ -314,7 +336,8 @@ static void free_memory_owned_by(uint32 pidx) free_memory_block(g_procs[pidx].mb1a, g_procs[pidx].mb1s); if (g_procs[pidx].mb2s) { - /* If process owns a child memory block, free it as well. + /* + * If process owns a child memory block, free it as well. */ free_memory_block(g_procs[pidx].mb2a, g_procs[pidx].mb2s); } @@ -322,7 +345,8 @@ static void free_memory_owned_by(uint32 pidx) static void proc_kill(void) { - /* Kill process on bottom of reaper queue (the oldest process). + /* + * Kill process on bottom of reaper queue (the oldest process). */ assert(g_is_init); assert(g_count); @@ -330,7 +354,8 @@ static void proc_kill(void) assert(g_last != UINT32_MAX); assert(!sal_proc_is_free(g_first)); - /* Free up owned memory and reset process data structure back to zero. + /* + * Free up owned memory and reset process data structure back to zero. */ free_memory_owned_by(g_first); memset(&g_procs[g_first], 0, sizeof(Process)); @@ -347,8 +372,9 @@ static void proc_kill(void) void sal_proc_kill(void) { - /* API function to kill a process. Make sure that at least one process is - alive, or 'assert()' will fail. + /* + * API function to kill a process. Make sure that at least one process is + * alive, or 'assert()' will fail. */ assert(g_is_init); assert(g_count); @@ -360,7 +386,8 @@ void sal_proc_kill(void) static boolean block_is_allocated(uint32 address, uint32 size) { - /* Assert that a given memory block is fully allocated. + /* + * Assert that a given memory block is fully allocated. */ uint32 offset; assert(g_is_init); @@ -376,9 +403,11 @@ static boolean block_is_allocated(uint32 address, uint32 size) static boolean proc_is_valid(uint32 pidx) { - /* Assert that the process with the given ID is in a valid state. This - means that all of its owned memory must be allocated and that the allocated - flags are set in place. IP and SP must be located in valid addresses. + /* + * Assert that the process with the given ID is in a valid state. This + * means that all of its owned memory must be allocated and that the + * allocated flags are set in place. IP and SP must be located in valid + * addresses. */ assert(g_is_init); assert(pidx < g_capacity); @@ -398,26 +427,29 @@ static boolean proc_is_valid(uint32 pidx) static boolean module_is_valid(void) { - /* Check for validity of process module. This function only gets called - when Salis is running in debug mode. It makes Salis **very** slow in - comparison to when running optimized, but it is also **very** useful for - debugging! + /* + * Check for validity of process module. This function only gets called when + * Salis is running in debug mode. It makes Salis **very** slow in + * comparison to when running optimized, but it is also **very** useful for + * debugging! */ uint32 pidx; uint32 alloc_count = 0; assert(g_is_init); - /* Check that each individual process is in a valid state. We can do this - in a multi-threaded way. + /* + * Check that each individual process is in a valid state. We can do this + * in a multi-threaded way. */ #pragma omp parallel for for (pidx = 0; pidx < g_capacity; pidx++) { assert(proc_is_valid(pidx)); } - /* Iterate all processes, counting their memory blocks and adding up their - memory block sizes. At the end, we compare the sums to the flag counters of - the memory module. + /* + * Iterate all processes, counting their memory blocks and adding up their + * memory block sizes. At the end, we compare the sums to the flag counters of + * the memory module. */ for (pidx = 0; pidx < g_capacity; pidx++) { if (!sal_proc_is_free(pidx)) { @@ -436,7 +468,8 @@ static boolean module_is_valid(void) static void on_fault(uint32 pidx) { - /* For now, faults do nothing. + /* + * For now, faults do nothing. */ assert(g_is_init); assert(pidx < g_capacity); @@ -446,8 +479,9 @@ static void on_fault(uint32 pidx) static void increment_ip(uint32 pidx) { - /* After executing each instruction, increment the given organism's IP to - the next valid address. + /* + * After executing each instruction, increment the given organism's IP to + * the next valid address. */ assert(g_is_init); assert(pidx < g_capacity); @@ -457,42 +491,49 @@ static void increment_ip(uint32 pidx) g_procs[pidx].ip++; } - /* Wherever IP goes, SP follows. :P + /* + * Wherever IP goes, SP follows. :P */ g_procs[pidx].sp = g_procs[pidx].ip; } static boolean are_templates_complements(uint32 source, uint32 complement) { - /* Check whether 2 templates are complements. Templates are introduced in - Salis-2.0 and they function in the same way as templates in the original - Tierra. They consist of string of NOP0 and NOP1 instructions. - - We say that templates are complements whenever one is a 'negation' of - another (i.e. they are reverse copies of each other). So, on the following - example, the top template would be the complement of the bottom template. - - >>> NOP0 - NOP1 - NOP1 - >>> NOP1 - NOP0 - NOP0 - - This function looks into 2 given addresses in memory and checks whether - there are complementing templates on those addresses. + /* + * Check whether 2 templates are complements. Templates are introduced in + * Salis-2.0 and they function in the same way as templates in the original + * Tierra. They consist of string of NOP0 and NOP1 instructions. + * + * We say that templates are complements whenever one is a 'negation' of + * another (i.e. they are reverse copies of each other). So, on the + * following example, the top template would be the complement of the bottom + * template. + * + * >>> NOP0 - NOP1 - NOP1 + * >>> NOP1 - NOP0 - NOP0 + * + * This function looks into 2 given addresses in memory and checks whether + * there are complementing templates on those addresses. */ assert(g_is_init); assert(sal_mem_is_address_valid(source)); assert(sal_mem_is_address_valid(complement)); assert(sal_is_template(sal_mem_get_inst(source))); - while (sal_mem_is_address_valid(source) && - sal_is_template(sal_mem_get_inst(source))) { - /* Iterate address by address, checking complementarity on each - consecutive byte pair. + while ( + sal_mem_is_address_valid(source) && + sal_is_template(sal_mem_get_inst(source)) + ) { + /* + * Iterate address by address, checking complementarity on each + * consecutive byte pair. */ uint8 inst_src; uint8 inst_comp; - /* If complement head moves to an invalid address, complementarity - fails. + /* + * If complement head moves to an invalid address, complementarity + * fails. */ if (!sal_mem_is_address_valid(complement)) { return FALSE; @@ -514,18 +555,20 @@ static boolean are_templates_complements(uint32 source, uint32 complement) complement++; } - /* If we get to the end of a template in the source head, and target has - been complementary all the way through, we consider these blocks of memory - 'complements'. + /* + * If we get to the end of a template in the source head, and target has + * been complementary all the way through, we consider these blocks of + * memory 'complements'. */ return TRUE; } static void increment_sp(uint32 pidx, boolean forward) { - /* Increment or decrement SP to the next valid address. This function gets - called by organisms during jumps, searches, etc. (i.e. whenever the seeker - pointer gets sent on a 'mission'). + /* + * Increment or decrement SP to the next valid address. This function gets + * called by organisms during jumps, searches, etc. (i.e. whenever the + * seeker pointer gets sent on a 'mission'). */ assert(g_is_init); assert(pidx < g_capacity); @@ -542,11 +585,12 @@ static void increment_sp(uint32 pidx, boolean forward) static boolean jump_seek(uint32 pidx, boolean forward) { - /* Search (via the seeker pointer) for template to jump into. This gets - called by organisms each cycle during a JMP instruction. Only when a valid - template is found, will this function return TRUE. Otherwise it will return - FALSE, signaling the calling process that a template has not yet been - found. + /* + * Search (via the seeker pointer) for template to jump into. This gets + * called by organisms each cycle during a JMP instruction. Only when a + * valid template is found, will this function return TRUE. Otherwise it + * will return FALSE, signaling the calling process that a template has not + * yet been found. */ uint32 next_addr; uint8 next_inst; @@ -555,8 +599,9 @@ static boolean jump_seek(uint32 pidx, boolean forward) assert(!sal_proc_is_free(pidx)); next_addr = g_procs[pidx].ip + 1; - /* This function causes a 'fault' when there is no template right in front - of the caller organism's instruction pointer. + /* + * This function causes a 'fault' when there is no template right in front + * of the caller organism's instruction pointer. */ if (!sal_mem_is_address_valid(next_addr)) { on_fault(pidx); @@ -572,8 +617,9 @@ static boolean jump_seek(uint32 pidx, boolean forward) return FALSE; } - /* Check for complementarity. Increment seeker pointer if template has not - been found yet. + /* + * Check for complementarity. Increment seeker pointer if template has not + * been found yet. */ if (are_templates_complements(next_addr, g_procs[pidx].sp)) { return TRUE; @@ -585,9 +631,10 @@ static boolean jump_seek(uint32 pidx, boolean forward) static void jump(uint32 pidx) { - /* This gets called when an organism has finally found a template to jump - into (see function above). Only when in debug mode, we make sure that the - entire jump operation has been performed in a valid way. + /* + * This gets called when an organism has finally found a template to jump + * into (see function above). Only when in debug mode, we make sure that the + * entire jump operation has been performed in a valid way. */ #ifndef NDEBUG uint32 next_addr; @@ -610,11 +657,13 @@ static void jump(uint32 pidx) static boolean addr_seek(uint32 pidx, boolean forward) { - /* Search (via the seeker pointer) for template address in memory. This - gets called by organisms each cycle during a ADR instruction. Only when a - valid template is found, will this function return TRUE. Otherwise it will - return FALSE, signaling the calling process that a template has not yet - been found. */ + /* + * Search (via the seeker pointer) for template address in memory. This + * gets called by organisms each cycle during a ADR instruction. Only when a + * valid template is found, will this function return TRUE. Otherwise it + * will return FALSE, signaling the calling process that a template has not + * yet been found. + */ uint32 next1_addr; uint32 next2_addr; uint8 next1_inst; @@ -625,12 +674,15 @@ static boolean addr_seek(uint32 pidx, boolean forward) next1_addr = g_procs[pidx].ip + 1; next2_addr = g_procs[pidx].ip + 2; - /* This function causes a 'fault' when there is no register modifier right - in front of the caller organism's instruction pointer, and a template just - after that. + /* + * This function causes a 'fault' when there is no register modifier right + * in front of the caller organism's instruction pointer, and a template + * just after that. */ - if (!sal_mem_is_address_valid(next1_addr) || - !sal_mem_is_address_valid(next2_addr)) { + if ( + !sal_mem_is_address_valid(next1_addr) || + !sal_mem_is_address_valid(next2_addr) + ) { on_fault(pidx); increment_ip(pidx); return FALSE; @@ -645,8 +697,9 @@ static boolean addr_seek(uint32 pidx, boolean forward) return FALSE; } - /* Check for complementarity. Increment seeker pointer if template has not - been found yet. + /* + * Check for complementarity. Increment seeker pointer if template has not + * been found yet. */ if (are_templates_complements(next2_addr, g_procs[pidx].sp)) { return TRUE; @@ -656,12 +709,13 @@ static boolean addr_seek(uint32 pidx, boolean forward) return FALSE; } -static boolean get_register_pointers(uint32 pidx, uint32_p *regs, - uint32 reg_count) -{ - /* This function is used to get pointers to a calling organism registers. - Specifically, registers returned are those that will be used when executing - the caller organism's current instruction. +static boolean get_register_pointers( + uint32 pidx, uint32_p *regs, uint32 reg_count +) { + /* + * This function is used to get pointers to a calling organism registers. + * Specifically, registers returned are those that will be used when + * executing the caller organism's current instruction. */ uint32 ridx; assert(g_is_init); @@ -671,15 +725,18 @@ static boolean get_register_pointers(uint32 pidx, uint32_p *regs, assert(reg_count); assert(reg_count < 4); - /* Iterate 'reg_count' number of instructions forward from the IP, noting - down all found register modifiers. If less than 'reg_count' modifiers are - found, this function returns FALSE (triggering a 'fault'). + /* + * Iterate 'reg_count' number of instructions forward from the IP, noting + * down all found register modifiers. If less than 'reg_count' modifiers are + * found, this function returns FALSE (triggering a 'fault'). */ for (ridx = 0; ridx < reg_count; ridx++) { uint32 mod_addr = g_procs[pidx].ip + 1 + ridx; - if (!sal_mem_is_address_valid(mod_addr) || - !sal_is_mod(sal_mem_get_inst(mod_addr))) { + if ( + !sal_mem_is_address_valid(mod_addr) || + !sal_is_mod(sal_mem_get_inst(mod_addr)) + ) { return FALSE; } @@ -704,9 +761,10 @@ static boolean get_register_pointers(uint32 pidx, uint32_p *regs, static void addr(uint32 pidx) { - /* This gets called when an organism has finally found a template and is - ready to store its address. Only when in debug mode, we make sure that the - entire search operation has been performed in a valid way. + /* + * This gets called when an organism has finally found a template and is + * ready to store its address. Only when in debug mode, we make sure that + * the entire search operation has been performed in a valid way. */ uint32_p reg; @@ -726,7 +784,8 @@ static void addr(uint32 pidx) assert(are_templates_complements(next2_addr, g_procs[pidx].sp)); #endif - /* Store address of complement into the given register. + /* + * Store address of complement into the given register. */ if (!get_register_pointers(pidx, ®, 1)) { on_fault(pidx); @@ -740,7 +799,8 @@ static void addr(uint32 pidx) static void free_child_block_of(uint32 pidx) { - /* Free only the 'child' memory block (mb2) of the caller organism. + /* + * Free only the 'child' memory block (mb2) of the caller organism. */ assert(g_is_init); assert(pidx < g_capacity); @@ -753,11 +813,12 @@ static void free_child_block_of(uint32 pidx) static void alloc(uint32 pidx, boolean forward) { - /* Allocate a 'child' memory block of size stored in the first given - register, and save its address into the second given register. This - function is the basis of Salisian reproduction. It's a fairly complicated - function (as the seeker pointer must function in a procedural way), so it's - divided into a series of steps, documented below. + /* + * Allocate a 'child' memory block of size stored in the first given + * register, and save its address into the second given register. This + * function is the basis of Salisian reproduction. It's a fairly complicated + * function (as the seeker pointer must function in a procedural way), so + * it's divided into a series of steps, documented below. */ uint32_p regs[2]; uint32 block_size; @@ -765,9 +826,10 @@ static void alloc(uint32 pidx, boolean forward) assert(pidx < g_capacity); assert(!sal_proc_is_free(pidx)); - /* For this function to work, we need at least two register modifiers. - Then, we check for all possible error conditions. If any error conditions - are found, the instruction faults and returns. + /* + * For this function to work, we need at least two register modifiers. + * Then, we check for all possible error conditions. If any error conditions + * are found, the instruction faults and returns. */ if (!get_register_pointers(pidx, regs, 2)) { on_fault(pidx); @@ -777,7 +839,8 @@ static void alloc(uint32 pidx, boolean forward) block_size = *regs[0]; - /* ERROR 1: requested child block is of size zero. + /* + * ERROR 1: requested child block is of size zero. */ if (!block_size) { on_fault(pidx); @@ -785,7 +848,8 @@ static void alloc(uint32 pidx, boolean forward) return; } - /* ERROR 2: seeker pointer not adjacent to existing child block. + /* + * ERROR 2: seeker pointer not adjacent to existing child block. */ if (g_procs[pidx].mb2s) { uint32 exp_addr; @@ -803,7 +867,8 @@ static void alloc(uint32 pidx, boolean forward) } } - /* No errors were detected. We thus handle all correct conditions. + /* + * No errors were detected. We thus handle all correct conditions. * CONDITION 1: allocation was successful. */ if (g_procs[pidx].mb2s == block_size) { @@ -812,8 +877,9 @@ static void alloc(uint32 pidx, boolean forward) return; } - /* CONDITION 2: seeker pointer has collided with allocated space. We free - child memory block and just continue searching. + /* + * CONDITION 2: seeker pointer has collided with allocated space. We free + * child memory block and just continue searching. */ if (sal_mem_is_allocated(g_procs[pidx].sp)) { if (g_procs[pidx].mb2s) { @@ -824,8 +890,9 @@ static void alloc(uint32 pidx, boolean forward) return; } - /* CONDITION 3: no collision detected; enlarge child memory block and - increment seeker pointer. + /* + * CONDITION 3: no collision detected; enlarge child memory block and + * increment seeker pointer. */ _sal_mem_set_allocated(g_procs[pidx].sp); @@ -839,8 +906,9 @@ static void alloc(uint32 pidx, boolean forward) static void swap(uint32 pidx) { - /* Swap parent and child memory blocks. This function is the basis of - Salisian metabolism. + /* + * Swap parent and child memory blocks. This function is the basis of + * Salisian metabolism. */ assert(g_is_init); assert(pidx < g_capacity); @@ -862,7 +930,8 @@ static void swap(uint32 pidx) static void split(uint32 pidx) { - /* Split child memory block into a new organism. A new baby is born. :-) + /* + * Split child memory block into a new organism. A new baby is born. :-) */ assert(g_is_init); assert(pidx < g_capacity); @@ -881,9 +950,10 @@ static void split(uint32 pidx) static void one_reg_op(uint32 pidx, uint8 inst) { - /* Here we group all 1-register operations. These include incrementing, - decrementing, placing zero or one on a register, and the negation - operation. + /* + * Here we group all 1-register operations. These include incrementing, + * decrementing, placing zero or one on a register, and the negation + * operation. */ uint32_p reg; assert(g_is_init); @@ -928,9 +998,10 @@ static void one_reg_op(uint32 pidx, uint8 inst) static void if_not_zero(uint32 pidx) { - /* Conditional operator. Like in most programming languages, this - instruction is needed to allow organism execution to branch into different - execution streams. + /* + * Conditional operator. Like in most programming languages, this + * instruction is needed to allow organism execution to branch into + * different execution streams. */ uint32_p reg; assert(g_is_init); @@ -953,8 +1024,9 @@ static void if_not_zero(uint32 pidx) static void three_reg_op(uint32 pidx, uint8 inst) { - /* Here we group all 3-register arithmetic operations. These include - addition, subtraction, multiplication and division. + /* + * Here we group all 3-register arithmetic operations. These include + * addition, subtraction, multiplication and division. */ uint32_p regs[3]; assert(g_is_init); @@ -979,7 +1051,9 @@ static void three_reg_op(uint32 pidx, uint8 inst) *regs[0] = *regs[1] * *regs[2]; break; case DIVN: - /* Division by 0 is not allowed and causes a fault. */ + /* + * Division by 0 is not allowed and causes a fault. + */ if (!(*regs[2])) { on_fault(pidx); increment_ip(pidx); @@ -997,16 +1071,19 @@ static void three_reg_op(uint32 pidx, uint8 inst) static void load(uint32 pidx) { - /* Load an instruction from a given address into a specified register. This - is used by organisms during their reproduction cycle. + /* + * Load an instruction from a given address into a specified register. This + * is used by organisms during their reproduction cycle. */ uint32_p regs[2]; assert(g_is_init); assert(pidx < g_capacity); assert(!sal_proc_is_free(pidx)); - if (!get_register_pointers(pidx, regs, 2) || - !sal_mem_is_address_valid(*regs[0])) { + if ( + !get_register_pointers(pidx, regs, 2) || + !sal_mem_is_address_valid(*regs[0]) + ) { on_fault(pidx); increment_ip(pidx); return; @@ -1024,9 +1101,10 @@ static void load(uint32 pidx) static boolean is_writeable_by(uint32 pidx, uint32 address) { - /* Check whether an organisms has writing rights on a specified address. - Any organism may write to any valid address that is either self owned or - not allocated. + /* + * Check whether an organisms has writing rights on a specified address. + * Any organism may write to any valid address that is either self owned or + * not allocated. */ assert(g_is_init); assert(pidx < g_capacity); @@ -1040,23 +1118,28 @@ static boolean is_writeable_by(uint32 pidx, uint32 address) uint32 lo2 = g_procs[pidx].mb2a; uint32 hi1 = lo1 + g_procs[pidx].mb1s; uint32 hi2 = lo2 + g_procs[pidx].mb2s; - return ((address >= lo1 && address < hi1) || - (address >= lo2 && address < hi2)); + return ( + (address >= lo1 && address < hi1) || + (address >= lo2 && address < hi2) + ); } } static void write(uint32 pidx) { - /* Write instruction on a given register into a specified address. This is - used by organisms during their reproduction cycle. + /* + * Write instruction on a given register into a specified address. This is + * used by organisms during their reproduction cycle. */ uint32_p regs[2]; assert(g_is_init); assert(pidx < g_capacity); assert(!sal_proc_is_free(pidx)); - if (!get_register_pointers(pidx, regs, 2) || - !sal_mem_is_address_valid(*regs[0]) || !sal_is_inst(*regs[1])) { + if ( + !get_register_pointers(pidx, regs, 2) || + !sal_mem_is_address_valid(*regs[0]) || !sal_is_inst(*regs[1]) + ) { on_fault(pidx); increment_ip(pidx); return; @@ -1077,7 +1160,8 @@ static void write(uint32 pidx) static void send(uint32 pidx) { - /* Send instruction on given register into the common sender. + /* + * Send instruction on given register into the common sender. */ uint32_p reg; assert(g_is_init); @@ -1102,9 +1186,10 @@ static void send(uint32 pidx) static void receive(uint32 pidx) { - /* Receive a single instruction from the common receiver and store it into - a specified register. In case the receiver is unset, it will return the - NOP0 instruction. + /* + * Receive a single instruction from the common receiver and store it into + * a specified register. In case the receiver is unset, it will return the + * NOP0 instruction. */ uint32_p reg; assert(g_is_init); @@ -1124,8 +1209,9 @@ static void receive(uint32 pidx) static void push(uint32 pidx) { - /* Push value on register into the stack. This is useful as a secondary - memory resource. + /* + * Push value on register into the stack. This is useful as a secondary + * memory resource. */ uint32_p reg; uint32 sidx; @@ -1149,7 +1235,8 @@ static void push(uint32 pidx) static void pop(uint32 pidx) { - /* Pop value from the stack into a given register. + /* + * Pop value from the stack into a given register. */ uint32_p reg; uint32 sidx; @@ -1175,8 +1262,9 @@ static void pop(uint32 pidx) static void proc_cycle(uint32 pidx) { - /* Cycle a process once. Organisms will always execute one instruction per - simulation cycle. + /* + * Cycle a process once. Organisms will always execute one instruction per + * simulation cycle. */ uint8 inst; assert(g_is_init); @@ -1252,16 +1340,18 @@ static void proc_cycle(uint32 pidx) void _sal_proc_cycle(void) { - /* The process module cycle consists of a series of steps, which are needed - to preserve overall correctness. + /* + * The process module cycle consists of a series of steps, which are needed + * to preserve overall correctness. */ assert(g_is_init); assert(module_is_valid()); - /* Iterate through all organisms in the reaper queue. First organism to - execute is the one pointed to by 'g_last' (the one on top of the queue). - Last one to execute is 'g_first'. We go around the circular queue, making - sure to modulo (%) around when iterator goes below zero. + /* + * Iterate through all organisms in the reaper queue. First organism to + * execute is the one pointed to by 'g_last' (the one on top of the queue). + * Last one to execute is 'g_first'. We go around the circular queue, making + * sure to modulo (%) around when iterator goes below zero. */ if (g_count) { uint32 pidx = g_last; @@ -1273,7 +1363,8 @@ void _sal_proc_cycle(void) proc_cycle(pidx); } - /* Kill oldest processes whenever memory gets filled over capacity. + /* + * Kill oldest processes whenever memory gets filled over capacity. */ while (sal_mem_get_allocated() > sal_mem_get_capacity()) { proc_kill(); diff --git a/src/render.c b/src/render.c index a4ed262..66db0c4 100644 --- a/src/render.c +++ b/src/render.c @@ -9,28 +9,31 @@ #define BLOCK_FLAG 0x40 #define IP_FLAG 0x80 -static void apply_flag(uint32 origin, uint32 max_pos, uint32 cell_size, - uint32 address, uint32 flag, uint8_p buffer) -{ +static void apply_flag( + uint32 origin, uint32 max_pos, uint32 cell_size, uint32 address, + uint32 flag, uint8_p buffer +) { if (address >= origin && address < max_pos) { - /* Flag falls inside rendered image. We can 'and' the bit to the - corresponding pixel. + /* + * Flag falls inside rendered image. We can 'and' the bit to the + * corresponding pixel. */ uint32 pixel = (address - origin) / cell_size; buffer[pixel] |= flag; } } -void sal_ren_get_image(uint32 origin, uint32 cell_size, uint32 buff_size, - uint8_p buffer) -{ - /* Render a 1D image of a given section of memory, at a given resolution - (zoom) and store it in a pre-allocated 'buffer'. - - On the Salis python handler we draw memory as a 1D 'image' on the WORLD - page. If we were to render this image directly on python, it would be - excruciatingly slow, as we have to iterate over large areas of memory! - Therefore, this memory module comes with a built-in, super fast renderer. +void sal_ren_get_image( + uint32 origin, uint32 cell_size, uint32 buff_size, uint8_p buffer +) { + /* + * Render a 1D image of a given section of memory, at a given resolution + * (zoom) and store it in a pre-allocated 'buffer'. + * + * On the Salis python handler we draw memory as a 1D 'image' on the WORLD + * page. If we were to render this image directly on python, it would be + * excruciatingly slow, as we have to iterate over large areas of memory! + * Therefore, this memory module comes with a built-in, super fast renderer. */ uint32 i; uint32 max_pos; @@ -40,8 +43,9 @@ void sal_ren_get_image(uint32 origin, uint32 cell_size, uint32 buff_size, assert(buff_size); assert(buffer); - /* We make use of openmp for multi-threaded looping. This allows even - faster render times, wherever openmp is supported. + /* + * We make use of openmp for multi-threaded looping. This allows even faster + * render times, wherever openmp is supported. */ #pragma omp parallel for for (i = 0; i < buff_size; i++) { @@ -68,8 +72,9 @@ void sal_ren_get_image(uint32 origin, uint32 cell_size, uint32 buff_size, buffer[i] |= (uint8)(alloc_flag); } - /* We also iterate through all processes and append extra bit flags to the - rendered image signaling process IP position and memory block limits. + /* + * We also iterate through all processes and append extra bit flags to the + * rendered image signaling process IP position and memory block limits. */ max_pos = origin + (cell_size * buff_size); @@ -78,12 +83,14 @@ void sal_ren_get_image(uint32 origin, uint32 cell_size, uint32 buff_size, if (!sal_proc_is_free(i)) { Process proc = sal_proc_get_proc(i); apply_flag(origin, max_pos, cell_size, proc.ip, IP_FLAG, buffer); - apply_flag(origin, max_pos, cell_size, proc.mb1a, BLOCK_FLAG, - buffer); + apply_flag( + origin, max_pos, cell_size, proc.mb1a, BLOCK_FLAG, buffer + ); if (proc.mb2s) { - apply_flag(origin, max_pos, cell_size, proc.mb2a, BLOCK_FLAG, - buffer); + apply_flag( + origin, max_pos, cell_size, proc.mb2a, BLOCK_FLAG, buffer + ); } } } diff --git a/src/salis.c b/src/salis.c index 32a14b8..102ca49 100644 --- a/src/salis.c +++ b/src/salis.c @@ -9,8 +9,9 @@ static uint32 g_epoch; void sal_main_init(uint32 order) { - /* Initialize all Salis modules to their initial states. We pass along any - arguments to their respective modules. + /* + * Initialize all Salis modules to their initial states. We pass along any + * arguments to their respective modules. */ assert(!g_is_init); _sal_mem_init(order); @@ -21,10 +22,11 @@ void sal_main_init(uint32 order) void sal_main_quit(void) { - /* Reset Salis and all of its modules back to zero. We may, thus, shutdown - Salis and re-initialize it with different parameters without having to - reload the library (useful, for example, when running data gathering - scripts that must iterate through many save files). + /* + * Reset Salis and all of its modules back to zero. We may, thus, shutdown + * Salis and re-initialize it with different parameters without having to + * reload the library (useful, for example, when running data gathering + * scripts that must iterate through many save files). */ assert(g_is_init); _sal_proc_quit(); @@ -37,8 +39,9 @@ void sal_main_quit(void) void sal_main_load(string file_name) { - /* Load simulation state from file. This file must have been created by - 'sal_main_save()'. + /* + * Load simulation state from file. This file must have been created by + * 'sal_main_save()'. */ FILE *file; assert(!g_is_init); @@ -56,9 +59,10 @@ void sal_main_load(string file_name) void sal_main_save(string file_name) { - /* Save simulation state to a file. This file may later be re-loaded with - 'sal_main_load()'. We save in binary format (to save space), which means - save files might not be entirely portable. + /* + * Save simulation state to a file. This file may later be re-loaded with + * 'sal_main_load()'. We save in binary format (to save space), which means + * save files might not be entirely portable. */ FILE *file; assert(g_is_init); @@ -76,21 +80,24 @@ void sal_main_save(string file_name) boolean sal_main_is_init(void) { - /* Check if Salis is currently initialized/running. + /* + * Check if Salis is currently initialized/running. */ return g_is_init; } -/* Getter methods for the Salis main module. +/* +* Getter methods for the Salis main module. */ UINT32_GETTER(main, cycle) UINT32_GETTER(main, epoch) void sal_main_cycle(void) { - /* Cycle the Salis simulator once. The combination of a cycle * epoch - counter allows us to track simulations for an insane period of time - (2^64 cycles). + /* + * Cycle the Salis simulator once. The combination of a cycle * epoch + * counter allows us to track simulations for an insane period of time + * (2^64 cycles). */ g_cycle++; @@ -98,7 +105,8 @@ void sal_main_cycle(void) g_epoch++; } - /* Cycle all of the Salis modules. + /* + * Cycle all of the Salis modules. */ _sal_mem_cycle(); _sal_evo_cycle(); |