leader: block: changes in block structs, add allocation struct, many changes and new functions, still segfault malloc

Author: SidoShiro

include/block.h

@@ -20,22 +20,46 @@ struct block {
     char free;
 };
 
-struct blocks {
+struct block_register {
     size_t nb_blocks;
     struct block **blks;
 };
 
-struct blocks *init_nodes_same_size(unsigned short nb_nodes, size_t size);
+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 blocks *generate_blocks(size_t nb_blks);
+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 blocks *blks);
+void merge_free_block(struct block_register *blks);
+
+struct block_register *init_nodes_same_size(unsigned short nb_nodes, size_t size);
 
-struct blocks *init_nodes_same_size(unsigned short nb_nodes, size_t size);
+/**
+ * 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,8 +9,10 @@
 #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 {

src/network/block.c

@@ -1,15 +1,15 @@
 #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 node_address,
-        size_t virtual_address, char free) {
+                             size_t virtual_address, char free) {
     struct block *blk = malloc(sizeof(struct block));
     blk->id = id;
     blk->size = size;
@@ -27,11 +27,11 @@ void add_block(struct block *blk, unsigned short id, size_t size, size_t node_ad
     (void) blk;
 }
 
-void merge_free_block(struct blocks *blks);
+void merge_free_block(struct block_register *blks);
 
-struct blocks *init_nodes_same_size(unsigned short nb_nodes, size_t size) {
-    struct blocks *blks = generate_blocks(nb_nodes);
-    size_t  v_address = 0;
+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);
@@ -40,3 +40,39 @@ struct blocks *init_nodes_same_size(unsigned short nb_nodes, size_t 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++;
+}

src/network/leader.c

@@ -6,28 +6,76 @@
 
 #include <mpi.h>
 
-struct leader_resources *generate_leader_resources(size_t nb_nodes) {
+struct leader_resources *generate_leader_resources(size_t nb_nodes /*, struct node *n*/) {
     struct leader_resources *l_r = malloc(sizeof(struct leader_resources));
     l_r->leader_blks = init_nodes_same_size(nb_nodes, 8);
     l_r->leader_command_queue = NULL;
+    l_r->leader_reg = generate_allocs(4);
+    //l_r->id = n->id;
     return l_r;
 }
 
+int check_block_for_alloc(size_t  *res_addr, struct block *b, size_t size, struct leader_resources *l_r) {
+    if (0 == b->free) {
+        if (size == b->size) {
+            b->free = 1;
+            struct allocation *a = malloc(sizeof(struct allocation));
+            a->number_parts = 1;
+            a->v_address_start = b->virtual_address;
+            a->parts = malloc(a->number_parts * sizeof(struct allocation*));
+            a->parts[0] = b;
+            add_allocation(l_r->leader_reg, a);
+            *res_addr = b->virtual_address;
+            return 1;
+        }
+        else if (size < b->size) {
+            b->free = 1;
+            b = split_block_u(b, size);
+            struct allocation *a = malloc(sizeof(struct allocation));
+            a->number_parts = 1;
+            a->v_address_start = b->virtual_address;
+            a->parts = malloc(a->number_parts * sizeof(struct allocation*));
+            a->parts[0] = b;
+            add_allocation(l_r->leader_reg, a);
+            *res_addr = b->virtual_address;
+            return 1;
+        }
+        else {
+
+        }
+
+    }
+    return 0;
+}
+
 /**
  * Allocated memory for the User, using free space of nodes
+ * | X1 |     |  X2 | X1 |
  * @param size
  * @param l_r
  * @return 1 if okay, 0 if no blocks possible for this size
  */
