Merge pull request #15 from SidoShiro/leader-feature-3

Leader feature 3

Author: SidoShiro

include/block.h

@@ -1,24 +1,65 @@
 #ifndef DISTRIBUTEDMALLOC_BLOCK_H
 #define DISTRIBUTEDMALLOC_BLOCK_H
 
-#include "stdlib.h"
+#include <stdlib.h>
+#include <stdio.h>
 
+/**
+ * size of block
+ * address on id node
+ * address virtual (user view)
+ * next block
+ * free : 0 is free, 1 is allocated
+ */
 struct block {
     unsigned short id;
     size_t size;
-    size_t address;
+    size_t node_address;
+    size_t virtual_address;
     struct block *next;
+    char free;
 };
 
-struct blocks {
+struct block_register {
     size_t nb_blocks;
     struct block **blks;
 };
 
-struct blocks *generate_blocks(size_t nb_blks);
+struct allocation_register {
+    size_t size_alloc;
+    size_t count_alloc;
+    struct allocation **allocs;
+};
+
+struct allocation {
+    size_t number_parts;
+    size_t v_address_start;
+    struct block **parts;
+};
+
+struct allocation_register *generate_allocs(size_t size_alloc);
+
+void add_allocation(struct allocation_register *a_r, struct allocation *a);
+
+struct block_register *init_nodes_same_size(unsigned short nb_nodes, size_t size);
+
+struct block_register *generate_blocks(size_t nb_blks);
+
+struct block *generate_block(unsigned short id, size_t size, size_t node_address, size_t virtual_address, char free);
+
+void
+add_block(struct block *blk, unsigned short id, size_t size, size_t node_address, size_t virtual_address, char free);
+
+void merge_free_block(struct block_register *blks);
 
-struct block *generate_block(unsigned short id, size_t size, size_t address);
+struct block_register *init_nodes_same_size(unsigned short nb_nodes, size_t size);
 
-void add_block(struct block blk, unsigned short id, size_t size, size_t address);
+/**
+ * Splited half 2 is free = 0
+ * @param b
+ * @param size
+ * @return
+ */
+struct block *split_block_u(struct block *b, size_t size);
 
 #endif /* !DISTRIBUTEDMALLOC_BLOCK_H */

include/leader.h

@@ -9,17 +9,20 @@
 #include "block.h"
 
 struct leader_resources {
-    struct blocks *leader_blks;
+    struct block_register *leader_blks;
+    struct allocation_register  *leader_reg;
     struct command_queue *leader_command_queue;
+    // unsigned short id;
 };
 
 struct address_search {
     unsigned short id;
-    size_t address_r;
-    size_t address;
+    size_t r_address;
+    size_t v_address;
+    size_t n_address;
     size_t size;
 };
 
-void leader_loop(struct node *n, unsigned short terminal_id);
+void leader_loop(struct node *n, unsigned short terminal_id, unsigned short nb_nodes);
 
 #endif /* !DISTRIBUTEDMALLOC_LEADER_H */

run.sh

@@ -1,3 +1,4 @@
+rm -rf build/*
 cd build
 cmake ..
 make -j 6

src/cli/cli.c

@@ -106,6 +106,7 @@ void execute(char **args, unsigned short leader) {
             printf("Execute DMALLOC of %zu\n", size);
             struct data_size *d_s = generate_data_size(size);
             send_command(OP_MALLOC, d_s, leader);
+            free(d_s);
         } else {
             error_msg("m  require an argument 'size' which can be casted as a positive integer");
         }
@@ -144,6 +145,7 @@ void execute(char **args, unsigned short leader) {
                 printf("Execute Write at %zu of %s : %zu bytes\n", address, args[3], datasize);
                 struct data_write *d_w = generate_data_write(address, datasize, args[3]);
                 send_command(OP_WRITE, d_w, leader);
+                free(d_w);
             } else {
                 error_msg("w requires an argument 'datasize' which can be casted as a positive integer");
             }
@@ -168,6 +170,7 @@ void execute(char **args, unsigned short leader) {
                 printf("Execute Read at %zu, %zu bytes\n", address, datasize);
                 struct data_read *d_r = generate_data_read(address, datasize);
                 send_command(OP_READ, d_r, leader);
+                free(d_r);
             } else {
                 error_msg("r requires an argument 'datasize' which can be casted as a positive integer");
             }

src/cli/user.c

@@ -18,7 +18,6 @@ void send_write(void *data, unsigned short leader) {
     debug("Send Data For Write OP", 0);
     MPI_Isend(d_w->data, d_w->size, MPI_BYTE, m->id_t, 0, MPI_COMM_WORLD, &r);
     free(m);
-    free(data);
 }
 
 void send_malloc(void *data, unsigned short leader) {
@@ -35,15 +34,23 @@ void send_malloc(void *data, unsigned short leader) {
     MPI_Request r2;
     void *buff = generate_message(0, 0, 0, 0, 0, OP_NONE);
     MPI_Irecv(buff, sizeof(struct message), MPI_BYTE, leader, 0, MPI_COMM_WORLD, &r2);
+    /*
     while (0 != MPI_Wait(&r, &st)) {
         char *msg = "Address from malloc operation of size ";
         char size_str[256];
         snprintf(size_str, sizeof(size_str), "%zu", d_s->size);
         strcat(msg, size_str);
         debug(msg, DEF_NODE_USER);
     }
+    */
+    if (0 == MPI_Wait(&r2, &st)) {
+        struct message *m2 = buff;
+        printf("user: request malloc of size %zu, is at address %zu on the network\n",
+                m2->size,
+                m2->address);
+    }
     free(m);
-    free(data);
+    free(buff);
 }
 
 void send_read(void *data, unsigned short leader) {
@@ -68,7 +75,6 @@ void send_read(void *data, unsigned short leader) {
         debug(msg, DEF_NODE_USER);
     }
     free(m);
-    free(data);
 }
 
 void send_command(enum operation op, void *data, unsigned short leader) {

src/main/main.c

@@ -53,7 +53,7 @@ int main(int argc, char **argv) {
         // Start Leader !
         if (n->id == leader) {
             n->isleader = 1;
-            leader_loop(n, DEF_NODE_USER);
+            leader_loop(n, DEF_NODE_USER, size - 1);
         }
 
         /*

src/network/block.c

@@ -1,24 +1,78 @@
 #include "block.h"
 
 
-struct blocks *generate_blocks(size_t nb_blks) {
-    struct blocks *blks = malloc(sizeof(struct blocks));
-    blks->blks = malloc(nb_blks * sizeof(struct block*));
+struct block_register *generate_blocks(size_t nb_blks) {
+    struct block_register *blks = malloc(sizeof(struct block_register));
+    blks->blks = malloc(nb_blks * sizeof(struct block *));
     blks->nb_blocks = nb_blks;
     return blks;
 }
 
-struct block *generate_block(unsigned short id, size_t size, size_t address) {
+struct block *generate_block(unsigned short id, size_t size, size_t node_address,
+                             size_t virtual_address, char free) {
     struct block *blk = malloc(sizeof(struct block));
     blk->id = id;
     blk->size = size;
-    blk->address = address;
+    blk->node_address = node_address;
+    blk->virtual_address = virtual_address;
+    blk->free = free;
     blk->next = NULL;
     return blk;
 }
 
-void add_block(struct block blk, unsigned short id, size_t size, size_t address) {
-    struct block *n_blk = generate_block(id, size, address);
-    blk.next = n_blk;
+void add_block(struct block *blk, unsigned short id, size_t size, size_t node_address,
+               size_t virtual_address, char free) {
+    struct block *n_blk = generate_block(id, size, node_address, virtual_address, free);
+    blk->next = n_blk;
     (void) blk;
 }
+
+void merge_free_block(struct block_register *blks);
+
+struct block_register *init_nodes_same_size(unsigned short nb_nodes, size_t size) {
+    struct block_register *blks = generate_blocks(nb_nodes);
+    size_t v_address = 0;
+    for (size_t i = 0; i < blks->nb_blocks; i++) {
+        // Skip 0 (user), so from 1 to nb_nodes + 1
+        blks->blks[i] = generate_block(i + 1, size, 0, v_address, 0);
+        v_address += size;
+    }
+    printf("Global init has memory size of %zu bytes", v_address);
+    return blks;
+}
+
+struct block *split_block_u(struct block *b, size_t size) {
+    if (!b) {
+        printf("FATAL ALLOCATION ERROR\n");
+    }
+    if (b->size < size) {
+        b->size = size;
+        size_t su = size - b->size;
+        struct block *b_next = b->next;
+        add_block(b, b->id, su, b->node_address + size, b->virtual_address + size, 0);
+        b->next->next = b_next;
+        return b;
+    }
+    return NULL;
+}
+
+struct allocation_register *generate_allocs(size_t size_alloc) {
+    struct allocation_register *a = malloc(sizeof(struct allocation_register));
+    a->size_alloc = size_alloc;
+    a->count_alloc = 0;
+    a->allocs = malloc(sizeof(struct allocation) * size_alloc);
+    return a;
+}
+
+void add_allocation(struct allocation_register *a_r, struct allocation *a) {
+    if (a_r->count_alloc >= a_r->size_alloc) {
+        a_r->allocs[a_r->count_alloc] = a;
+    } else {
+        // x2 size
+        a_r->size_alloc = a_r->size_alloc * 2;
+        a_r->allocs = realloc(a_r->allocs, a_r->size_alloc * sizeof(struct allocation));
+
+    }
+    a_r->allocs[a_r->count_alloc] = a;
+    a_r->count_alloc++;
+}