leader: update malloc operation, update leader_loop

Author: SidoShiro

src/network/leader.c

@@ -3,46 +3,51 @@
 #include "globals.h"
 #include "message.h"
 #include "debug.h"
+#include "utils.h"
 
 #include <mpi.h>
 
-struct leader_resources *generate_leader_resources(size_t nb_nodes /*, struct node *n*/) {
-    struct leader_resources *l_r = malloc(sizeof(struct leader_resources));
+size_t get_message_size() {
+    return (sizeof(unsigned short) * 3 + 2 * sizeof(size_t) + sizeof(enum operation));
+}
+
+struct leader_resources *generate_leader_resources(size_t nb_nodes, size_t id) {
+    struct leader_resources *l_r = malloc(128);
     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;
+    l_r->id = id;
     return l_r;
 }
 
-int check_block_for_alloc(size_t  *res_addr, struct block *b, size_t size, struct leader_resources *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 = 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) {
+        } else if (size < b->size) {
             b->free = 1;
             b = split_block_u(b, size);
             if (b) {
-                struct allocation *a = malloc(sizeof(struct allocation));
+                struct allocation *a = malloc(32 + 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 = malloc(34 + (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 {
+                debug("Fatal Error, split invalid or memory error", 1);
             }
-        }
-        else {
+        } else {
 
         }
 
@@ -63,15 +68,42 @@ size_t alloc_memory(size_t size, struct leader_resources *l_r) {
         debug("ERROR not malloc blockS !!!", 0); //l_r->id);
         return 999;
     }
-    size_t address = 0;
+    // Single Part
     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;
+        while (b != NULL) {
+            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);
+                    return b->virtual_address;
+                } else if (size < b->size) {
+                    b->free = 1;
+                    b = split_block_u(b, size);
+                    if (b) {
+                        struct allocation *a = malloc(32 + sizeof(struct allocation));
+                        a->number_parts = 1;
+                        a->v_address_start = b->virtual_address;
+                        a->parts = malloc(34 + (a->number_parts * sizeof(struct allocation *)));
+                        a->parts[0] = b;
+                        add_allocation(l_r->leader_reg, a);
+                        return b->virtual_address;
+                    } else {
+                        debug("Fatal Error, split invalid or memory error", 1);
+                    }
+                }
+            }
+            b = b->next;
         }
-        if (1 == check_block_for_alloc(&address, b, size, l_r))
-            return address;
+    }
+    // Multi - Parts
+    for (size_t i = 0; i < blks->nb_blocks; i++) {
+        
     }
     return 999999999;
 }
@@ -94,68 +126,69 @@ struct address_search *search_at_address(size_t address, struct leader_resources
 }
 
 