-int alloc_memory(size_t size, struct leader_resources *l_r) {
-    struct blocks *blks = l_r->leader_blks;
-    (void) blks;
-    (void) size;
+size_t alloc_memory(size_t size, struct leader_resources *l_r) {
+    struct block_register *blks = l_r->leader_blks;
+    if (!blks && blks->nb_blocks > 0) {
+        debug("ERROR not malloc blockS !!!", 0); //l_r->id);
+        return 999;
+    }
+    size_t address = 0;
+    for (size_t i = 0; i < blks->nb_blocks; i++) {
+        struct block *b = blks->blks[i];
+        if (!b) {
+            debug("ERROR not malloc block !!!", 0); // l_r->id);
+            return 1999;
+        }
+        if (1 == check_block_for_alloc(&address, b, size, l_r))
+            return address;
+    }
     return 0;
 }
 
 struct address_search *search_at_address(size_t address, struct leader_resources *l_r) {
-    struct blocks *bs = l_r->leader_blks;
+    struct block_register *bs = l_r->leader_blks;
     for (size_t i = 0; i < bs->nb_blocks; i++) {
         struct block *b = bs->blks[i];
         if (b->virtual_address >= address && b->virtual_address + b->size < address) {
@@ -101,8 +149,25 @@ void get_command(struct node *n, struct leader_resources *l_r, unsigned short us
 }
 
 void execute_malloc(struct node *n, struct leader_resources *l_r) {
-    (void) n;
-    (void) l_r;
+    struct data_size *d_s = peek_command(l_r->leader_command_queue);
+    if (!d_s) {
+        debug("ERROR allocation data_size for OP MALLOC execution [LEADER]", n->id);
+    }
+    size_t  v_addr = alloc_memory(d_s->size, l_r);
+    if (v_addr == 999 || v_addr == 1999) {
+        debug("FATAL ERROR", n->id);
+        if (v_addr == 1999) {
+            debug("SEC", n->id);
+        }
+        return;
+    }
+    debug("Allocation at ", n->id);
+    printf("%zu\n", v_addr);
+    struct message *m = generate_message(n->id, DEF_NODE_USER, DEF_NODE_USER, v_addr, d_s->size, OP_MALLOC);
+
+    MPI_Request r;
+    MPI_Isend((void *) m, sizeof(struct message), MPI_BYTE, m->id_t, 0, MPI_COMM_WORLD, &r);
+    free(m);
 }
 
 void execute_read(struct node *n, struct leader_resources *l_r) {
@@ -128,14 +193,18 @@ void execute_command(struct node *n, struct leader_resources *l_r) {
 
         switch (peek_user_command(l_r->leader_command_queue)) {
             case OP_MALLOC:
+                debug("EXECUTE OP MALLOC LEADER", n->id);
                 execute_malloc(n, l_r);
                 break;
             case OP_FREE:
+                debug("EXECUTE OP FREE LEADER", n->id);
                 break;
             case OP_WRITE:
+                debug("EXECUTE OP WRITE LEADER", n->id);
                 execute_write(n, l_r);
                 break;
             case OP_READ:
+                debug("EXECUTE OP READ LEADER", n->id);
                 execute_read(n, l_r);
                 break;
             case OP_DUMP:
@@ -153,13 +222,19 @@ void execute_command(struct node *n, struct leader_resources *l_r) {
             default:
                 break;
         }
+        pop_command(l_r->leader_command_queue);
     }
 }
 
 
 void leader_loop(struct node *n, unsigned short terminal_id, unsigned short nb_nodes) {
     // Init leader resource
-    struct leader_resources *l_r = generate_leader_resources(nb_nodes);
+    struct leader_resources *l_r = generate_leader_resources(nb_nodes/*, n*/);
+
+    for (size_t  i = 0; i < l_r->leader_blks->nb_blocks; i++) {
+        struct block *b = l_r->leader_blks->blks[i];
+        printf("%u\n", b->id);
+    }
 
     /*
     // MPI_Isend();
@@ -176,10 +251,10 @@ void leader_loop(struct node *n, unsigned short terminal_id, unsigned short nb_n
     while (1) {
         // Get command from user
         get_command(n, l_r, terminal_id);
-
+        debug("COMMANDS LISTEN DONE", n->id);
         // Execute Commands
         execute_command(n, l_r);
-
+        debug("COMMANDS EXEC DONE", n->id);
         // Break on death
         if (die == 1)
             break;