-void get_command(struct node *n, struct leader_resources *l_r, unsigned short user) {
+void get_command(struct leader_resources *l_r, unsigned short user) {
     // int MPI_Irecv(void *buf, int count, MPI_Datatype datatype, int source,
     //              int tag, MPI_Comm comm, MPI_Request *request);
-    void *buff = malloc(sizeof(struct message));
+    struct message buff;
     int count = sizeof(struct message);
     MPI_Request r;
     MPI_Status st;
-    MPI_Irecv(buff, count, MPI_BYTE, MPI_ANY_SOURCE, 0, MPI_COMM_WORLD, &r);
+    MPI_Irecv(&buff, count, MPI_BYTE, MPI_ANY_SOURCE, 0, MPI_COMM_WORLD, &r);
 
     if (0 == MPI_Wait(&r, &st)) {
-        struct message *m = buff;
+        struct message *m = &buff;
         struct command_queue *n_command = generate_command_queue(m->op, NULL);
         switch (m->op) {
             case OP_OK:
-                debug("Leader recv OP OK from User", n->id);
+                debug("Leader recv OP OK from User", l_r->id);
                 break;
             case OP_WRITE:
-                debug("Leader recv OP WRITE from User", n->id);
+                debug("Leader recv OP WRITE from User", l_r->id);
                 n_command->command = m->op;
                 n_command->data = NULL;
                 struct data_write *d_w = generate_data_write(m->size, m->size, NULL);
                 void *wbuff = malloc(sizeof(char) * (m->size + 1));
-                debug("Leader wait DATA from User for OP WRITE", n->id);
+                debug("Leader wait DATA from User for OP WRITE", l_r->id);
                 MPI_Irecv(wbuff, m->size * sizeof(char), MPI_BYTE, user, 0, MPI_COMM_WORLD, &r);
                 if (0 == MPI_Wait(&r, &st)) {
                     d_w->data = wbuff;
                     n_command->data = d_w;
                 }
-                debug("Leader recv DATA from User for OP WRITE : ", n->id);
-                debug_n(d_w->data, n->id, d_w->size);
+                debug("Leader recv DATA from User for OP WRITE : ", l_r->id);
+                debug_n(d_w->data, l_r->id, d_w->size);
                 l_r->leader_command_queue = push_command(l_r->leader_command_queue, n_command);
                 break;
             case OP_READ:
-                debug("Leader recv OP READ from User", n->id);
+                debug("Leader recv OP READ from User", l_r->id);
                 n_command->command = m->op;
                 n_command->data = NULL;
                 struct data_read *d_r = generate_data_read(m->address, m->size);
                 n_command->data = d_r;
                 l_r->leader_command_queue = push_command(l_r->leader_command_queue, n_command);
                 break;
             case OP_MALLOC:
-                debug("Leader recv OP MALLOC from User", n->id);
+                debug("Leader recv OP MALLOC from User", l_r->id);
                 n_command->command = m->op;
                 n_command->data = NULL;
                 struct data_size *d_s = generate_data_size(m->size);
                 n_command->data = d_s;
                 l_r->leader_command_queue = push_command(l_r->leader_command_queue, n_command);
                 break;
             default:
-                debug("Leader recv ANY OP from User", n->id);
+                debug("Leader recv ANY OP from User", l_r->id);
                 break;
         }
     }
-    free(buff);
+    //free(buff);
 }
 
 void execute_malloc(struct node *n, struct leader_resources *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);
+    size_t v_addr = alloc_memory(d_s->size, l_r);
+    size_t sss = d_s->size;
     if (v_addr == 999 || v_addr == 1999) {
         debug("FATAL ERROR", n->id);
         if (v_addr == 1999) {
@@ -164,12 +197,15 @@ void execute_malloc(struct node *n, struct leader_resources *l_r) {
         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);
+    printf("%zu of %zu bytes\n", v_addr, sss);
+    if (n->id != l_r->id) {
+        debug("WTFFFFFFFFFFFFFFFFFFFf", n->id);
+    } else {
+        struct message *m = generate_message(l_r->id, DEF_NODE_USER, DEF_NODE_USER, v_addr, sss, 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) {
@@ -231,9 +267,24 @@ void execute_command(struct node *n, struct leader_resources *l_r) {
 
 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/*, n*/);
+    printf("NB NODES :%d,", nb_nodes);
+
+    printf("NB NODES :%d,", nb_nodes);
+    void *k = malloc(sizeof(struct message));
+    (void) k;
+    debug("START LEADER LOOP", n->id);
+    struct leader_resources *l_r = generate_leader_resources(nb_nodes, n->id);
 
-    for (size_t  i = 0; i < l_r->leader_blks->nb_blocks; i++) {
+    debug("PASS LEADER_RESOURCES", n->id);
+    for (size_t o = 0; o < 1; o++) {
+        // void *g =generate_message(0, DEF_NODE_USER, DEF_NODE_USER, 0, 0, OP_MALLOC);
+        // (void)g;
+        void *jj = malloc(48); //
+        // sizeof(struct message));
+        (void) jj;
+    }
+
+    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);
     }
@@ -245,18 +296,18 @@ void leader_loop(struct node *n, unsigned short terminal_id, unsigned short nb_n
     // MPI_Irecv();
     // MPI_Wait();
     // MPI_Test();
-
     int MPI_Irecv(void *buf, int count, MPI_Datatype datatype, int source,
                   int tag, MPI_Comm comm, MPI_Request *request);
     */
     int die = -1;
     while (1) {
+        print_allocations_table(l_r);
         // Get command from user
-        get_command(n, l_r, terminal_id);
-        debug("COMMANDS LISTEN DONE", n->id);
+        get_command(l_r, terminal_id);
+        // debug("COMMANDS LISTEN DONE", n->id);
         // Execute Commands
         execute_command(n, l_r);
-        debug("COMMANDS EXEC DONE", n->id);
+        // debug("COMMANDS EXEC DONE", n->id);
         // Break on death
         if (die == 1)
             break;