Commiting v1 into the new repo

.gitignore

+resource_manager/bin/**
+

.gitmodules

+[submodule "resource_manager/src/common/cJSON"]
+	path = resource_manager/src/common/cJSON
+	url = https://github.com/DaveGamble/cJSON

resource_manager/README

+Dependency: Clang compiler
+
+1. Clone using "git clone --recursive https://namandixit@git.cse.iitb.ac.in/namandixit/FaaS-Tactician.git"
+2. Run "build.linux" script to compile the project.

resource_manager/build.linux

+#!/usr/bin/env bash
+
+if [ -z ${BuildPlatform+x} ]; then
+    BuildPlatform=linux
+fi
+
+if [ -z ${BuildArchitecture+x} ]; then
+    BuildArchitecture=x64
+fi
+
+ProjectRoot="$( cd "$(dirname "$0")" ; pwd -P)" # Directory in which the script is located
+cd ${ProjectRoot}
+echo "Entering directory \`$(pwd)'"
+
+BuildDirectory="bin/${BuildPlatform}/${BuildArchitecture}"
+mkdir -p ${BuildDirectory}
+
+VersionNumberOld=$(< ./version.linux)
+VersionNumber=$((${VersionNumberOld} + 1))
+echo ${VersionNumber} > ./version.linux
+
+# .....................................................................
+# BUILD
+# `````````````````````````````````````````````````````````````````````
+
+Compiler="clang"
+
+# Compile Arbiter =====================================================
+
+ArbiterSource=${ProjectRoot}/src/arbiter/arbiter.c
+ArbiterTarget=arbiter
+ArbiterTargetPath="bin/${BuildPlatform}/${BuildArchitecture}/${ArbiterTarget}"
+
+if [ -f "${ArbiterTargetPath}" ]; then
+    rm "${ArbiterTargetPath}"
+fi
+
+# For Address Sanitizer: -fsanitize=address -fno-omit-frame-pointer
+#     Memory Sanitizer : -fsanitize=memory -fno-optimize-sibling-calls -fno-omit-frame-pointer -fsanitize-memory-track-origins
+
+ArbiterCompilerFlags="-iquote /code/include -iquote ${ProjectRoot}/src \
+                      -iquote ${ProjectRoot}/src/common \
+                      -g3 -O0 -fno-strict-aliasing -fwrapv -msse2 \
+                     "
+ArbiterLanguageFlags="--std=c11 -DBUILD_INTERNAL -DBUILD_SLOW -DBUILD_DEBUG \
+                      -DBUILD_NUMBER=${NEW_BUILD_NUMBER}                    \
+                      -D_POSIX_C_SOURCE=200809L -D_DEFAULT_SOURCE"
+ArbiterWarningFlags="-Weverything -Wpedantic -pedantic-errors -Werror \
+                     -Wno-c++98-compat -Wno-gnu-statement-expression \
+                     -Wno-bad-function-cast -Wno-unused-function \
+                     -Wno-padded "
+ArbiterLinkerFlags="-o ${ArbiterTargetPath} \
+                    -static-libgcc -lm -pthread \
+                    -Wl,-rpath=\${ORIGIN} -Wl,-z,origin -Wl,--enable-new-dtags"
+
+${Compiler} ${ArbiterCompilerFlags} ${ArbiterLanguageFlags} ${ArbiterWarningFlags} \
+            ${ArbiterSource} \
+            ${ArbiterLinkerFlags}
+
+# Compile Grunt =====================================================
+
+GruntSource=${ProjectRoot}/src/grunt/grunt.c
+GruntTarget=grunt
+GruntTargetPath="bin/${BuildPlatform}/${BuildArchitecture}/${GruntTarget}"
+
+if [ -f "${GruntTargetPath}" ]; then
+    rm "${GruntTargetPath}"
+fi
+
+# For Address Sanitizer: -fsanitize=address -fno-omit-frame-pointer
+#     Memory Sanitizer : -fsanitize=memory -fno-optimize-sibling-calls -fno-omit-frame-pointer -fsanitize-memory-track-origins
+
+GruntCompilerFlags="-iquote /code/include -iquote ${ProjectRoot}/src \
+                    -iquote ${ProjectRoot}/src/common \
+                    -g3 -O0 -fno-strict-aliasing -fwrapv -msse2 \
+                    "
+GruntLanguageFlags="--std=c11 -DBUILD_INTERNAL -DBUILD_SLOW -DBUILD_DEBUG \
+                    -DBUILD_NUMBER=${NEW_BUILD_NUMBER}                    \
+                    -D_POSIX_C_SOURCE=200809L -D_DEFAULT_SOURCE"
+GruntWarningFlags="-Weverything -Wpedantic -pedantic-errors -Werror \
+                   -Wno-c++98-compat -Wno-gnu-statement-expression \
+                   -Wno-bad-function-cast -Wno-unused-function \
+                   -Wno-padded "
+GruntLinkerFlags="-o ${GruntTargetPath} \
+                  -static-libgcc -lm -pthread \
+                  -Wl,-rpath=\${ORIGIN} -Wl,-z,origin -Wl,--enable-new-dtags"
+
+${Compiler} ${GruntCompilerFlags} ${GruntLanguageFlags} ${GruntWarningFlags} \
+            ${GruntSource} \
+            ${GruntLinkerFlags}
+
+# Compile Test =====================================================
+
+TestSource=${ProjectRoot}/src/test/test.c
+TestTarget=test
+TestTargetPath="bin/${BuildPlatform}/${BuildArchitecture}/${TestTarget}"
+
+if [ -f "${TestTargetPath}" ]; then
+    rm "${TestTargetPath}"
+fi
+
+# For Address Sanitizer: -fsanitize=address -fno-omit-frame-pointer
+#     Memory Sanitizer : -fsanitize=memory -fno-optimize-sibling-calls -fno-omit-frame-pointer -fsanitize-memory-track-origins
+
+TestCompilerFlags="-iquote /code/include -iquote ${ProjectRoot}/src \
+                    -iquote ${ProjectRoot}/src/common \
+                    -g3 -O0 -fno-strict-aliasing -fwrapv -msse2 \
+                    "
+TestLanguageFlags="--std=c11 -DBUILD_INTERNAL -DBUILD_SLOW -DBUILD_DEBUG \
+                    -DBUILD_NUMBER=${NEW_BUILD_NUMBER}                    \
+                    -D_POSIX_C_SOURCE=200809L -D_DEFAULT_SOURCE"
+TestWarningFlags="-Weverything -Wpedantic -pedantic-errors -Werror \
+                   -Wno-c++98-compat -Wno-gnu-statement-expression \
+                   -Wno-bad-function-cast -Wno-unused-function \
+                   -Wno-padded "
+TestLinkerFlags="-o ${TestTargetPath} \
+                  -static-libgcc -lm -pthread \
+                  -Wl,-rpath=\${ORIGIN} -Wl,-z,origin -Wl,--enable-new-dtags"
+
+${Compiler} ${TestCompilerFlags} ${TestLanguageFlags} ${TestWarningFlags} \
+            ${TestSource} \
+            ${TestLinkerFlags}

resource_manager/src/arbiter/arbiter.c

+/*
+ * Creator: Naman Dixit
+ * Notice: © Copyright 2020 Naman Dixit
+ */
+
+#include "nlib/nlib.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/socket.h>
+#include <sys/epoll.h>
+#include <netdb.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <sys/time.h>
+#include <arpa/inet.h>
+
+#define MAX_SOCKET_CONNECTIONS_REQUEST 64
+#define MAX_EPOLL_EVENTS 1024
+
+typedef struct Input_Resume {
+    Char *buffer;
+    Size buffer_len;
+    Size buffer_cap;
+    U32 buffer_expected_len;
+
+    Byte size_bytes[4];
+    Size size_bytes_count;
+
+    int fd;
+    B32 initialized;
+} Input_Resume;
+
+typedef struct Output_Resume {
+    Char *buffer;
+    Size buffer_pos;
+    Size buffer_len;
+
+    U64 msg_id_hash;
+
+    Sint fd;
+
+    Byte _pad[4];
+} Output_Resume;
+
+typedef struct Input_Output {
+    Input_Resume *ir;
+    Output_Resume *ors;
+} Input_Output;
+
+typedef struct Grunt {
+    Char *ip;
+    Sint memory;
+} Grunt;
+
+typedef struct Grunt_Survey {
+    Char **ips;
+    U64 milli_passed;
+    U64 milli_last;
+    Sint id;
+    Sint dispatcher_socket;
+} Grunt_Survey;
+
+typedef struct Command {
+    enum Command_Kind {
+        Command_NONE,
+        Command_REQUEST_EXTERNAL,
+        Command_REQUEST_INTERNAL,
+        Command_RESPONSE_INTERNAL,
+        Command_RESPONSE_EXTERNAL,
+        Command_HEARTBEAT,
+    } kind;
+
+    Sint id;
+
+    union {
+        struct {
+            Sint memory;
+        } reqex;
+
+        struct {
+            Sint memory;
+            Sint dispatcher_socket;
+        } reqin;
+
+        struct {
+            Char **ips;
+            Sint dispatcher_socket;
+        } resin;
+
+        struct {
+            Char **ips;
+            Sint dispatcher_socket;
+        } resex;
+
+        struct {
+            Sint memory;
+        } heartbeat;
+    };
+} Command;
+
+# if defined(COMPILER_CLANG)
+#  pragma clang diagnostic push
+#   pragma clang diagnostic ignored "-Wpadded"
+#   pragma clang diagnostic ignored "-Wfloat-equal"
+# endif
+#include "cJSON/cJSON.h"
+#include "cJSON/cJSON.c"
+# if defined(COMPILER_CLANG)
+#  pragma clang diagnostic pop
+# endif
+
+#include "socket.c"
+#include "time.c"
+
+Sint main (Sint argc, Char *argv[])
+{
+    unused_variable(argc);
+    unused_variable(argv);
+
+    Sint sock_fd_external = socketCreateListener("9526");
+    Sint sock_fd_internal = socketCreateListener("9527");
+
+    // NOTE(naman): Create an epoll instance, with no flags set.
+    int epoll_fd = epoll_create1(0);
+    if (epoll_fd < 0) {
+        perror("epoll_create1");
+        exit(-1);
+    }
+
+    // NOTE(naman): Add the socket's file descriptor to the epoll set
+    struct epoll_event accept_event_internal = {.data.fd = sock_fd_internal,
+                                                .events = EPOLLIN};
+    if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, sock_fd_internal, &accept_event_internal) < 0) {
+        perror("epoll_ctl EPOLL_CTL_ADD");
+        exit(-1);
+    }
+
+    struct epoll_event accept_event_external = {.data.fd = sock_fd_external,
+                                                .events = EPOLLIN};
+    if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, sock_fd_external, &accept_event_external) < 0) {
+        perror("epoll_ctl EPOLL_CTL_ADD");
+        exit(-1);
+    }
+
+    // NOTE(naman): Allocate memory for epoll array
+    struct epoll_event* events = calloc(MAX_EPOLL_EVENTS, sizeof(struct epoll_event));
+    if (events == NULL) {
+        fprintf(stderr, "Unable to allocate memory for epoll_events");
+        exit(-1);
+    }
+
+    Command  *commands  = NULL;
+    Hash_Table commands_pending = htCreate(0);
+
+    Hash_Table socket_map = htCreate(0);
+    Hash_Table io_map = htCreate(0);
+    Hash_Table grunt_map = htCreate(0);
+    Hash_Table grunt_survey_map = htCreate(0);
+
+    while (true) {
+        // NOTE(naman): Get the fd's that are ready
+        int nready = epoll_wait(epoll_fd, events, MAX_EPOLL_EVENTS, 100);
+
+        for (int i = 0; i < nready; i++) {
+            if (events[i].events & EPOLLERR) {
+                perror("epoll_wait returned EPOLLERR");
+                exit(-1);
+            }
+
+            if ((events[i].data.fd == sock_fd_internal) ||
+                (events[i].data.fd == sock_fd_external)) {
+                Sint sock_fd = events[i].data.fd;
+
+                // NOTE(naman): A new grunt is connecting.
+                struct sockaddr_in peer_addr = {0};
+                socklen_t peer_addr_len = sizeof(peer_addr);
+                int accept_fd = accept(sock_fd, (struct sockaddr*)&peer_addr,
+                                       &peer_addr_len);
+
+                if (accept_fd < 0) {
+                    if (errno == EAGAIN || errno == EWOULDBLOCK) {
+                        // This can happen due to the nonblocking socket mode; in this
+                        // case don't do anything, but print a notice (since these events
+                        // are extremely rare and interesting to observe...)
+                        fprintf(stderr, "accept() returned %s\n",
+                                errno == EAGAIN ? "EAGAIN" : "EWOULDBLOCK");
+                    } else {
+                        perror("accept");
+                        exit(-1);
+                    }
+                } else {
+                    printf("Log: Connection made: client_fd=%d\n", accept_fd);
+
+                    // NOTE(naman): Set the socket as non-blocking
+                    int sock_flags = fcntl(sock_fd, F_GETFL, 0);
+                    if (sock_flags == -1) {
+                        perror("fcntl F_GETFL");
+                        exit(-1);
+                    }
+
+                    if (fcntl(sock_fd, F_SETFL, sock_flags | O_NONBLOCK) == -1) {
+                        perror("fcntl F_SETFL O_NONBLOCK");
+                        exit(-1);
+                    }
+
+                    // NOTE(naman): Add the new file descriptor to the epoll set
+                    struct epoll_event event = {.data.fd = accept_fd,
+                                                .events = EPOLLIN};
+                    if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, accept_fd, &event) < 0) {
+                        perror("epoll_ctl EPOLL_CTL_ADD");
+                        exit(-1);
+                    }
+
+                    if (events[i].data.fd == sock_fd_internal) {
+                        htInsert(&socket_map, (U64)accept_fd, Socket_Kind_INTERNAL);
+
+                        struct in_addr ip_addr = peer_addr.sin_addr;
+                        char str[INET_ADDRSTRLEN];
+                        inet_ntop(AF_INET, &ip_addr, str, INET_ADDRSTRLEN);
+
+                        Grunt *grunt = calloc(1, sizeof(*grunt));
+                        grunt->ip = strdup(str);
+                        htInsert(&grunt_map, (U64)accept_fd, (U64)grunt);
+                    } else if (events[i].data.fd == sock_fd_external) {
+                        htInsert(&socket_map, (U64)accept_fd, Socket_Kind_EXTERNAL);
+                    }
+
+                    Input_Output *io = calloc(1, sizeof(*io));
+                    htInsert(&io_map, (U64)accept_fd, (Uptr)io);
+                }
+            } else {
+                // A peer socket is ready.
+                if (events[i].events & EPOLLIN) {
+                    // Ready for reading.
+                    int fd = events[i].data.fd;
+
+                    Socket_Kind socket_kind = (Socket_Kind)htLookup(&socket_map, (U64)fd);
+
+                    Input_Output *io = (Input_Output *)htLookup(&io_map, (U64)fd);
+
+
+                    if (io->ir == NULL) {
+                        io->ir = calloc(1, sizeof(*io->ir));
+                        io->ir->buffer_cap = MiB(1);
+                        io->ir->buffer = calloc(io->ir->buffer_cap,
+                                                    sizeof(*(io->ir->buffer)));
+                        io->ir->fd = fd;
+                    }
+
+                    Input_Resume *ir = io->ir;
+
+                    if (ir->initialized == false) {
+                        long len = read(fd,
+                                        (Char *)ir->size_bytes + ir->size_bytes_count,
+                                        4 - ir->size_bytes_count);
+
+                        if (len == 0) {
+                            close(fd);
+                            sbufDelete(io->ors);
+                            free(io->ir);
+                            free(io);
+
+                            htRemove(&io_map, (U64)fd);
+                            htRemove(&socket_map, (U64)fd);
+
+                            if (socket_kind == Socket_Kind_INTERNAL) {
+                                htRemove(&grunt_map, (U64)fd);
+                            }
+
+                            continue;
+                        }
+
+                        ir->size_bytes_count += (Size)len;
+
+                        if (ir->size_bytes_count == 4) {
+                            ir->initialized = true;
+
+                            ir->buffer_expected_len = (U32)((ir->size_bytes[3] <<  0U) |
+                                                            (ir->size_bytes[2] <<  8U) |
+                                                            (ir->size_bytes[1] << 16U) |
+                                                            (ir->size_bytes[0] << 24U));
+                        }
+
+                        continue;
+                    } else {
+                        long len = read(fd,
+                                        ir->buffer + ir->buffer_len,
+                                        ir->buffer_expected_len - ir->buffer_len);
+
+                        ir->buffer_len += (Size)len;
+
+                        if (ir->buffer_expected_len == ir->buffer_len) {
+//                            char *json_printed = cJSON_Print(cJSON_Parse(ir->buffer));
+
+                            const Char *json_error = NULL;
+                            cJSON *root = cJSON_ParseWithOpts(ir->buffer, &json_error, true);
+
+                            B32 prepare_for_output = true;
+
+                            if (root == NULL) {
+                                // TODO(naman): Error
+                            } else {
+                                if (socket_kind == Socket_Kind_EXTERNAL) {
+                                    printf("Recieved: REQUEST EXTERNAL:\n%s\n",
+                                           cJSON_Print(cJSON_Parse(ir->buffer)));
+
+                                    Command c = {.kind = Command_REQUEST_INTERNAL};
+                                    c.id = cJSON_GetObjectItem(root, "id")->valueint;
+
+                                    Sint memory = cJSON_GetObjectItem(root, "memory")->valueint;
+
+                                    Char **ips = NULL;
+
+                                    for (Size j = 0; j < grunt_map.slot_count; j++) {
+                                        if (grunt_map.keys[j] != 0) {
+                                            Grunt *g = (Grunt *)grunt_map.values;
+                                            if (g->memory >= memory) {
+                                                c.kind = Command_RESPONSE_EXTERNAL;
+                                                sbufAdd(ips, g->ip);
+                                            }
+                                        }
+                                    }
+
+                                    if (c.kind == Command_REQUEST_INTERNAL) {
+                                        c.reqin.dispatcher_socket = fd;
+                                        c.reqin.memory = memory;
+                                    } else if (c.kind == Command_RESPONSE_EXTERNAL) {
+                                        c.resex.ips = ips;
+                                        c.reqin.dispatcher_socket = fd;
+                                    }
+
+                                    sbufAdd(commands, c);
+                                    htInsert(&commands_pending, hashInteger((U64)c.id), true);
+                                } else if (socket_kind == Socket_Kind_INTERNAL) {
+                                    Char *type = cJSON_GetObjectItem(root, "type")->valuestring;
+
+                                    if (strcmp(type, "response") == 0) {
+                                        printf("Recieved: RESPONSE INTERNAL:\n%s\n",
+                                               cJSON_Print(cJSON_Parse(ir->buffer)));
+
+                                        B32 success = (B32)(cJSON_GetObjectItem(root,
+                                                                                "success")->valueint);
+
+                                        if (success) {
+                                            Command c = {.kind = Command_RESPONSE_EXTERNAL};
+                                            c.id = cJSON_GetObjectItem(root, "id")->valueint;
+
+                                            c.resex.dispatcher_socket = cJSON_GetObjectItem(root,
+                                                                                      "dispatcher_socket")->valueint;
+
+                                            Grunt_Survey *gs =
+                                                (Grunt_Survey *)htLookup(&grunt_survey_map,
+                                                                         hashInteger((U64)c.id));
+
+                                            if (gs != NULL) {
+                                                Grunt *g = (Grunt *)htLookup(&grunt_map, (U64)fd);
+
+                                                sbufAdd(gs->ips, g->ip);
+
+                                                U64 milli_new = timeMilli();
+                                                gs->milli_passed += milli_new - gs->milli_last;
+                                                gs->milli_last = milli_new;
+
+                                                if (gs->milli_passed >= 1000) {
+                                                    htRemove(&grunt_survey_map,
+                                                             hashInteger((U64)c.id));
+
+                                                    c.resex.ips = gs->ips;
+                                                    sbufAdd(commands, c);
+                                                }
+                                            }
+                                        }
+                                    } else if (strcmp(type, "heartbeat") == 0) {
+                                        printf("Recieved: HEARTBEAT:\n%s\n",
+                                               cJSON_Print(cJSON_Parse(ir->buffer)));
+
+                                        Grunt *grunt = (Grunt *)htLookup(&grunt_map, (U64)fd);
+                                        grunt->memory = cJSON_GetObjectItem(root, "memory")->valueint;
+
+                                        prepare_for_output = false;
+                                    }
+                                }
+                            }
+
+                            free(ir->buffer);
+                            free(ir);
+                            io->ir = NULL;
+
+                            if (prepare_for_output) {
+                                struct epoll_event event = {.data.fd = fd,
+                                                            .events = EPOLLIN | EPOLLOUT};
+                                if (epoll_ctl(epoll_fd, EPOLL_CTL_MOD, fd, &event) < 0) {
+                                    perror("epoll_ctl EPOLL_CTL_MOD");
+                                    exit(-1);
+                                }
+                            }
+                        }
+                    }
+                } else if (events[i].events & EPOLLOUT) {
+                    // Writing into fd in which we previously were not able to finish writing to
+                    int fd = events[i].data.fd;
+
+                    Input_Output *io = (Input_Output *)htLookup(&io_map, (U64)fd);
+
+                    if (sbufElemin(io->ors) == 0) {
+                        // fprintf(stderr, "hmLookup returned NULL\n");
+                        // NOTE(naman): We haven't popped the Result yet, first go do that.
+                        continue;
+                    } else {
+                        Output_Resume *or = &io->ors[0];
+
+                        Char *output = or->buffer;
+                        Size output_len = or->buffer_len;
+                        Size output_pos = or->buffer_pos;
+
+                        ssize_t nsent = write(or->fd, output + output_pos, output_len - output_pos);
+
+                        if (nsent == -1) {
+                            if (errno == EAGAIN || errno == EWOULDBLOCK) {
+                                // Try next time
+                            } else {
+                                perror("write() failed\n");
+                                exit(-1);
+                            }
+                        } else if ((Size)nsent < (output_len - output_pos)) {
+                            or->buffer_pos += (Size)nsent;
+                        } else {
+                            sbufUnsortedRemove(io->ors, 0);
+
+                            struct epoll_event event = {.data.fd = fd,
+                                                        .events = EPOLLIN};
+                            if (epoll_ctl(epoll_fd, EPOLL_CTL_MOD,
+                                          or->fd, &event) < 0) {
+                                perror("epoll_ctl EPOLL_CTL_MOD");
+                                exit(-1);
+                            }
+
+                            sbufDelete(output);
+                        }
+                    }
+                }
+            }
+        }
+
+        for (Size i = 0; i < grunt_survey_map.slot_count; i++) {
+            if (grunt_survey_map.keys[i] != 0) {
+                Grunt_Survey *gs = (Grunt_Survey *)grunt_survey_map.values[i];
+
+                U64 milli_new = timeMilli();
+                gs->milli_passed += milli_new - gs->milli_last;
+                gs->milli_last = milli_new;
+
+                if (gs->milli_passed >= 1000) {
+                    htRemove(&grunt_survey_map,
+                             hashInteger((U64)gs->id));
+
+                    Command c = {.kind = Command_RESPONSE_EXTERNAL};
+                    c.id = gs->id;
+                    c.resex.dispatcher_socket = gs->dispatcher_socket;
+                    c.resex.ips = gs->ips;
+
+                    sbufAdd(commands, c);
+                }
+            }
+        }
+
+        for (Size j = 0; j < sbufElemin(commands); j++) {
+            Command c = commands[j];
+
+            if (c.kind == Command_REQUEST_INTERNAL) {
+                for (Size i = 0; i < socket_map.slot_count; i++) {
+                    if ((socket_map.values[i] == Socket_Kind_INTERNAL) &&
+                        (socket_map.keys[i] != 0)) {
+                        Char *output = NULL;
+
+                        sbufPrint(output, "    ");
+                        sbufPrint(output, "{\n\"id\": %d", c.id);
+                        sbufPrint(output, ",\n\"dispatcher_socket\": %d", c.reqin.dispatcher_socket);
+
+                        sbufPrint(output, ",\n\"memory\": %d\n", c.reqin.memory);
+
+                        sbufPrint(output, "\n}\n");
+
+                        printf("Sending: REQUEST INTERNAL:\n%s\n",
+                               cJSON_Print(cJSON_Parse(output + 4)));
+
+                        Size output_len = strlen(output);
+
+#if defined(ENDIAN_LITTLE)
+                        U32 json_len = (U32)output_len - 4;
+                        U32 json_len_be = swap_endian(json_len);
+                        output[0] = ((Char*)&json_len_be)[0];
+                        output[1] = ((Char*)&json_len_be)[1];
+                        output[2] = ((Char*)&json_len_be)[2];
+                        output[3] = ((Char*)&json_len_be)[3];
+#endif
+
+                        Grunt_Survey *gs =(Grunt_Survey *) htLookup(&grunt_survey_map,
+                                                                    hashInteger((U64)c.id));
+                        if (gs == NULL) {
+                            gs = calloc(1, sizeof(*gs));
+                            htInsert(&grunt_survey_map, hashInteger((U64)c.id), (U64)gs);
+                        }
+                        gs->milli_last = timeMilli();
+                        gs->id = c.id;
+                        gs->dispatcher_socket = c.reqin.dispatcher_socket;
+
+                        Sint fd = (Sint)socket_map.keys[i];
+                        ssize_t nsent = write(fd, output, output_len);
+
+                        if (nsent == -1) {
+                            if (errno == EAGAIN || errno == EWOULDBLOCK) {
+                                Output_Resume or = {0};
+                                or.fd = fd;
+                                or.buffer = output;
+                                or.buffer_pos = 0;
+                                or.buffer_len = output_len;
+
+                                Input_Output *io = (Input_Output *)htLookup(&io_map, (U64)fd);
+                                sbufAdd(io->ors, or);
+
+                                struct epoll_event event = {.data.fd = fd,
+                                                            .events = EPOLLIN | EPOLLOUT};
+                                if (epoll_ctl(epoll_fd, EPOLL_CTL_MOD, fd, &event) < 0) {
+                                    perror("epoll_ctl EPOLL_CTL_MOD");
+                                    exit(-1);
+                                }
+                            } else {
+                                perror("write() failed");
+                                exit(-1);
+                            }
+                        } else if ((Size)nsent < output_len) {
+                            Output_Resume or = {0};
+                            or.fd = fd;
+                            or.buffer = output;
+                            or.buffer_pos = (Size)nsent;
+                            or.buffer_len = output_len;
+
+                            Input_Output *io = (Input_Output *)htLookup(&io_map, (U64)fd);
+                            sbufAdd(io->ors, or);
+
+                            struct epoll_event event = {.data.fd = fd,
+                                                        .events = EPOLLIN | EPOLLOUT};
+                            if (epoll_ctl(epoll_fd, EPOLL_CTL_MOD, fd, &event) < 0) {
+                                perror("epoll_ctl EPOLL_CTL_MOD");
+                                exit(-1);
+                            }
+                        } else {
+                            struct epoll_event event = {.data.fd = fd,
+                                                        .events = EPOLLIN};
+                            if (epoll_ctl(epoll_fd, EPOLL_CTL_MOD,
+                                          fd, &event) < 0) {
+                                perror("epoll_ctl EPOLL_CTL_MOD");
+                                exit(-1);
+                            }
+
+                            sbufDelete(output);
+                        }
+                    }
+                }
+            } else if (c.kind == Command_RESPONSE_EXTERNAL) {
+                if (htLookup(&commands_pending, hashInteger((U64)c.id))) {
+                    htRemove(&commands_pending, hashInteger((U64)c.id));
+
+                    Sint fd = c.resex.dispatcher_socket;
+
+                    Char *output = NULL;
+
+                    sbufPrint(output, "    ");
+                    sbufPrint(output, "{\n\"id\": %d", c.id);
+                    sbufPrint(output, ",\n\"ip\": [");
+                    for (Size k = 0; k < sbufElemin(c.resex.ips); k++) {
+                        sbufPrint(output, "\"%s\"", c.resex.ips[k]);
+                        if (k < sbufElemin(c.resex.ips) - 1) {
+                            sbufPrint(output, ",");
+                        }
+                    }
+                    sbufPrint(output, "]");
+                    sbufPrint(output, "\n}");
+                    Size output_len = strlen(output);
+
+                    printf("Sending: RESPONSE EXTERNAL:\n%s\n",
+                           cJSON_Print(cJSON_Parse(output + 4)));
+
+#if defined(ENDIAN_LITTLE)
+                    U32 json_len = (U32)output_len - 4;
+                    U32 json_len_be = swap_endian(json_len);
+                    output[0] = ((Char*)&json_len_be)[0];
+                    output[1] = ((Char*)&json_len_be)[1];
+                    output[2] = ((Char*)&json_len_be)[2];
+                    output[3] = ((Char*)&json_len_be)[3];
+#endif
+
+                    ssize_t nsent = write(fd, output, output_len);
+
+                    if (nsent == -1) {
+                        if (errno == EAGAIN || errno == EWOULDBLOCK) {
+                            Output_Resume or = {0};
+                            or.fd = fd;
+                            or.buffer = output;
+                            or.buffer_pos = 0;
+                            or.buffer_len = output_len;
+
+                            Input_Output *io = (Input_Output *)htLookup(&io_map, (U64)fd);
+                            sbufAdd(io->ors, or);
+
+                            struct epoll_event event = {.data.fd = fd,
+                                                        .events = EPOLLIN | EPOLLOUT};
+                            if (epoll_ctl(epoll_fd, EPOLL_CTL_MOD, fd, &event) < 0) {
+                                perror("epoll_ctl EPOLL_CTL_MOD");
+                                exit(-1);
+                            }
+                        } else {
+                            perror("write() failed");
+                            exit(-1);
+                        }
+                    } else if ((Size)nsent < output_len) {
+                        Output_Resume or = {0};
+                        or.fd = fd;
+                        or.buffer = output;
+                        or.buffer_pos = (Size)nsent;
+                        or.buffer_len = output_len;
+
+                        Input_Output *io = (Input_Output *)htLookup(&io_map, (U64)fd);
+                        sbufAdd(io->ors, or);
+
+                        struct epoll_event event = {.data.fd = fd,
+                                                    .events = EPOLLIN | EPOLLOUT};
+                        if (epoll_ctl(epoll_fd, EPOLL_CTL_MOD, fd, &event) < 0) {
+                            perror("epoll_ctl EPOLL_CTL_MOD");
+                            exit(-1);
+                        }
+                    } else {
+                        struct epoll_event event = {.data.fd = fd,
+                                                    .events = EPOLLIN};
+                        if (epoll_ctl(epoll_fd, EPOLL_CTL_MOD,
+                                      fd, &event) < 0) {
+                            perror("epoll_ctl EPOLL_CTL_MOD");
+                            exit(-1);
+                        }
+
+                        sbufDelete(output);
+                    }
+                }
+            }
+        }
+
+        sbufDelete(commands);
+    }
+
+}

resource_manager/src/arbiter/socket.c

+/*
+ * Creator: Naman Dixit
+ * Notice: © Copyright 2020 Naman Dixit
+ */
+
+typedef enum Socket_Kind {
+    Socket_Kind_NONE,
+    Socket_Kind_INTERNAL,
+    Socket_Kind_EXTERNAL,
+} Socket_Kind;
+
+internal_function
+Sint socketCreateListener (Char *port)
+{
+    printf("Openiing socket on port %s\n", port);
+
+    // NOTE(naman): Create a socket for IPv4 and TCP.
+    Sint sock_fd = socket(AF_INET, SOCK_STREAM, 0);
+    if (sock_fd < 0) {
+        perror("ERROR opening socket");
+        exit(-1);
+    }
+
+    // NOTE(naman): This helps avoid spurious EADDRINUSE when the previous instance of this
+    // server died.
+    int opt = 1;
+    if (setsockopt(sock_fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt)) < 0) {
+        perror("setsockopt");
+        exit(-1);
+    }
+
+    // NOTE(naman): Get actual internet address to bind to using IPv4 and TCP,
+    // and listening passively
+    struct addrinfo hints = {.ai_family = AF_INET,
+                             .ai_socktype = SOCK_STREAM,
+                             .ai_flags = AI_PASSIVE};
+    struct addrinfo *addrinfo = NULL;
+    Sint s = getaddrinfo(NULL, port, &hints, &addrinfo);
+    if (s != 0) {
+        fprintf(stderr, "Error: getaddrinfo: %s\n", gai_strerror(s));
+        exit(-1);
+    }
+
+    // NOTE(naman): Assign an address to the socket
+    if (bind(sock_fd, addrinfo->ai_addr, addrinfo->ai_addrlen) != 0) {
+        perror("bind()");
+        exit(-1);
+    }
+
+    // NOTE(naman): Start listening for incoming connections
+    if (listen(sock_fd, MAX_SOCKET_CONNECTIONS_REQUEST) != 0) {
+        perror("listen()");
+        exit(-1);
+    }
+
+    // NOTE(naman): Set the socket as non-blocking
+    int flags = fcntl(sock_fd, F_GETFL, 0);
+    if (flags == -1) {
+        perror("fcntl F_GETFL");
+        exit(-1);
+    }
+    if (fcntl(sock_fd, F_SETFL, flags | O_NONBLOCK) == -1) {
+        perror("fcntl F_SETFL O_NONBLOCK");
+        exit(-1);
+    }
+
+    printf("Log: Waiting for connection on port %s...\n", port);
+
+    return sock_fd;
+}

resource_manager/src/arbiter/time.c

+/*
+ * Creator: Naman Dixit
+ * Notice: © Copyright 2020 Naman Dixit
+ */
+
+internal_function
+U64 timeMilli (void)
+{
+    struct timespec now = {0};
+
+    U64 nanosec = 0;
+
+    if (clock_gettime(CLOCK_MONOTONIC_RAW, &now) == 0) {
+        nanosec = ((U64)now.tv_sec * 1000000000ULL) + (U64)now.tv_nsec;
+    } else {
+        struct timeval now_low = {0};
+        gettimeofday(&now_low, NULL);
+        nanosec = ((U64)now_low.tv_sec * 1000000000ULL) + (U64)(now_low.tv_usec * 100);
+    }
+
+    U64 millisec = nanosec / 1000000ULL;
+
+    return millisec;
+}

cJSON @ f790e17b

+Subproject commit f790e17b6cecef030c4eda811149d238c2085fcf

resource_manager/src/common/nlib/nlib.h

+/*
+ * Creator: Naman Dixit
+ * Notice: © Copyright 2018 Naman Dixit
+ */
+
+#if !defined(NLIB_H_INCLUDE_GUARD)
+
+/* ****************************************************************************
+ * COMMON *********************************************************************
+ */
+
+/* ===============
+ * Platform Identification
+ */
+
+# if defined(_MSC_VER)
+#  if defined(__clang__)
+#   define COMPILER_CLANG
+#   define COMPILER_CLANG_WITH_MSVC
+#  else
+#   define COMPILER_MSVC
+#  endif
+# elif defined (__GNUC__)
+#  if defined(__clang__)
+#   define COMPILER_CLANG
+#   define COMPILER_CLANG_WITH_GCC
+#  else
+#   define COMPILER_GCC
+#  endif
+# elif defined(__clang__)
+#  define COMPILER_CLANG
+# else
+#  error Compiler not supported
+# endif
+
+# if defined(_WIN32)
+#  define OS_WINDOWS
+# elif defined(__linux__)
+#  define OS_LINUX
+# else
+#  error Operating system not supported
+# endif
+
+# if defined(COMPILER_MSVC) || defined(COMPILER_CLANG_WITH_MSVC)
+#  if defined(_M_IX86)
+#   define ARCH_X86
+#  elif defined(_M_X64)
+#   define ARCH_X64
+#  endif
+# elif defined(COMPILER_CLANG) || defined(COMPILER_GCC)
+#  if defined(__i386__)
+#   define ARCH_X86
+#  elif defined(__x86_64__)
+#   define ARCH_X64
+#  endif
+# endif
+
+# if !defined(ARCH_X64)  // && !defined(ARCH_X86)
+#  error Architecture not supported
+# endif
+
+# if defined(COMPILER_MSVC)
+#  if !defined(__cplusplus) // TODO(naman): See if this is actually works and is the best way.
+#   define LANGUAGE_C99  // TODO(naman): Update when Microsoft gets off its ass.
+#  else
+#   error Language not supported
+#  endif
+# endif
+
+# if defined(COMPILER_CLANG) || defined(COMPILER_GCC)
+#  if (__STDC_VERSION__ == 199409)
+#   define LANGUAGE_C89
+#  elif (__STDC_VERSION__ == 199901)
+#   define LANGUAGE_C99
+#  elif (__STDC_VERSION__ == 201112) || (__STDC_VERSION__ == 201710)
+#   define LANGUAGE_C11
+#  else
+#   error Language not supported
+#  endif
+# endif
+
+# if defined(OS_WINDOWS)
+#  define ENDIAN_BIG
+# else
+#  include <endian.h>
+#  if __BYTE_ORDER == __LITTLE_ENDIAN
+#   define ENDIAN_LITTLE
+#  elif __BYTE_ORDER == __BIG_ENDIAN
+#   define ENDIAN_BIG
+#  else
+#   error Can not determine endianness
+#  endif
+# endif
+
+/* ===========================
+ * Standard C Headers Includes
+ */
+
+/* NOTE(naman): Manually define NLIB_EXCLUDE_CRT if you want to not include CRT.
+   (done to maintain backwards compatibility). If you do prevent CRT from inclusion, do
+   the following from the code:
+
+   1. Run memUserCreate()
+*/
+
+# if defined(COMPILER_MSVC)
+#  pragma warning(push)
+#   pragma warning(disable:4668)
+# endif
+
+# include <stddef.h>
+
+# if defined(COMPILER_MSVC)
+#  pragma warning(pop)
+# endif
+
+# include <limits.h>
+# include <stdint.h>
+# include <stdarg.h>
+# include <inttypes.h>
+# include <stdnoreturn.h>
+# include <float.h>
+# include <stddef.h>
+# include <errno.h>
+
+#include <stdatomic.h>
+# include <stdio.h>
+# include <string.h>
+
+# if !defined(NLIB_EXCLUDE_CRT)
+#  include <stdlib.h>
+# endif
+
+/* ===========================
+ * Misc C Headers Includes
+ */
+
+
+/* ===========================
+ * Platform Headers Includes
+ */
+
+# if defined(OS_WINDOWS)
+
+#  if defined(COMPILER_MSVC)
+#   pragma warning(push)
+#    pragma warning(disable:4255)
+#    pragma warning(disable:4668)
+#  endif
+
+#  include <Windows.h>
+
+#  if defined(COMPILER_MSVC)
+#   pragma warning(pop)
+#  endif
+
+#  if defined(COMPILER_MSVC)
+#   pragma warning(push)
+#    pragma warning(disable:4820)
+#    pragma warning(disable:4668)
+#    pragma warning(disable:4255)
+#  endif
+
+#  include <intrin.h>
+
+#  if defined(COMPILER_MSVC)
+#   pragma warning(pop)
+#  endif
+
+# elif defined(OS_LINUX)
+// ...
+
+# endif
+
+/* ===============
+ * Primitive Types
+ */
+
+typedef int8_t               S8;
+typedef int16_t              S16;
+typedef int32_t              S32;
+typedef int64_t              S64;
+typedef int                  Sint;
+
+typedef uint8_t              U8;
+typedef uint16_t             U16;
+typedef uint32_t             U32;
+typedef uint64_t             U64;
+typedef unsigned             Uint;
+
+typedef size_t               Size;
+
+typedef uintptr_t            Uptr;
+typedef intptr_t             Sptr;
+typedef ptrdiff_t            Dptr;
+
+typedef float                F32;
+typedef double               F64;
+
+typedef U8                   B8;
+typedef U16                  B16;
+typedef U32                  B32;
+typedef U64                  B64;
+# define true                1U
+# define false               0U
+
+typedef unsigned char        Byte;
+typedef char                 Char;
+
+/* ========================
+ * Preprocessor Definitions
+ */
+
+# define elemin(array) (sizeof(array)/sizeof((array)[0]))
+#define containerof(ptr, type, member)                                  \
+    ((type *)( ((Byte *)(true ? (ptr) : (type *)NULL)) - offsetof(type, member) ))
+
+# define KiB(x) (   (x) * 1024ULL)
+# define MiB(x) (KiB(x) * 1024ULL)
+# define GiB(x) (MiB(x) * 1024ULL)
+# define TiB(x) (GiB(x) * 1024ULL)
+
+# define THOUSAND 1000L
+# define MILLION  1000000L
+# define BILLION  1000000000L
+
+# define unused_variable(var) (void)var
+
+# define global_variable   static
+# define persistent_value  static
+
+# define internal_function static
+# define header_function   static inline
+
+/* =======================
+ * Compiler Specific Hacks
+ */
+
+/* Microsoft Visual C */
+# if defined(COMPILER_MSVC)
+
+// #  if _MSC_VER != 1916 // Visual Studio 2017 Version 15.7
+// #   error MSVC version not supported
+// #  endif // MSVC Versions
+
+#  define _Alignof __alignof
+#  define alignof _Alignof
+#  define __alignof_is_defined 1
+
+/* In alignas(a), 'a' should be a power of two that is at least the type's
+   alignment and at most the implementation's alignment limit.  This limit is
+   2**13 on MSVC. To be portable to MSVC through at least version 10.0,
+   'a' should be an integer constant, as MSVC does not support expressions
+   such as 1 << 3.
+
+   The following C11 requirements are not supported here:
+
+   - If 'a' is zero, alignas has no effect.
+   - alignas can be used multiple times; the strictest one wins.
+   - alignas (TYPE) is equivalent to alignas (alignof (TYPE)).
+*/
+
+#  define _Alignas(a) __declspec(align(a))
+#  define alignas _Alignas
+#  define __alignas_is_defined 1
+
+/* Malloc Alignment: https://msdn.microsoft.com/en-us/library/ycsb6wwf.aspx
+ */
+#  if defined(ARCH_x86)
+// Alignment is 8 bytes
+typedef union {
+    alignas(8) Byte alignment[8];
+    F64 a;
+} max_align_t;
+#  elif defined(ARCH_X64)
+// Alignment is 16 bytes
+typedef union {
+    alignas(16) Byte alignment[16];
+    alignas(16) struct { F64 a, b; } f;
+} max_align_t;
+#  endif
+
+#  if defined(LANGUAGE_C11)
+#   include <threads.h>
+#  else
+#   define thread_local __declspec( thread )
+#  endif
+
+#  define swap_endian(x) _byteswap_ulong(x)
+
+# elif defined(COMPILER_CLANG) || defined(COMPILER_GCC)
+
+#  define max(a, b)                             \
+    ({ __typeof__ (a) _a = (a);                 \
+        __typeof__ (b) _b = (b);                \
+        _a > _b ? _a : _b; })
+#  define min(a, b)                             \
+    ({ __typeof__ (a) _a = (a);                 \
+        __typeof__ (b) _b = (b);                \
+        _a < _b ? _a : _b; })
+
+#  if defined(LANGUAGE_C11)
+#   include <stdalign.h>
+#  else
+#   pragma clang diagnostic push
+#   pragma clang diagnostic ignored "-Wreserved-id-macro"
+#   define _Alignof __alignof__
+#   define alignof _Alignof
+#   define __alignof_is_defined 1
+#   define _Alignas(a) __attribute__ ((aligned (a)))
+#   define alignas _Alignas
+#   define __alignas_is_defined 1
+#   pragma clang diagnostic pop
+
+/* Malloc Alignment: https://msdn.microsoft.com/en-us/library/ycsb6wwf.aspx
+ */
+#   if defined(ARCH_x86)
+// Alignment is 8 bytes
+typedef union {
+    alignas(8) Byte alignment[8];
+    F64 a;
+} max_align_t;
+#   elif defined(ARCH_X64)
+// Alignment is 16 bytes
+typedef union {
+    alignas(16) Byte alignment[16];
+    alignas(16) struct { F64 a, b; } f;
+} max_align_t;
+#   endif
+#  endif
+
+#  if defined(LANGUAGE_C11)
+#   include <threads.h>
+#  else
+#   define thread_local __thread
+#  endif
+
+#  define swap_endian(x) __builtin_bswap32(x)
+
+# endif
+
+/* =======================
+ * Other nlib libraries
+ */
+
+# include "unicode.h"
+
+
+/* =======================
+ * OS Specific Hacks
+ */
+
+# if defined(OS_WINDOWS)
+
+header_function
+void reportDebugV(Char *format, va_list ap)
+{
+    Char buffer[2048] = {0};
+
+    stbsp_vsnprintf(buffer, 2048, format, ap);
+    buffer[2047] = '\0';
+
+    LPWSTR wcstr = unicodeWin32UTF16FromUTF8(buffer);
+    OutputDebugStringW(wcstr);
+    unicodeWin32UTF16Dealloc(wcstr);
+
+    return;
+}
+
+header_function
+void reportDebug(Char *format, ...)
+{
+    va_list ap;
+
+    va_start(ap, format);
+    reportDebugV(format, ap);
+    va_end(ap);
+
+    return;
+}
+
+
+#  if defined(BUILD_INTERNAL)
+#   define report(...)  reportDebug(__VA_ARGS__)
+#   define reportv(...) reportDebugV(__VA_ARGS__)
+#   define breakpoint() __debugbreak()
+#   define quit() breakpoint()
+#  else
+#   define report(...)      fprintf(stderr, __VA_ARGS__)
+#   define reportv(format, va_list) vfprintf(stderr, format, va_list)
+#   define quit() abort()
+#   define breakpoint() do{report("Fired breakpoint in release code, quitting...\n");quit();}while(0)
+#  endif
+
+# elif defined(OS_LINUX)
+
+#  if defined(BUILD_INTERNAL)
+#   define report(...)      fprintf(stderr, __VA_ARGS__)
+#   define reportv(format, va_list) vfprintf(stderr, format, va_list)
+#   define breakpoint() __asm__ volatile("int $0x03")
+#   define quit() breakpoint()
+#  else
+#   define report(...)      fprintf(stderr, __VA_ARGS__)
+#   define reportv(format, va_list) vfprintf(stderr, format, va_list)
+#   define quit() abort()
+#   define breakpoint() do{report("Fired breakpoint in release code, quitting...\n");quit();}while(0)
+#  endif
+
+# endif
+
+/* ===============================
+ * Integer Mathematics Functions
+ */
+
+# if defined(OS_WINDOWS)
+
+/* _BitScanReverse64(&r, x) scans for the first 1-bit from left in x. Once it finds it,
+ * it returns the number of bits after the found 1-bit.
+ *
+ * If b is the bit-width of the number,
+ *    p is the closest lower power of two and
+ *    r is the number of bits to the right of the first 1-bit when seen from left; then
+ * then a number between 2^p and 2^(p+1) has the form: (b-p-1 0-bits) 1 (p bits)
+ *
+ * => r = p
+ *
+ * Thus, the rounded-down log2 of the number is r.
+ */
+header_function
+U64 u64Log2(U64 x)
+{
+    unsigned long result = 0;
+    _BitScanReverse64(&result, x);
+    return result;
+}
+
+/* Linear Congruential Generator
+ *
+ * If x is the last random number,
+ *    m is a number greater than zero that is a power of two,
+ *    a is a number between 0 and m,
+ * then the next random number is ((x * a) % m).
+ *
+ * Unfortunately, the lower bits don't have enought randomness in them. The LSB doesn't
+ * change at all, the second LSB alternates, the one after that toggles every 2 turns and so
+ * on. Therefore, we try to get rid of the LSBs by pulling in some MSBs.
+ *
+ * NOTE(naman): Seed should be an odd number or the randomness might drop drastically.
+ * NOTE(naman): "a" should be equal to 5(mod 8) or 3(mod 8).
+ */
+
+header_function
+U64 u64Rand (U64 seed)
+{
+    U64 previous = seed;
+    if (previous == 0) {
+        // This seed has been tested and should be preferred in normal circumstances.
+        previous = 2531011ULL;
+    }
+
+    U64 a = 214013ULL;
+
+    U64 upper = 0, lower = 0;
+    lower = _umul128(previous, a, &upper);
+    U64 log_upper = u64Log2(upper);
+    U64 shift_amount = 64 - (log_upper + 1);
+    upper = (upper << shift_amount) | (lower >> log_upper);
+
+    U64 result = upper * a;
+
+    return result;
+}
+
+# elif defined(OS_LINUX)
+
+/* __builtin_clzll(x) returns the leading number of 0-bits in x, starting from
+ * most significant position.
+ *
+ * If b is the bit-width of the number,
+ *    p is the closest lower power of two and
+ *    lz is the number of leading 0-bits; then
+ * then a number between 2^p and 2^(p+1) has the form: (b-p-1 0-bits) 1 (p bits)
+ *
+ * => lz = b-p-1
+ * => p = b-(lz+1)
+ *
+ * Thus, the rounded-down log2 of the number is b-(lz+1).
+ */
+header_function
+U64 u64Log2(U64 x)
+{
+    U64 result = 64ULL - ((U64)__builtin_clzll(x) + 1ULL);
+    return result;
+}
+
+/* Linear Congruential Generator
+ *
+ * If x is the last random number,
+ *    m is a number greater than zero that is a power of two,
+ *    a is a number between 0 and m,
+ * then the next random number is ((x * a) % m).
+ *
+ * Unfortunately, the lower bits don't have enought randomness in them. The LSB doesn't
+ * change at all, the second LSB alternates, the one after that toggles every 2 turns and so
+ * on. Therefore, we try to get rid of the LSBs by pulling in some MSBs.
+ *
+ * We do the multiplcation twice because Chi-Square Test indicated that this method
+ * gives better randomness. Don't ask.
+ *
+ * NOTE(naman): Seed should be an odd number or the randomness might drop drastically.
+ * NOTE(naman): "a" should be equal to 5(mod 8) or 3(mod 8).
+ */
+
+header_function
+U64 u64Rand (U64 seed)
+{
+    U64 previous = seed;
+    if (previous == 0) {
+        // This seed has been tested and should be preferred in normal circumstances.
+        previous = 2531011ULL;
+    }
+
+    U64 a = 214013ULL;
+
+    __uint128_t product = (__uint128_t)previous * (__uint128_t)a;
+    U64 upper = product >> 64, lower = (U64)product;
+    U64 log_upper = u64Log2(upper);
+    U64 shift_amount = 64 - (log_upper + 1);
+    upper = (upper << shift_amount) | (lower >> log_upper);
+
+    U64 result = upper * a;
+
+    return result;
+}
+
+# endif
+
+header_function
+U64 u64NextPowerOf2 (U64 x)
+{
+    U64 result = 0;
+    if ((x != 0) && ((x & (x - 1)) == 0)) { // If x is a power of true
+        result = x;
+    } else {
+        result = 1 << (u64Log2(x) + 1);
+    }
+
+    return result;
+}
+
+
+
+/* ****************************************************************************
+ * LIBRARIES ******************************************************************
+ */
+
+/* ==============
+ * Claim (assert)
+ */
+
+# define claim(cond) claim_(cond, #cond, __FILE__, __LINE__)
+
+header_function
+void claim_ (B32 cond,
+             Char *cond_str,
+             Char *filename, U32 line_num)
+{
+    if (!cond) {
+        report("Claim \"%s\" Failed in %s:%u\n\n",
+               cond_str, filename, line_num);
+
+        quit();
+    }
+}
+
+/* ===================
+ * String Functions
+ */
+
+header_function
+B32 strequal (Char *str1, Char *str2)
+{
+    B32 result = (strcmp(str1, str2) == 0);
+    return result;
+}
+
+header_function
+Size strprefix(Char *str, Char *pre)
+{
+    Size lenpre = strlen(pre);
+    Size lenstr = strlen(str);
+
+    if (lenstr < lenpre) {
+        return 0;
+    } else {
+        if (memcmp(pre, str, lenpre) == 0) {
+            return lenpre;
+        } else {
+            return 0;
+        }
+    }
+}
+
+header_function
+B32 strsuffix (Char *str, Char *suf)
+{
+    Char *string = strrchr(str, suf[0]);
+    B32 result = false;
+
+    if(string != NULL) {
+        if (strcmp(string, suf) == 0) {
+            result = true;
+        }
+    }
+
+    return result;
+}
+
+/* ===================
+ * Unit Test Framework
+ */
+
+# define utTest(cond) ut_Test(cond, #cond, __FILE__, __LINE__)
+
+header_function
+void ut_Test (B32 cond,
+              Char *cond_str,
+              Char *filename, U32 line_num) {
+    if (!(cond)) {
+        report("Test Failed: (%s:%u) %s\n", filename, line_num, cond_str);
+        quit();
+    }
+}
+
+/* ****************************************************************************
+ * MEMORY ALLOCATORS **********************************************************
+ */
+
+/* ===============================
+ * User Memory Allocator Helpers
+ */
+
+#define MEM_MAX_ALIGN_MINUS_ONE (alignof(max_align_t) - 1u)
+#define memAlignUp(p) (((p) + MEM_MAX_ALIGN_MINUS_ONE) & (~ MEM_MAX_ALIGN_MINUS_ONE))
+#define memAlignDown(p) (memAlignUp((p) - MEM_MAX_ALIGN_MINUS_ONE))
+
+#define memBytesFromBits(b) (((b)+(CHAR_BIT-1))/(CHAR_BIT))
+
+#define memSetBit(array, index)                                 \
+    ((array)[(index)/CHAR_BIT] |= (1U << ((index)%CHAR_BIT)))
+#define memResetBit(array, index)                               \
+    ((array)[(index)/CHAR_BIT] &= ~(1U << ((index)%CHAR_BIT)))
+#define memToggleBit(array, index)                              \
+    ((array)[(index)/CHAR_BIT] ^= ~(1U << ((index)%CHAR_BIT)))
+#define memTestBit(array, index)                                \
+    ((array)[(index)/CHAR_BIT] & (1U << ((index)%CHAR_BIT)))
+
+
+# if defined(COMPILER_CLANG)
+#  pragma clang diagnostic push
+#   pragma clang diagnostic ignored "-Wcast-align"
+# endif
+
+typedef enum Memory_Allocator_Mode {
+    Memory_Allocator_Mode_NONE,
+    Memory_Allocator_Mode_CREATE,
+    Memory_Allocator_Mode_ALLOC,
+    Memory_Allocator_Mode_REALLOC,
+    Memory_Allocator_Mode_DEALLOC,
+    Memory_Allocator_Mode_DEALLOC_ALL,
+} Memory_Allocator_Mode;
+
+# define MEMORY_ALLOCATOR(allocator)               \
+    void* allocator(Memory_Allocator_Mode mode,          \
+                    Size size, void* old_ptr,   \
+                    void *data)
+typedef MEMORY_ALLOCATOR(Memory_Allocator_Function);
+
+/* =============================
+ * General Purpose User Memory Allocator
+ */
+
+typedef struct Memory_User_Buddy Memory_User_Buddy;
+
+typedef struct Memory_User {
+    Memory_User_Buddy *b;
+    Byte *base;
+    Size total;
+    Size filled;
+} Memory_User;
+
+struct Memory_User_Buddy {
+    Byte *free_bits;
+    Byte *split_bits;
+
+    struct Memory_User_Buddy *prev;
+    struct Memory_User_Buddy *next;
+
+    Byte *arena;
+    Size arena_size;
+    Size leaf_size;
+    Size leaf_count;
+    Size block_count;
+    U8 level_max;
+    U8 level_count;
+
+    Byte _pad1[6];
+};
+
+/*
+  -------------------------------------------------------------------
+  L:0 |                                0                             |
+  -------------------------------------------------------------------
+  L:1 |               1                |              2              |
+  -------------------------------------------------------------------
+  L:2 |       3       |       4        |       5      |       6      |
+  -------------------------------------------------------------------
+  L:3 |   7   |   8   |   9   |   10   |  11   |  12  |  13   |  14  |
+  -------------------------------------------------------------------
+*/
+
+#define memcb_CountOfBlocksAtLevel(level) (1u << (level))
+#define memcb_SizeOfBlocksAtLevel(b, level)                     \
+    (((b)->arena_size)/memcb_CountOfBlocksAtLevel(level))
+#define memcb_IndexOfBlockInLevel(b, ptr, level) /* Zero based */       \
+    ((Uptr)((ptr) - (b)->arena) / memcb_SizeOfBlocksAtLevel(b, level))
+#define memcb_IndexOfLeaf(b, ptr) /* Zero based */      \
+    ((Uptr)((ptr) - ((b)->arena)) / ((b)->leaf_size))
+#define memcb_PointerToBlockInLevel(b, index, level)                    \
+    (((index) * memcb_SizeOfBlocksAtLevel(b, level)) + (b)->arena)
+#define memcb_PreviousBlockInLevel(b, ptr, level)       \
+    ((void*)(((Byte*)ptr) - memcb_SizeOfBlocksAtLevel(b, level)))
+#define memcb_NextBlockInLevel(b, ptr, level)           \
+    ((void*)(((Byte*)ptr) + memcb_SizeOfBlocksAtLevel(b, level)))
+#define memcb_BlocksBeforeThisLevel(level)                              \
+    ((1 << (level)) - 1) /* Using sum of GP, blocks before level n are (2ⁿ - 1) */
+#define memcb_GlobalIndexOfBlock(b, ptr, level) \
+    (memcb_BlocksBeforeThisLevel(level) +       \
+     memcb_IndexOfBlockInLevel(b, ptr, level))
+#define memcb_IndexOfFirstChild(index)          \
+    ((2 * (index)) + 1)
+#define memcb_IndexOfSecondChild(index)         \
+    ((2 * (index)) + 2)
+#define memcb_IndexOfParent(index)              \
+    (((index) - 1) / 2)
+
+header_function
+Memory_User_Buddy memcb_Init (Byte* arena, Size arena_size, Size leaf_size)
+{
+    Size leaf_count  = arena_size / leaf_size;
+    U8 level_max   = (U8)u64Log2(leaf_count);
+    U8 level_count = level_max + 1;
+    Size block_count  = (1 << level_count) - 1; // 2ⁿ⁺¹ - 1 where n is level_max (sum of GP)
+
+    Memory_User_Buddy buddy = {0};
+    buddy.arena = arena;
+    buddy.arena_size = arena_size;
+    buddy.leaf_size = leaf_size;
+    buddy.leaf_count = leaf_count;
+    buddy.level_max = level_max;
+    buddy.level_count = level_count;
+    buddy.block_count = block_count;
+
+    return buddy;
+}
+
+header_function
+void* memcb_GetFreeBlockAtLevel (Memory_User_Buddy *buddy, Size level)
+{
+    Byte *found_block = NULL;
+    Size level_current = level;
+
+    do {
+        if (level_current == 0) {
+            if (memTestBit(buddy->free_bits, 0)) {
+                found_block = buddy->arena;
+            }
+            break;
+        }
+
+        Size free_bits_begin = memcb_GlobalIndexOfBlock(buddy,
+                                                        buddy->arena,
+                                                        level_current);
+        Size free_bits_end = free_bits_begin + memcb_CountOfBlocksAtLevel(level_current);
+
+        for (Size bi = free_bits_begin; bi < free_bits_end; bi = bi + 1) {
+            if (memTestBit(buddy->free_bits, bi)) {
+                found_block = (buddy->arena +
+                               (memcb_SizeOfBlocksAtLevel(buddy,
+                                                                    level_current) *
+                                (bi - memcb_BlocksBeforeThisLevel(level_current))));
+                break;
+            }
+        }
+
+        if (level_current == 0) {
+            break;
+        } else if (found_block == NULL) {
+            level_current--;
+        }
+    } while (found_block == NULL);
+
+    if (found_block != NULL) {
+        for (Size lvl = level_current + 1; lvl <= level; lvl++) {
+            Byte *found_block_sibiling = (found_block +
+                                          memcb_SizeOfBlocksAtLevel(buddy, lvl));
+
+            memSetBit(buddy->free_bits,
+                     memcb_GlobalIndexOfBlock(buddy, found_block, lvl));
+            memSetBit(buddy->free_bits,
+                     memcb_GlobalIndexOfBlock(buddy, found_block_sibiling, lvl));
+            memResetBit(buddy->free_bits,
+                       memcb_IndexOfParent(memcb_GlobalIndexOfBlock(buddy,
+                                                                                        found_block,
+                                                                                        lvl)));
+            memSetBit(buddy->split_bits,
+                     memcb_IndexOfParent(memcb_GlobalIndexOfBlock(buddy,
+                                                                                      found_block,
+                                                                                      lvl)));
+        }
+
+        memResetBit(buddy->free_bits,
+                   memcb_GlobalIndexOfBlock(buddy, found_block, level));
+    }
+
+    return found_block;
+}
+
+header_function
+void* memcb_Alloc (Memory_User_Buddy *bbuddy, Size size)
+{
+    Size size_real = size;
+
+    if (size_real == 0 || bbuddy == NULL) {
+        return NULL;
+    }
+
+    if (size_real < bbuddy->leaf_size) {
+        size_real = bbuddy->leaf_size;
+    }
+
+    if (size_real > bbuddy->arena_size) {
+        return NULL;
+    }
+
+    Size total_size = u64NextPowerOf2(size_real);
+
+    // "inverse" because it is taking smallest block as level 0
+    U8 inverse_level = (U8)u64Log2(total_size/(bbuddy->leaf_size));
+    U8 level = bbuddy->level_max - inverse_level; // Actually, largest block is level 0
+
+    Byte *m = memcb_GetFreeBlockAtLevel(bbuddy, level);
+
+    return m;
+}
+
+header_function
+Byte* memcb_MergeBuddies (Memory_User_Buddy *buddy, Byte *block, Size level)
+{
+    if (level == 0) return NULL;
+
+    Byte *result = NULL;
+
+    Size local_index  = memcb_IndexOfBlockInLevel(buddy, block, level);
+
+    Byte *parent_block = NULL; // the pointer to the merged blocks (if they get merged)
+    Byte *buddy_block = NULL; // pointer to buddy block
+
+    if (local_index % 2 == 1) { // odd = merge with previous block
+        buddy_block = memcb_PreviousBlockInLevel(buddy, block, level);
+        parent_block = buddy_block;
+    } else { // even = merge with next block
+        buddy_block = memcb_NextBlockInLevel(buddy, block, level);
+        parent_block = block;
+    }
+
+    Size block_global_index = memcb_GlobalIndexOfBlock(buddy, block, level);
+    Size buddy_global_index = memcb_GlobalIndexOfBlock(buddy, buddy_block, level);
+    Size parent_global_index = memcb_GlobalIndexOfBlock(buddy, parent_block, level - 1);
+
+    if (memTestBit(buddy->free_bits, buddy_global_index)) { // Buddy is also free
+        memResetBit(buddy->free_bits, buddy_global_index);
+        memResetBit(buddy->free_bits, block_global_index);
+        memSetBit(buddy->free_bits, parent_global_index);
+        memResetBit(buddy->split_bits, parent_global_index);
+
+        result = parent_block;
+    }
+
+    return result;
+}
+
+header_function
+void memcb_ReleaseBlockAtLevel (Memory_User_Buddy *buddy, Byte *ptr, Size level)
+{
+    memSetBit(buddy->free_bits, memcb_GlobalIndexOfBlock(buddy, ptr, level));
+
+    Size merge_level = level;
+    Byte *merge_ptr = ptr;
+
+    while (merge_level > 0) {
+        merge_ptr = memcb_MergeBuddies(buddy, merge_ptr, merge_level);
+        if (merge_ptr == NULL) break;
+        merge_level--;
+    }
+
+    return;
+}
+
+header_function
+void memcb_Dealloc (Memory_User_Buddy *buddy, void *ptr)
+{
+    if (ptr == NULL || buddy == NULL) return;
+
+     U8 level_min = buddy->level_max; //The real level will never be zero since we already
+                                      // made a bunch of allocations at that level manually during init.
+
+     while ((level_min < buddy->level_count) && (level_min > 0)) {
+         if (memcb_IndexOfBlockInLevel(buddy, (Byte*)ptr, level_min) % 2 == 1) break;
+         level_min--;
+     }
+
+    U8 level = buddy->level_max;
+    while ((level >= level_min) && (level <= buddy->level_max)) {
+        if (level == 0) {
+            break;
+        } else if (memTestBit(buddy->split_bits,
+                             memcb_IndexOfParent(memcb_GlobalIndexOfBlock(buddy,
+                                                                          (Byte*)ptr,
+                                                                          level)))) {
+            break;
+        }
+        level--;
+    }
+
+    memcb_ReleaseBlockAtLevel(buddy, ptr, level);
+
+    return;
+}
+
+header_function
+void* memcb_GetMemory (Memory_User *m, Size size)
+{
+    if ((m->filled + size) > m->total) {
+        fprintf(stderr, "Memory full: Total = %lu, Filled = %lu\n", m->total, m->filled);
+        fflush(stdout);
+        return NULL;
+    }
+
+    void *result = m->base + m->filled;
+
+    m->filled += size;
+
+    return result;
+}
+
+# define memUserCreate(m, base, size)    memUser(Memory_Allocator_Mode_CREATE,  size, base, m)
+# define memUserAlloc(m, size)           memUser(Memory_Allocator_Mode_ALLOC,   size, NULL, m)
+# define memUserRealloc(m, ptr, size)    memUser(Memory_Allocator_Mode_REALLOC, size, ptr,  m)
+# define memUserDealloc(m, ptr)          memUser(Memory_Allocator_Mode_DEALLOC, 0,    ptr,  m)
+
+header_function
+MEMORY_ALLOCATOR(memUser)
+{
+    Memory_User *m = data;
+
+    switch (mode) {
+        case Memory_Allocator_Mode_CREATE: {
+            m->total = size;
+            m->base = old_ptr;
+            m->filled = 0;
+            m->b = NULL;
+        } break;
+
+        case Memory_Allocator_Mode_ALLOC: {
+            if (size == 0) return NULL;
+            size = u64NextPowerOf2(size);
+
+            void *mem = NULL;
+
+            for (Memory_User_Buddy *b = m->b; b != NULL; b = b->next) {
+                if ((size >= b->leaf_size) && (size <= b->arena_size)) {
+                    mem = memcb_Alloc(b, size);
+                    if (mem != NULL) break;
+                } else {
+                    continue;
+                }
+            }
+
+            if (mem == NULL) {
+                Size leaf_size = size;
+                Size arena_size = 1 << (u64Log2(size) + 5);
+
+                Memory_User_Buddy *buddy = memcb_GetMemory(m, sizeof(*buddy));
+                *buddy = (Memory_User_Buddy){0};
+
+                Byte *arena = memcb_GetMemory(m, arena_size);
+
+                *buddy = memcb_Init(arena, arena_size, leaf_size);
+
+                Size size_of_free_bits = memBytesFromBits(buddy->block_count);
+                Size size_of_split_bits = memBytesFromBits(buddy->block_count - buddy->leaf_count);
+                Size total_size = memAlignUp(size_of_free_bits + size_of_split_bits);
+
+                Byte *overhead = memcb_GetMemory(m, total_size);
+                memset(overhead, 0, total_size);
+
+                buddy->free_bits = overhead;
+                buddy->split_bits = overhead + size_of_free_bits;
+                memSetBit(buddy->free_bits, 0);
+
+                if (m->b != NULL) {
+                    m->b->prev = buddy;
+                }
+
+                buddy->next = m->b;
+                m->b = buddy;
+
+                mem = memcb_Alloc(buddy, size);
+            }
+
+            if (mem == NULL) breakpoint();
+            return mem;
+        } break;
+
+        case Memory_Allocator_Mode_REALLOC: {
+            if (old_ptr == NULL) {
+                void *result = memUser(Memory_Allocator_Mode_ALLOC, size, NULL, m);
+                return result;
+            }
+
+            if (size == 0) {
+                memUser(Memory_Allocator_Mode_DEALLOC, 0, old_ptr, m);
+                return NULL;
+            }
+
+            Memory_User_Buddy *buddy = NULL;
+
+            for (Memory_User_Buddy *b = m->b; b != NULL; b = b->next) {
+                if (((Byte*)old_ptr > (Byte*)&(b->arena)) && ((Byte*)old_ptr < (((Byte*)&(b->arena)) + b->arena_size))) {
+                    buddy = b;
+                    break;
+                }
+            }
+
+            if (buddy == NULL) return NULL;
+
+            U8 level_min = buddy->level_max; // The real level will never be zero since we already
+            // made a bunch of allocations at that level manually during init.
+
+            while ((level_min < buddy->level_count) && (level_min > 0)) {
+                if (memcb_IndexOfBlockInLevel(buddy, (Byte*)old_ptr, level_min) % 2 == 1) break;
+                level_min--;
+            }
+
+            U8 level = buddy->level_max;
+            while ((level >= level_min) && (level <= buddy->level_max)) {
+                if (level == 0) {
+                    break;
+                } else if (memTestBit(buddy->split_bits,
+                                     memcb_IndexOfParent(memcb_GlobalIndexOfBlock(buddy, (Byte*)old_ptr, level)))) {
+                    break;
+                }
+                level--;
+            }
+
+            Size old_size = memcb_SizeOfBlocksAtLevel(buddy, level);
+            if (old_size > size) {
+                return old_ptr;
+            }
+
+            if (size < (2 * old_size)) {
+                size = 2 * old_size;
+            }
+
+            B32 reallocated = false;
+            Byte *new_ptr = NULL;
+
+            if (level != 0) {
+                Size local_index  = memcb_IndexOfBlockInLevel(buddy, (Byte*)old_ptr, level);
+
+                Byte *parent_ptr = NULL; // the pointer to the merged blocks (if they get merged)
+                Byte *buddy_ptr = NULL; // pointer to buddy block
+
+                if (local_index % 2 == 0) {
+                    buddy_ptr = memcb_NextBlockInLevel(buddy, old_ptr, level);
+                    parent_ptr = old_ptr;
+
+                    Size buddy_global_index = memcb_GlobalIndexOfBlock(buddy, buddy_ptr, level);
+                    Size parent_global_index = memcb_GlobalIndexOfBlock(buddy, parent_ptr, level - 1);
+
+                    if (memTestBit(buddy->free_bits, buddy_global_index)) {
+                        memResetBit(buddy->free_bits, buddy_global_index);
+                        memResetBit(buddy->split_bits, parent_global_index);
+
+                        reallocated = true;
+                        new_ptr = old_ptr;
+                    }
+                } else {
+                    buddy_ptr = memcb_PreviousBlockInLevel(buddy, old_ptr, level);
+                    parent_ptr = buddy_ptr;
+
+                    Size buddy_global_index = memcb_GlobalIndexOfBlock(buddy, buddy_ptr, level);
+                    Size parent_global_index = memcb_GlobalIndexOfBlock(buddy, parent_ptr, level - 1);
+
+                    if (memTestBit(buddy->free_bits, buddy_global_index)) {
+                        memcpy(buddy_ptr, old_ptr, old_size);
+
+                        memResetBit(buddy->free_bits, buddy_global_index);
+                        memResetBit(buddy->split_bits, parent_global_index);
+
+                        reallocated = true;
+                        new_ptr = old_ptr;
+                    }
+                }
+            }
+
+            if (!reallocated) {
+                new_ptr = memUser(Memory_Allocator_Mode_ALLOC, size, NULL, m);
+                if (new_ptr == NULL) return NULL;
+                memcpy(new_ptr, old_ptr, old_size);
+                memUser(Memory_Allocator_Mode_DEALLOC, 0, old_ptr,  m);
+            }
+
+            return new_ptr;
+        } break;
+
+        case Memory_Allocator_Mode_DEALLOC: {
+            for (Memory_User_Buddy *b = m->b; b != NULL; b = b->next) {
+                if (((Byte*)old_ptr > (Byte*)&(b->arena)) && ((Byte*)old_ptr < (((Byte*)&(b->arena)) + b->arena_size))) {
+                    memcb_Dealloc(b, old_ptr);
+                    break;
+                }
+            }
+
+            return NULL;
+        } break;
+
+        case Memory_Allocator_Mode_DEALLOC_ALL: {
+            // TODO(naman): Maybe we should use a off-the-shelf malloc that allows this?
+        } break;
+
+        case Memory_Allocator_Mode_NONE: {
+            breakpoint();
+        } break;
+    }
+
+    return NULL;
+}
+
+/* =============================
+ * stdlib Memory Allocator
+ */
+
+# if !defined(NLIB_EXCLUDE_CRT)
+
+struct MemCRT_Header {
+    Size size;
+};
+
+#  define memCRTAlloc(size)        memCRT(Memory_Allocator_Mode_ALLOC,   size, NULL, NULL)
+#  define memCRTRealloc(ptr, size) memCRT(Memory_Allocator_Mode_REALLOC, size, ptr,  NULL)
+#  define memCRTDealloc(ptr)       memCRT(Memory_Allocator_Mode_DEALLOC, 0,    ptr,  NULL)
+
+header_function
+MEMORY_ALLOCATOR(memCRT)
+{
+    unused_variable(data);
+    switch (mode) {
+        case Memory_Allocator_Mode_CREATE: {
+            // NOTE(naman): Not needed for now
+        } break;
+
+        case Memory_Allocator_Mode_ALLOC: {
+            Size memory_size = memAlignUp(size);
+            Size header_size = memAlignUp(sizeof(struct MemCRT_Header));
+            Size total_size = memory_size + header_size;
+
+            Byte *mem = malloc(total_size);
+            memset(mem, 0, total_size);
+
+            struct MemCRT_Header *header = (struct MemCRT_Header *)mem;
+            header->size = memory_size;
+
+            Byte *result = mem + header_size;
+
+            return result;
+        } break;
+
+        case Memory_Allocator_Mode_REALLOC: {
+            Size memory_size = memAlignUp(size);
+            Size header_size = memAlignUp(sizeof(struct MemCRT_Header));
+            Size total_size = memory_size + header_size;
+
+            Byte *mem = malloc(total_size);
+
+            struct MemCRT_Header *header = (struct MemCRT_Header *)mem;
+            header->size = memory_size;
+
+            Byte *result = mem + header_size;
+
+            if (old_ptr != NULL) {
+                Byte *previous_mem = (Byte*)old_ptr - header_size;
+                struct MemCRT_Header *previous_header = (struct MemCRT_Header *)previous_mem;
+                Size previous_size = previous_header->size;
+
+                memcpy(result, old_ptr, previous_size);
+                memset(result + previous_size, 0, memory_size - previous_size);
+
+                memCRTDealloc(old_ptr);
+            } else {
+                memset(result, 0, memory_size);
+            }
+
+            return result;
+        } break;
+
+        case Memory_Allocator_Mode_DEALLOC: {
+            if (old_ptr == NULL) {
+                return NULL;
+            }
+
+            Size header_size = memAlignUp(sizeof(struct MemCRT_Header));
+            Byte *mem = (Byte*)old_ptr - header_size;
+            free(mem);
+        } break;
+
+        case Memory_Allocator_Mode_DEALLOC_ALL: {
+            // TODO(naman): Maybe we should use a off-the-shelf malloc that allows this?
+        } break;
+
+        case Memory_Allocator_Mode_NONE: {
+            breakpoint();
+        } break;
+    }
+
+    return NULL;
+}
+
+# endif
+
+# if !defined(NLIB_EXCLUDE_CRT)
+global_variable thread_local Memory_Allocator_Function *memDefaultAllocator = &memCRT;
+global_variable thread_local void *memDefaultAllocatorData = NULL;
+#  define memAlloc(size)          memCRTAlloc(size)
+#  define memRealloc(ptr, size)   memCRTRealloc(ptr, size)
+#  define memDealloc(ptr)         memCRTDealloc(ptr)
+# else
+global_variable thread_local Memory_Allocator_Function *memDefaultAllocator = &memUser;
+global_variable thread_local Memory_User *memDefaultAllocatorData = NULL;
+#  define memAlloc(size)          memUserAlloc(memDefaultAllocatorData, size)
+#  define memRealloc(ptr, size)   memUserRealloc(memDefaultAllocatorData, ptr, size)
+#  define memDealloc(ptr)         memUserDealloc(memDefaultAllocatorData, ptr)
+# endif
+
+# if defined(COMPILER_CLANG)
+#  pragma clang diagnostic pop
+# endif
+
+
+/* ****************************************************************************
+ * DATA STRUCTURES ******************************************************************
+ */
+
+/* ==============
+ * Strechy Buffer
+ */
+
+/* API ----------------------------------------
+ * Size  sbufAdd       (T *ptr, T elem)
+ * void  sbufDelete    (T *ptr)
+ * T*    sbufEnd       (T *ptr)
+ *
+ * Size  sbufSizeof    (T *ptr)
+ * Size  sbufElemin    (T *ptr)
+ * Size  sbufMaxSizeof (T *ptr)
+ * Size  sbufMaxElemin (T *ptr)
+ */
+
+typedef struct Sbuf_Header {
+    Size cap; // NOTE(naman): Maximum number of elements that can be stored
+    Size len; // NOTE(naman): Count of elements actually stored
+    Byte buf[];
+} Sbuf_Header;
+
+# define sbuf_GetHeader(sb) ((Sbuf_Header*)(void*)((Byte*)(sb) - offsetof(Sbuf_Header, buf)))
+
+# define sbuf_Len(sb)         ((sb) ? sbuf_GetHeader(sb)->len : 0U)
+# define sbuf_Cap(sb)         ((sb) ? sbuf_GetHeader(sb)->cap : 0U)
+
+# define sbufAdd(sb, ...)     ((sb) = sbuf_Grow((sb), sizeof(*(sb))),   \
+                               (sb)[sbuf_Len(sb)] = (__VA_ARGS__),      \
+                               ((sbuf_GetHeader(sb))->len)++)
+# define sbufDelete(sb)       ((sb) ?                                   \
+                               (memDealloc(sbuf_GetHeader(sb)), (sb) = NULL) : \
+                               0)
+# define sbufClear(sb)        ((sb) ?                                   \
+                               (memset((sb), 0, sbufSizeof(sb)),        \
+                                sbuf_GetHeader(sb)->len = 0) :          \
+                               0)
+# define sbufResize(sb, n)    (((n) > sbufMaxElemin(sb)) ?              \
+                               ((sb) = sbuf_Resize(sb, n, sizeof(*(sb)))) : \
+                               0)
+
+# define sbufSizeof(sb)       (sbuf_Len(sb) * sizeof(*(sb)))
+# define sbufElemin(sb)       (sbuf_Len(sb))
+# define sbufMaxSizeof(sb)    (sbuf_Cap(sb) * sizeof(*(sb)))
+# define sbufMaxElemin(sb)    (sbuf_Cap(sb))
+# define sbufEnd(sb)          ((sb) + sbuf_Len(sb))
+
+#define sbufPrint(sb, ...) ((sb) = sbuf_Print((sb), __VA_ARGS__))
+
+#define sbufUnsortedRemove(sb, i) (((sb)[(i)] = (sb)[sbuf_Len(sb) - 1]), \
+                                   ((sbuf_GetHeader(sb)->len)--))
+
+# if defined(COMPILER_CLANG)
+#  pragma clang diagnostic push
+#   pragma clang diagnostic ignored "-Wcast-align"
+# endif
+
+header_function
+void* sbuf_Grow (void *buf, Size elem_size)
+{
+    if ((sbuf_Len(buf) + 1) <= sbuf_Cap(buf)) {
+        return buf;
+    } else {
+        Size new_cap = max(2 * sbuf_Cap(buf), 4U);
+
+        Size new_size = (new_cap * elem_size) + sizeof(Sbuf_Header);
+
+        Sbuf_Header *new_header = NULL;
+
+        if (buf != NULL) {
+            new_header = memRealloc(sbuf_GetHeader(buf), new_size);
+        } else {
+            new_header = memAlloc(new_size);
+        }
+
+        new_header->cap = new_cap;
+
+        return new_header->buf;
+    }
+}
+
+header_function
+void* sbuf_Resize (void *buf, Size elem_count, Size elem_size)
+{
+    Size new_cap = elem_count;
+
+    Size new_size = (new_cap * elem_size) + sizeof(Sbuf_Header);
+
+    Sbuf_Header *new_header = NULL;
+
+    if (buf != NULL) {
+        new_header = memRealloc(sbuf_GetHeader(buf), new_size);
+    } else {
+        new_header = memAlloc(new_size);
+    }
+
+    new_header->cap = new_cap;
+
+    return new_header->buf;
+}
+
+# if defined(COMPILER_CLANG)
+#  pragma clang diagnostic push
+#   pragma clang diagnostic ignored "-Wformat-nonliteral"
+# endif
+header_function
+Char* sbuf_Print(Char *buf, const Char *fmt, ...)
+{
+    // TODO(naman): Replace with stbsp_vsnprintf once the following bug is taken care of:
+    // https://github.com/nothings/stb/issues/612
+    va_list args;
+
+    va_start(args, fmt);
+    size_t cap = sbufMaxElemin(buf) - sbufElemin(buf);
+    int n = 1 + vsnprintf(sbufEnd(buf), cap, fmt, args);
+    va_end(args);
+
+    if ((Size)n > cap) {
+        sbufResize(buf, (Size)n + sbufElemin(buf));
+        size_t new_cap = sbufMaxElemin(buf) - sbufElemin(buf);
+    va_start(args, fmt);
+        n = 1 + vsnprintf(sbufEnd(buf), new_cap, fmt, args);
+    va_end(args);
+    }
+
+    sbuf_GetHeader(buf)->len += ((Size)n - 1);
+    return buf;
+}
+# if defined(COMPILER_CLANG)
+#  pragma clang diagnostic pop
+# endif
+
+header_function
+void sbufUnitTest (void)
+{
+    S32 *buf = NULL;
+
+    sbufAdd(buf, 42);
+    utTest(buf != NULL);
+
+    sbufAdd(buf, 1234);
+
+    utTest(sbufElemin(buf) == 2);
+    utTest(sbufMaxElemin(buf) >= sbufElemin(buf));
+
+    utTest(buf[0] == 42);
+    utTest(buf[1] == 1234);
+
+    sbufDelete(buf);
+
+    utTest(buf == NULL);
+
+    Char *stream = NULL;
+    sbufPrint(stream, "Hello, %s\n", "World!");
+    sbufPrint(stream, "Still here? %d\n", 420);
+    sbufPrint(stream, "GO AWAY!!!\n");
+
+    utTest(strcmp(stream, "Hello, World!\nStill here? 420\nGO AWAY!!!\n") == 0);
+}
+
+# if defined(COMPILER_CLANG)
+#  pragma clang diagnostic pop
+# endif
+
+
+
+/* ==========================
+ * Interning
+ *
+ * Char* internString (Intern_String *is, Char *str)
+ */
+
+#define INTERN_EQUALITY(func_name) B32 func_name (void *a, void *b, Size b_index)
+typedef INTERN_EQUALITY(Intern_Equality_Function);
+
+typedef struct Intern {
+    struct Intern_List {
+        Size *indices;
+        U8 *secondary_hashes;
+    } lists[256];
+} Intern;
+
+header_function
+B32 internCheck (Intern *it, U8 hash1, U8 hash2,
+                 void *datum, void *data, Intern_Equality_Function *eqf,
+                 Size *result)
+{
+    if (it->lists[hash1].secondary_hashes != NULL) {
+        // Our data has probably been inserted already.
+        // (or atleast some data with same hash has been inserted :)
+        for (Size i = 0; i < sbufElemin(it->lists[hash1].secondary_hashes); i++) {
+            Size index = it->lists[hash1].indices[i];
+            if ((it->lists[hash1].secondary_hashes[i] == hash2) && eqf(datum, data, index)) {
+                // This is our data, return it
+                if (result != NULL) {
+                    *result = index;
+                }
+                return true;
+            }
+        }
+
+        return false;
+    } else {
+        return false;
+    }
+}
+
+header_function
+void internData (Intern *it, U8 hash1, U8 hash2, Size index)
+{
+    sbufAdd(it->lists[hash1].secondary_hashes, hash2);
+    sbufAdd(it->lists[hash1].indices, index);
+}
+
+header_function
+U8 internStringPearsonHash (void *buffer, Size len, B32 which)
+{
+    // NOTE(naman): Pearson's hash for 8-bit hashing
+    // https://en.wikipedia.org/wiki/Pearson_hashing
+    persistent_value U8 hash_lookup_table1[256] =
+        {
+         // 0-255 shuffled in any (random) order suffices
+         98,    6,   85, 150,  36,  23, 112, 164, 135, 207, 169,   5,  26,  64, 165, 219, // 01
+         61,   20,   68,  89, 130,  63,  52, 102,  24, 229, 132, 245,  80, 216, 195, 115, // 02
+         90,  168,  156, 203, 177, 120,   2, 190, 188,   7, 100, 185, 174, 243, 162,  10, // 03
+         237,  18,  253, 225,   8, 208, 172, 244, 255, 126, 101,  79, 145, 235, 228, 121, // 04
+         123, 251,   67, 250, 161,   0, 107,  97, 241, 111, 181,  82, 249,  33,  69,  55, // 05
+         59,  153,   29,   9, 213, 167,  84,  93,  30,  46, 94,   75, 151, 114,  73, 222, // 06
+         197,  96,  210,  45,  16, 227, 248, 202,  51, 152, 252, 125,  81, 206, 215, 186, // 07
+         39,  158,  178, 187, 131, 136,   1,  49,  50,  17, 141,  91,  47, 129,  60,  99, // 08
+         154,  35,   86, 171, 105,  34,  38, 200, 147,  58,  77, 118, 173, 246,  76, 254, // 09
+         133, 232,  196, 144, 198, 124,  53,   4, 108,  74, 223, 234, 134, 230, 157, 139, // 10
+         189, 205,  199, 128, 176,  19, 211, 236, 127, 192, 231,  70, 233,  88, 146,  44, // 11
+         183, 201,   22,  83,  13, 214, 116, 109, 159,  32,  95, 226, 140, 220,  57,  12, // 12
+         221,  31,  209, 182, 143,  92, 149, 184, 148,  62, 113,  65,  37,  27, 106, 166, // 13
+         3,    14,  204,  72,  21,  41,  56,  66,  28, 193,  40, 217,  25,  54, 179, 117, // 14
+         238,  87,  240, 155, 180, 170, 242, 212, 191, 163,  78, 218, 137, 194, 175, 110, // 15
+         43,  119,  224,  71, 122, 142,  42, 160, 104,  48, 247, 103,  15,  11, 138, 239, // 16
+        };
+
+    persistent_value U8 hash_lookup_table2[256] =
+        {
+         251, 175, 119, 215,  81,  14,  79, 191, 103,  49, 181, 143, 186, 157,   0, 232, // 01
+         31,   32,  55,  60, 152,  58,  17, 237, 174,  70, 160, 144, 220,  90,  57, 223, // 02
+         59,    3,  18, 140, 111, 166, 203, 196, 134, 243, 124,  95, 222, 179, 197,  65, // 03
+         180,  48,  36,  15, 107,  46, 233, 130, 165,  30, 123, 161, 209,  23,  97,  16, // 04
+         40,   91, 219,  61, 100,  10, 210, 109, 250, 127,  22, 138,  29, 108, 244,  67, // 05
+         207,   9, 178, 204,  74,  98, 126, 249, 167, 116,  34,  77, 193, 200, 121,   5, // 06
+         20,  113,  71,  35, 128,  13, 182,  94,  25, 226, 227, 199,  75,  27,  41, 245, // 07
+         230, 224,  43, 225, 177,  26, 155, 150, 212, 142, 218, 115, 241,  73,  88, 105, // 08
+         39,  114,  62, 255, 192, 201, 145, 214, 168, 158, 221, 148, 154, 122,  12,  84, // 09
+         82,  163,  44, 139, 228, 236, 205, 242, 217,  11, 187, 146, 159,  64,  86, 239, // 10
+         195,  42, 106, 198, 118, 112, 184, 172,  87,   2, 173, 117, 176, 229, 247, 253, // 11
+         137, 185,  99, 164, 102, 147,  45,  66, 231,  52, 141, 211, 194, 206, 246, 238, // 12
+         56,  110,  78, 248,  63, 240, 189,  93,  92,  51,  53, 183,  19, 171,  72,  50, // 13
+         33,  104, 101,  69,   8, 252,  83, 120,  76, 135,  85,  54, 202, 125, 188, 213, // 14
+         96,  235, 136, 208, 162, 129, 190, 132, 156,  38,  47,   1,   7, 254,  24,   4, // 15
+         216, 131,  89,  21,  28, 133,  37, 153, 149,  80, 170,  68,   6, 169, 234, 151, // 16
+        };
+
+    Char *string = buffer;
+
+    U8 hash = (U8)len;
+    for (Size i = 0; i < len; i++) {
+        if (which == true) {
+            hash = hash_lookup_table1[hash ^ string[i]];
+        } else {
+            hash = hash_lookup_table2[hash ^ string[i]];
+        }
+    }
+
+    return hash;
+}
+
+typedef struct Intern_String {
+    Intern intern;
+    Char *strings;
+} Intern_String;
+
+header_function
+INTERN_EQUALITY(internStringEquality) {
+    Char *sa = a;
+    Char *sb = (Char *)b + b_index;
+    B32 result = (strcmp(sa, sb) == 0);
+    return result;
+}
+
+header_function
+Char *internString (Intern_String *is, Char *str)
+{
+    U8 hash1 = internStringPearsonHash(str, strlen(str), true);
+    U8 hash2 = internStringPearsonHash(str, strlen(str), false);
+
+    Size index = 0;
+
+    if (internCheck(&is->intern, hash1, hash2, str, is->strings, &internStringEquality, &index)) {
+        Char *result = is->strings + index;
+        return result;
+    } else {
+        Size index_new = sbufElemin(is->strings);
+        for (Char *s = str; s[0] != '\0'; s++) {
+            sbufAdd(is->strings, s[0]);
+        }
+        sbufAdd(is->strings, '\0');
+        internData(&is->intern, hash1, hash2, index_new);
+        Char *result = is->strings + index_new;
+        return result;
+    }
+}
+
+header_function
+Char *internStringCheck (Intern_String *is, Char *str)
+{
+    U8 hash1 = internStringPearsonHash(str, strlen(str), true);
+    U8 hash2 = internStringPearsonHash(str, strlen(str), false);
+
+    Size index = 0;
+
+    if (internCheck(&is->intern, hash1, hash2, str, is->strings, &internStringEquality, &index)) {
+        Char *result = is->strings + index;
+        return result;
+    } else {
+        return NULL;
+    }
+}
+
+typedef struct Intern_Integer {
+    Intern intern;
+    U64 *integers;
+} Intern_Integer;
+
+header_function
+INTERN_EQUALITY(internIntegerEquality) {
+    U64 ia = ((U64*)a)[0];
+    U64 ib = ((U64*)b)[b_index];
+
+    B32 result = (ia == ib);
+    return result;
+}
+
+// SEE(naman): https://stackoverflow.com/a/8546542
+header_function
+U8 internIntegerHash8Bit (U64 key, B32 which)
+{
+    U8 result = 0;
+    U64 q = 0;
+
+    // NOTE(naman): Both q are prime.
+    if (which == true) {
+        q = 33149;
+    } else {
+        q = 146519;
+    }
+
+    Byte *b = (Byte*)(&key);
+    for (Size i = 0; i < sizeof(key); i++) {
+        result += (U8)((U64)(b[i]) * q);
+    }
+
+    return result;
+}
+
+header_function
+U64 internInteger (Intern_Integer *ii, U64 num)
+{
+    U8 hash1 = internIntegerHash8Bit(num, true);
+    U8 hash2 = internIntegerHash8Bit(num, false);
+
+    U64 num_copy = num; // Just in case
+    Size index = 0;
+
+    if (internCheck(&ii->intern, hash1, hash2,
+                    &num_copy, ii->integers, &internIntegerEquality, &index)) {
+        return num;
+    } else {
+        sbufAdd(ii->integers, num);
+        internData(&ii->intern, hash1, hash2, sbufElemin(ii->integers));
+        return num;
+    }
+}
+
+header_function
+U64 internIntegerCheck (Intern_Integer *ii, U64 num)
+{
+    U8 hash1 = internIntegerHash8Bit(num, true);
+    U8 hash2 = internIntegerHash8Bit(num, false);
+
+    U64 num_copy = num; // Just in case
+    Size index = 0;
+
+    if (internCheck(&ii->intern, hash1, hash2,
+                    &num_copy, ii->integers, &internIntegerEquality, &index)) {
+        return num;
+    } else {
+        return false;
+    }
+}
+
+header_function
+void internUnitTest (void)
+{
+    Char x[] = "Hello";
+    Char y[] = "Hello";
+
+    Intern_String is = {0};
+
+    utTest(x != y);
+
+    Char *y_interned = internString(&is, y);
+    Char *x_interned = internString(&is, x);
+    utTest(x_interned == y_interned);
+
+    Char z[] = "World";
+    Char *z_interned = internString(&is, z);
+    utTest(x_interned != z_interned);
+
+    Char p[] = "Hello!!";
+    Char *p_interned = internString(&is, p);
+    utTest(x_interned != p_interned);
+
+    // TODO(naman): Write tests to see what happens if two strings with same hash are interned.
+
+    return;
+}
+
+/* ==========================
+ * Hashing Infrastructure
+ */
+
+// TODO(naman): Add hash collision detection
+
+// FNV-1a
+header_function
+U64 hashString (Char *str)
+{
+    U64 hash = 0xCBF29CE484222325ULL; // FNV_offset_basis
+    for (Size i = 0; str[i] != '\0'; i++) {
+        hash = hash ^ (U64)str[i];
+        hash = hash * 0x100000001B3ULL; // FNV_prime
+    }
+
+    return hash;
+}
+
+// splitmix64 (xoshiro.di.unimi.it/splitmix64.c)
+header_function
+U64 hashInteger(U64 x)
+{
+    x ^= x >> 30;
+    x *= 0xBF58476D1CE4E5B9ULL;
+    x ^= x >> 27;
+    x *= 0x94D049BB133111EBULL;
+    x ^= x >> 31;
+    return x;
+}
+
+/* Universal Hashing: https://en.wikipedia.org/wiki/Universal_hashing#Avoiding_modular_arithmetic
+ *
+ * NOTE(naman): Implementation notes
+ * w is number of bits in machine word (64 in our case)
+ * s is the number of buckets/bins (slots in the hash table) to which the
+ *   universe of hashable objects is to be mapped
+ * m is log2(s) (=> m = 2^s) and is equal to the number of bits in the final hash
+ * a is a random odd positive integer < 2^w (fitting in w bits)
+ * b is a random non-negative integer < 2^(w-m) (fitting in (w-m) bits)
+ * SEE(naman): https://en.wikipedia.org/wiki/Universal_hashing#Avoiding_modular_arithmetic
+ *
+ * r is the last random number generated and is just an implementation detail.
+ */
+
+typedef struct Hash_Universal {
+    U64 a, b, m; /* Hashing constants */
+
+    U64 r; /* Last random number for Universal Hashing */
+} Hash_Universal;
+
+header_function
+void hashUniversalConstantsUpdate (Hash_Universal *h)
+{
+    do {
+        h->r = u64Rand(h->r);
+        h->a = h->r;
+    } while ((h->a > 0) && ((h->a & 0x01) != 0x01)); // Make sure that 'a' is odd
+
+    h->r = u64Rand(h->r);
+    // b should be (64 - m) bits long
+    h->b = h->r & (0xFFFFFFFFFFFFFFFFULL >> h->m);
+}
+
+header_function
+U64 hashUniversal (Hash_Universal h, U64 key)
+{
+    // NOTE(naman): Remember that we don't want 64-bit hashes, we want hashes < 2^m (s)
+    U64 result =  ((h.a * key) + h.b) >> (64 - h.m);
+    return result;
+}
+
+
+/* ==============
+ * Hash Table
+ */
+
+/* API ---------------------------------------------------
+ * NOTE(naman): Zero key and value are considered invalid.
+ *
+ * Hash_Table htCreate (Size min_slots);
+ * void       htDelete (Hash_Table ht);
+ * U64        htInsert (Hash_Table *ht, U64 key, U64 value);
+ * U64        htLookup (Hash_Table *ht, U64 key);
+ * U64        htRemove (Hash_Table *ht, U64 key);
+ *
+ * Hash_Table htCreateWithAlloc (Size min_slots,
+ *                               Memory_Allocator_Function *allocator, void *allocator_data);
+ */
+
+typedef struct Hash_Table {
+    Hash_Universal univ;
+    Memory_Allocator_Function *allocator;
+    void *allocator_data;
+    U64 *keys;
+    U64 *values;
+    Size slot_count;
+    Size slot_filled;
+} Hash_Table;
+
+header_function
+Hash_Table htCreateWithAlloc (Size slots_atleast,
+                              Memory_Allocator_Function *allocator, void *allocator_data)
+{
+    Hash_Table ht = {0};
+
+    ht.univ.m = u64Log2(max(slots_atleast, 1U)); // Log of closest lower power of two
+
+    // This will make m log of closest upper power of two
+    ht.univ.m = ht.univ.m + 1;
+    ht.slot_count = 1ULL << (ht.univ.m);
+    hashUniversalConstantsUpdate(&ht.univ);
+
+    if (allocator != NULL) {
+        ht.allocator = allocator;
+        ht.allocator_data = allocator_data;
+    } else {
+        ht.allocator = memDefaultAllocator;
+        ht.allocator_data = memDefaultAllocatorData;
+    }
+
+    ht.keys     = ht.allocator(Memory_Allocator_Mode_ALLOC,
+                               (ht.slot_count) * sizeof(*(ht.keys)), NULL,
+                               ht.allocator_data);
+    ht.values   = ht.allocator(Memory_Allocator_Mode_ALLOC,
+                               (ht.slot_count) * sizeof(*(ht.values)), NULL,
+                               ht.allocator_data);
+
+    return ht;
+}
+
+header_function
+Hash_Table htCreate (Size slots_atleast)
+{
+    Hash_Table ht = htCreateWithAlloc(slots_atleast, NULL, NULL);
+
+    return ht;
+}
+
+header_function
+void htDelete (Hash_Table ht)
+{
+    ht.allocator(Memory_Allocator_Mode_DEALLOC, 0, ht.keys,   NULL);
+    ht.allocator(Memory_Allocator_Mode_DEALLOC, 0, ht.values, NULL);
+}
+
+header_function
+B32 ht_LinearProbeSearch (Hash_Table *ht, U64 key, Size *value)
+{
+    Size index = 0;
+    B32 found = false;
+
+    for (Size i = 0; !found && (i < ht->slot_count); ++i) {
+        index = (key + i) % (ht->slot_count);
+        if (ht->keys[index] == key) {
+            found = true;
+            break;
+        }
+    }
+
+    *value = index;
+
+    return found;
+}
+
+header_function
+U64 ht_LinearProbeInsertion (Hash_Table *ht,
+                             U64 hash, U64 key, U64 value)
+{
+    U64 result_value = value;
+
+    for (Size i = 0; i < ht->slot_count; ++i) {
+        Size index = (hash + i) % (ht->slot_count);
+
+        if ((ht->keys[index] == key) || (ht->values[index] == 0))  {
+            result_value = ht->values[index];
+            ht->keys[index] = key;
+            ht->values[index] = value;
+            break;
+        }
+    }
+
+    return result_value;
+}
+
+header_function
+U64 htInsert (Hash_Table *ht, U64 key, U64 value)
+{
+    if ((key == 0) || (value == 0)) return 0;
+
+    // FIXME(naman): Use number of collisions as the parameter for resizing
+    if ((2U * (ht->slot_filled)) > (ht->slot_count)) {
+        Size slot_count_prev = ht->slot_count;
+        U64 *keys   = ht->keys;
+        U64 *values = ht->values;
+
+        ht->univ.m = ht->univ.m + 1;
+        ht->slot_count = 1ULL << (ht->univ.m);
+        hashUniversalConstantsUpdate(&(ht->univ));
+
+        ht->keys   = ht->allocator(Memory_Allocator_Mode_ALLOC,
+                                   sizeof(*(ht->keys)) * ht->slot_count,
+                                   NULL, ht->allocator_data);
+        ht->values = ht->allocator(Memory_Allocator_Mode_ALLOC,
+                                   sizeof(*(ht->values)) * ht->slot_count,
+                                   NULL, ht->allocator_data);
+
+        for (Size i = 0; i < slot_count_prev; ++i) {
+            U64 key_i     = keys[i];
+            U64 value_i   = values[i];
+
+            if (value_i != 0) {
+                U64 hash_new = hashUniversal(ht->univ, key_i);
+                ht_LinearProbeInsertion(ht, hash_new, key_i, value_i);
+            }
+        }
+
+        ht->allocator(Memory_Allocator_Mode_DEALLOC, 0, keys,   ht->allocator_data);
+        ht->allocator(Memory_Allocator_Mode_DEALLOC, 0, values, ht->allocator_data);
+    }
+
+    U64 hash = hashUniversal(ht->univ, key);
+
+    U64 result_value = ht_LinearProbeInsertion(ht, hash, key, value);
+    if (result_value == 0) {
+        ht->slot_filled++;
+    }
+
+    return result_value;
+}
+
+header_function
+U64 htLookup (Hash_Table *ht, U64 key)
+{
+    if (key == 0) return 0;
+
+    Size location = 0;
+    U64 result_value = 0;
+
+    if (ht_LinearProbeSearch(ht, key, &location)) {
+        result_value = ht->values[location];
+    }
+
+    return result_value;
+}
+
+header_function
+U64 htRemove (Hash_Table *ht, U64 key)
+{
+    if (key == 0) return 0;
+
+    Size location = 0;
+    U64 result_value = 0;
+
+    if (ht_LinearProbeSearch(ht, key, &location)) {
+        result_value = ht->values[location];
+    }
+
+    if (result_value != 0) {
+        ht->keys[location] = 0;
+        ht->values[location] = 0;
+        ht->slot_filled -= 1;
+    }
+
+    return result_value;
+}
+
+header_function
+void htUnitTest (void)
+{
+    Hash_Table ht = htCreate(0);
+
+    /* No Entries */
+    utTest(htLookup(&ht, 0) == 0);
+    utTest(htLookup(&ht, 1) == 0);
+    utTest(htLookup(&ht, 2) == 0);
+
+    /* Insertion Test */
+    Size f0 = ht.slot_filled;
+
+    htInsert(&ht, 1, 1);
+    utTest(ht.slot_filled == (f0 + 1));
+    utTest(htLookup(&ht, 0) == 0);
+    utTest(htLookup(&ht, 1) == 1);
+    fflush(stdout);
+    utTest(htLookup(&ht, 2) == 0);
+
+    htInsert(&ht, 2, 42);
+    utTest(ht.slot_filled == (f0 + 2));
+    utTest(htLookup(&ht, 0) == 0);
+    utTest(htLookup(&ht, 1) == 1);
+    utTest(htLookup(&ht, 2) == 42);
+
+    /* Duplicate Key */
+    U64 v1 = htInsert(&ht, 2, 24);
+    utTest(v1 == 42);
+    utTest(htLookup(&ht, 0) == 0);
+    utTest(htLookup(&ht, 1) == 1);
+    utTest(htLookup(&ht, 2) == 24);
+
+    /* Removal Test */
+    U64 v2 = htRemove(&ht, 2);
+    utTest(v2 == 24);
+    utTest(htLookup(&ht, 2) == 0);
+
+    U64 v3 = htRemove(&ht, 1);
+    utTest(v3 == 1);
+    utTest(htLookup(&ht, 1) == 0);
+
+    /* NULL Check */
+    Size f1 = ht.slot_filled;
+    htInsert(&ht, 0, 1);
+    utTest(ht.slot_filled == f1);
+    utTest(htLookup(&ht, 0) == 0);
+
+    Size f2 = ht.slot_filled;
+    htRemove(&ht, 0);
+    utTest(ht.slot_filled == f2);
+    utTest(htLookup(&ht, 0) == 0);
+
+    /* Expansion Test */
+    htInsert(&ht, 3, 33);
+    utTest(htLookup(&ht, 3) == 33);
+
+    htInsert(&ht, 4, 44);
+    utTest(htLookup(&ht, 4) == 44);
+
+    htInsert(&ht, 5, 55);
+    utTest(htLookup(&ht, 5) == 55);
+
+    htInsert(&ht, 6, 66);
+    utTest(htLookup(&ht, 6) == 66);
+
+    htInsert(&ht, 7, 77);
+    utTest(htLookup(&ht, 7) == 77);
+
+    htInsert(&ht, 8, 88);
+    utTest(htLookup(&ht, 8) == 88);
+
+    htInsert(&ht, 9, 99);
+    utTest(htLookup(&ht, 9) == 99);
+
+    /* Removal after Expansion */
+
+    htRemove(&ht, 3);
+    utTest(htLookup(&ht, 3) == 0);
+
+    htRemove(&ht, 4);
+    utTest(htLookup(&ht, 4) == 0);
+
+    htRemove(&ht, 5);
+    utTest(htLookup(&ht, 5) == 0);
+
+    htRemove(&ht, 6);
+    utTest(htLookup(&ht, 6) == 0);
+
+    htRemove(&ht, 7);
+    utTest(htLookup(&ht, 7) == 0);
+
+    htRemove(&ht, 8);
+    utTest(htLookup(&ht, 8) == 0);
+
+    htRemove(&ht, 9);
+    utTest(htLookup(&ht, 9) == 0);
+
+    htDelete(ht);
+
+    return;
+}
+
+#define NLIB_H_INCLUDE_GUARD
+#endif // NLIB_H_INCLUDE_GUARD

resource_manager/src/common/nlib/unicode.h

+/*
+ * Creator: Naman Dixit
+ * Notice: © Copyright 2019 Naman Dixit
+ */
+
+#if !defined(UNICODE_H_INCLUDE_GUARD)
+
+header_function
+B64 unicodeCodepointFromUTF16Surrogate (U16 surrogate, U16 *last_surrogate, U32 *codepoint)
+{
+    U16 utf16_hi_surrogate_start = 0xD800;
+    U16 utf16_lo_surrogate_start = 0xDC00;
+    U16 utf16_surrogate_end = 0xDFFF;
+
+    if ((surrogate >= utf16_hi_surrogate_start) &&
+        (surrogate < utf16_lo_surrogate_start)) {
+        *last_surrogate = surrogate;
+
+        return false;
+    } else {
+        if ((surrogate >= utf16_lo_surrogate_start) &&
+            (surrogate <= utf16_surrogate_end)) {
+            U16 low_surrogate = surrogate;
+            // NOTE(naman): In this line, the numbers get promoted from U16 to S32,
+            // so storing them in a U32 results in a inmpicit sign conversion.
+            // That is why we are casting manually.
+            *codepoint = (U32)((*last_surrogate - utf16_hi_surrogate_start) << 10U);
+            *codepoint |= (low_surrogate - utf16_lo_surrogate_start);
+            *codepoint += 0x10000;
+
+            *last_surrogate = 0;
+        } else {
+            *codepoint = surrogate;
+        }
+
+        return true;
+    }
+}
+
+header_function
+Size unicodeUTF8FromUTF32 (U32 *codepoints, Size codepoint_count, Char *buffer)
+{
+    if (buffer == NULL) {
+        Size length = 1; // NOTE(naman): We need one byte for the NUL byte.
+
+        for (Size i = 0; i < codepoint_count; i++) {
+            if (codepoints[i] <= 0x7F) {
+                length += 1;
+            } else if (codepoints[i] <= 0x7FF) {
+                length += 2;
+            } else if (codepoints[i] <= 0xFFFF) {
+                length += 3;
+            } else if (codepoints[i] <= 0x10FFFF) {
+                length += 4;
+            }
+        }
+
+        return length;
+    } else {
+        Size length = 1; // NOTE(naman): We need one byte for the NUL byte.
+
+        for (Size i = 0; i < codepoint_count; i++) {
+            if (codepoints[i] <= 0x7F) {
+                buffer[0] = (Char)codepoints[i];
+                buffer += 1;
+                length += 1;
+            } else if (codepoints[i] <= 0x7FF) {
+                buffer[0] = (Char)(0xC0 | (codepoints[i] >> 6));            /* 110xxxxx */
+                buffer[1] = (Char)(0x80 | (codepoints[i] & 0x3F));          /* 10xxxxxx */
+                buffer += 2;
+                length += 2;
+            } else if (codepoints[i] <= 0xFFFF) {
+                buffer[0] = (Char)(0xE0 | (codepoints[i] >> 12));           /* 1110xxxx */
+                buffer[1] = (Char)(0x80 | ((codepoints[i] >> 6) & 0x3F));   /* 10xxxxxx */
+                buffer[2] = (Char)(0x80 | (codepoints[i] & 0x3F));          /* 10xxxxxx */
+                buffer += 3;
+                length += 3;
+            } else if (codepoints[i] <= 0x10FFFF) {
+                buffer[0] = (Char)(0xF0 | (codepoints[i] >> 18));           /* 11110xxx */
+                buffer[1] = (Char)(0x80 | ((codepoints[i] >> 12) & 0x3F));  /* 10xxxxxx */
+                buffer[2] = (Char)(0x80 | ((codepoints[i] >> 6) & 0x3F));   /* 10xxxxxx */
+                buffer[3] = (Char)(0x80 | (codepoints[i] & 0x3F));          /* 10xxxxxx */
+                buffer += 4;
+                length += 4;
+            }
+        }
+
+        buffer[0] = '\0';
+
+        return length;
+    }
+}
+
+# if defined(OS_WINDOWS)
+
+header_function
+LPWSTR unicodeWin32UTF16FromUTF8 (Char *utf8)
+{
+    int wcstr_length = MultiByteToWideChar(CP_UTF8, 0, utf8, -1, NULL, 0);
+    LPWSTR wcstr = VirtualAlloc(NULL, (DWORD)wcstr_length * sizeof(wchar_t),
+                                MEM_COMMIT, PAGE_READWRITE);
+    MultiByteToWideChar(CP_UTF8, 0, utf8, -1, wcstr, wcstr_length);
+
+    int normalized_length = NormalizeString(NormalizationC,
+                                            wcstr, -1,
+                                            NULL, 0);
+    LPWSTR norm = VirtualAlloc(NULL, (DWORD)normalized_length * sizeof(wchar_t),
+                               MEM_COMMIT, PAGE_READWRITE);
+    NormalizeString(NormalizationC, wcstr, -1, norm, normalized_length);
+
+    VirtualFree(wcstr, 0, MEM_RELEASE);
+
+    return norm;
+}
+
+header_function
+void unicodeWin32UTF16Dealloc (LPWSTR utf16)
+{
+    VirtualFree(utf16, 0, MEM_RELEASE);
+}
+
+# endif
+
+#define UNICODE_H_INCLUDE_GUARD
+#endif

resource_manager/src/grunt/grunt.c

+/*
+ * Creator: Naman Dixit
+ * Notice: © Copyright 2020 Naman Dixit
+ */
+
+#include "nlib/nlib.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netdb.h>
+#include <unistd.h>
+#include <ctype.h>
+#include <sys/ioctl.h>
+#include <net/if.h>
+#include <netinet/in.h>
+#include <sys/epoll.h>
+#include <sys/time.h>
+
+#define MAX_EPOLL_EVENTS 1024
+
+# if defined(COMPILER_CLANG)
+#  pragma clang diagnostic push
+#   pragma clang diagnostic ignored "-Wpadded"
+#   pragma clang diagnostic ignored "-Wfloat-equal"
+# endif
+#include "cJSON/cJSON.h"
+#include "cJSON/cJSON.c"
+# if defined(COMPILER_CLANG)
+#  pragma clang diagnostic pop
+# endif
+
+typedef struct Command {
+    Sint id;
+    Sint dispatcher_socket;
+
+    Sint memory;
+} Command;
+
+#include "time.c"
+#include"socket.c"
+
+int main(int argc, char** argv)
+{
+    unused_variable(argc);
+    unused_variable(argv);
+
+    Char *port = "9527";
+
+    Sint sock_fd = socket(AF_INET, SOCK_STREAM, 0);
+
+    struct addrinfo hints = {.ai_family = AF_INET,
+                             .ai_socktype = SOCK_STREAM};
+    struct addrinfo *result = NULL;
+    Sint s = getaddrinfo(NULL, port, &hints, &result);
+    if (s != 0) {
+        fprintf(stderr, "Error: getaddrinfo: %s\n", gai_strerror(s));
+        exit(-1);
+    }
+
+    // NOTE(naman): Create an epoll instance, with no flags set.
+    int epoll_fd = epoll_create1(0);
+    if (epoll_fd < 0) {
+        perror("epoll_create1");
+        exit(-1);
+    }
+
+    // NOTE(naman): Add the socket's file descriptor to the epoll set
+    struct epoll_event accept_event = {.data.fd = sock_fd,
+                                       .events = EPOLLIN};
+    if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, sock_fd, &accept_event) < 0) {
+        perror("epoll_ctl EPOLL_CTL_ADD");
+        exit(-1);
+    }
+
+    // NOTE(naman): Allocate memory for epoll array
+    struct epoll_event* events = calloc(MAX_EPOLL_EVENTS, sizeof(struct epoll_event));
+    if (events == NULL) {
+        fprintf(stderr, "Unable to allocate memory for epoll_events");
+        exit(-1);
+    }
+
+    while (connect(sock_fd, result->ai_addr, result->ai_addrlen) == -1) {
+        fprintf(stderr, "Error: Couldn't connect on port %s, trying again in one second...\n", port);
+        sleep(1);
+    }
+
+    printf("Log: Starting communication with server on port %s...\n", port);
+
+    U64 time_begin = timeMilli();
+    U64 time_accum = 0;
+
+    while (true) {
+        // NOTE(naman): Get the fd's that are ready
+        int nready = epoll_wait(epoll_fd, events, MAX_EPOLL_EVENTS, 1000);
+
+        for (int i = 0; i < nready; i++) {
+            if (events[i].events & EPOLLERR) {
+                perror("epoll_wait returned EPOLLERR");
+                exit(-1);
+            }
+
+            if (events[i].events & EPOLLIN) {
+                B32 initialized = false;
+                Size buffer_len = 0;
+                Size buffer_cap = MiB(1);
+                U32 buffer_expected_len = 0;
+                Char *buffer = calloc(buffer_cap, sizeof(*buffer));
+
+                Char size_bytes[4] = {0};
+                Size size_bytes_count = 0;
+
+                Command *c = NULL;
+
+                while (true) {
+                    if (initialized == false) {
+                        long len = read(sock_fd,
+                                        (Char*)size_bytes + size_bytes_count,
+                                        4 - size_bytes_count);
+
+                        if (len == 0) {
+                            perror("read() returned zero");
+                            exit(-1);
+                        }
+
+                        size_bytes_count += (Size)len;
+
+                        if (size_bytes_count == 4) {
+                            initialized = true;
+
+                            buffer_expected_len = (U32)((size_bytes[3] <<  0U) |
+                                                        (size_bytes[2] <<  8U) |
+                                                        (size_bytes[1] << 16U) |
+                                                        (size_bytes[0] << 24U));
+                        }
+
+                        continue;
+                    } else {
+                        long len = read(sock_fd,
+                                        buffer + buffer_len,
+                                        buffer_expected_len - buffer_len);
+
+                        buffer_len += (Size)len;
+
+                        if (buffer_expected_len == buffer_len) {
+                            cJSON_Print(cJSON_Parse(buffer));
+                            printf("%.*s", (int)buffer_len, buffer);
+
+                            const Char *json_error = NULL;
+                            cJSON *root = cJSON_ParseWithOpts(buffer, &json_error, true);
+
+                            if (root == NULL) {
+                                // TODO(naman): Error
+                            } else {
+                                c = calloc(1, sizeof(*c));
+
+                                c->id = cJSON_GetObjectItem(root, "id")->valueint;
+                                c->dispatcher_socket = cJSON_GetObjectItem(root, "dispatcher_socket")->valueint;
+
+                                c->memory = cJSON_GetObjectItem(root, "memory")->valueint;
+                            }
+
+                            free(buffer);
+                            break;
+                        }
+                    }
+                }
+
+                int memory = 0;
+
+                FILE *meminfo = fopen("/proc/meminfo", "r");
+                Char line[256] = {0};
+                while(fgets(line, sizeof(line), meminfo)) {
+                    if (sscanf(line, "MemTotal: %d kB", &memory) == 1) {
+                        fclose(meminfo);
+                        break;
+                    }
+                }
+
+                Char *output = NULL;
+
+                sbufPrint(output, "    ");
+                sbufPrint(output, "{\n\"id\": %d", c->id);
+                sbufPrint(output, ",\n\"dispatcher_socket\": %d", c->dispatcher_socket);
+                sbufPrint(output, ",\n\"type\": \"response\"");
+
+                if (memory >= c->memory) {
+                    sbufPrint(output, ",\n\"success\": %d\n", 1);
+                } else {
+                    sbufPrint(output, ",\n\"success\": %d\n", 0);
+                }
+
+                sbufPrint(output, "\n}\n");
+                Size output_len = strlen(output);
+
+#if defined(ENDIAN_LITTLE)
+                U32 json_len = (U32)output_len - 4;
+                U32 json_len_be = swap_endian(json_len);
+                output[0] = ((Char*)&json_len_be)[0];
+                output[1] = ((Char*)&json_len_be)[1];
+                output[2] = ((Char*)&json_len_be)[2];
+                output[3] = ((Char*)&json_len_be)[3];
+#endif
+
+                socketWrite(output, output_len, sock_fd);
+            }
+        }
+
+        { // Send a heartbeat message if it is time to do so
+            U64 time_new = timeMilli();
+            U64 time_passed = time_new - time_begin;
+            time_begin = time_new;
+            time_accum += time_passed;
+
+            if (time_accum >= 1000) {
+                time_accum = 0;
+
+                int memory = 0;
+
+                FILE *meminfo = fopen("/proc/meminfo", "r");
+                Char line[256] = {0};
+                while(fgets(line, sizeof(line), meminfo)) {
+                    if (sscanf(line, "MemTotal: %d kB", &memory) == 1) {
+                        fclose(meminfo);
+                        break;
+                    }
+                }
+
+                Char *output = NULL;
+
+                sbufPrint(output, "    ");
+                sbufPrint(output, "{");
+                sbufPrint(output, " \n\"type\": \"heartbeat\"");
+                sbufPrint(output, ",\n\"memory\": %d", memory);
+
+                sbufPrint(output, "\n}\n");
+                Size output_len = strlen(output);
+
+#if defined(ENDIAN_LITTLE)
+                U32 json_len = (U32)output_len - 4;
+                U32 json_len_be = swap_endian(json_len);
+                output[0] = ((Char*)&json_len_be)[0];
+                output[1] = ((Char*)&json_len_be)[1];
+                output[2] = ((Char*)&json_len_be)[2];
+                output[3] = ((Char*)&json_len_be)[3];
+#endif
+
+                socketWrite(output, output_len, sock_fd);
+            }
+        }
+    }
+}

resource_manager/src/grunt/socket.c

+/*
+ * Creator: Naman Dixit
+ * Notice: © Copyright 2020 Naman Dixit
+ */
+
+internal_function
+void socketWrite (Char *output, Size output_len,
+                  int sock_fd)
+{
+    ssize_t nsent = 0;
+    Size output_cursor = 0;
+    while (true) {
+        nsent = write(sock_fd, output + output_cursor, output_len - output_cursor);
+
+        if (nsent == -1) {
+            if (errno == EAGAIN || errno == EWOULDBLOCK) {
+                continue;
+            } else {
+                exit(-1);
+            }
+        } else if ((Size)nsent < output_len) {
+            output_cursor += (Size)nsent;
+        } else {
+            break;
+        }
+    }
+}

resource_manager/src/grunt/time.c

+/*
+ * Creator: Naman Dixit
+ * Notice: © Copyright 2020 Naman Dixit
+ */
+
+internal_function
+U64 timeMilli (void)
+{
+    struct timespec now = {0};
+
+    U64 nanosec = 0;
+
+    if (clock_gettime(CLOCK_MONOTONIC_RAW, &now) == 0) {
+        nanosec = ((U64)now.tv_sec * 1000000000ULL) + (U64)now.tv_nsec;
+    } else {
+        struct timeval now_low = {0};
+        gettimeofday(&now_low, NULL);
+        nanosec = ((U64)now_low.tv_sec * 1000000000ULL) + (U64)(now_low.tv_usec * 100);
+    }
+
+    U64 millisec = nanosec / 1000000ULL;
+
+    return millisec;
+}

resource_manager/src/test/test.c

+/*
+ * Creator: Naman Dixit
+ * Notice: © Copyright 2020 Naman Dixit
+ */
+
+/*
+ * Creator: Naman Dixit
+ * Notice: © Copyright 2019 Naman Dixit
+ */
+
+#include "nlib/nlib.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netdb.h>
+#include <unistd.h>
+#include <ctype.h>
+
+# if defined(COMPILER_CLANG)
+#  pragma clang diagnostic push
+#   pragma clang diagnostic ignored "-Wpadded"
+#   pragma clang diagnostic ignored "-Wfloat-equal"
+# endif
+#include "cJSON/cJSON.h"
+#include "cJSON/cJSON.c"
+# if defined(COMPILER_CLANG)
+#  pragma clang diagnostic pop
+# endif
+
+
+int main(int argc, char** argv)
+{
+    if (argc < 2) {
+        printf("Error: Pass the amount of memory\n");
+        exit(-1);
+    }
+
+    Sint memory_required = (Sint)strtol(argv[1], NULL, 10);
+
+    Char *port = "9526";
+
+    Sint sock_fd = socket(AF_INET, SOCK_STREAM, 0);
+
+    struct addrinfo hints = {.ai_family = AF_INET,
+                             .ai_socktype = SOCK_STREAM};
+    struct addrinfo *result = NULL;
+    Sint s = getaddrinfo(NULL, port, &hints, &result);
+    if (s != 0) {
+        fprintf(stderr, "Error: getaddrinfo: %s\n", gai_strerror(s));
+        exit(-1);
+    }
+
+    while (connect(sock_fd, result->ai_addr, result->ai_addrlen) == -1) {
+        fprintf(stderr, "Error: Couldn't connect on port %s, trying again in one second...\n", port);
+        sleep(1);
+    }
+
+    printf("Log: Starting communication with server on port %s...\n", port);
+
+    Char *output = NULL;
+
+    sbufPrint(output, "    ");
+    sbufPrint(output, "{\n\"id\": %d", (Sint)time(NULL));
+    sbufPrint(output, ",\n\"memory\": %d", memory_required);
+    sbufPrint(output, "\n}\n");
+    Size output_len = strlen(output);
+
+    printf("Sending to Arbiter:\n%s\n",
+           cJSON_Print(cJSON_Parse(output + 4)));
+
+#if defined(ENDIAN_LITTLE)
+    U32 json_len = (U32)output_len - 4;
+    U32 json_len_be = swap_endian(json_len);
+    output[0] = ((Char*)&json_len_be)[0];
+    output[1] = ((Char*)&json_len_be)[1];
+    output[2] = ((Char*)&json_len_be)[2];
+    output[3] = ((Char*)&json_len_be)[3];
+#endif
+
+    write(sock_fd, output, output_len);
+
+    {
+        cJSON *array = NULL;
+
+        B32 initialized = false;
+        Size buffer_len = 0;
+        Size buffer_cap = MiB(1);
+        U32 buffer_expected_len = 0;
+        Char *buffer = calloc(buffer_cap, sizeof(*buffer));
+
+        Char size_bytes[4] = {0};
+        Size size_bytes_count = 0;
+
+        while (true) {
+            if (initialized == false) {
+                long len = read(sock_fd,
+                                (Char*)size_bytes + size_bytes_count,
+                                4 - size_bytes_count);
+
+                if (len == 0) {
+                    perror("read() returned zero");
+                    exit(-1);
+                }
+
+                size_bytes_count += (Size)len;
+
+                if (size_bytes_count == 4) {
+                    initialized = true;
+
+                    buffer_expected_len = (U32)((size_bytes[3] <<  0U) |
+                                                (size_bytes[2] <<  8U) |
+                                                (size_bytes[1] << 16U) |
+                                                (size_bytes[0] << 24U));
+                }
+
+                continue;
+            } else {
+                long len = read(sock_fd,
+                                buffer + buffer_len,
+                                buffer_expected_len - buffer_len);
+
+                buffer_len += (Size)len;
+
+                if (buffer_expected_len == buffer_len) {
+                    printf("Recieved: Final Response:\n%s\n",
+                           cJSON_Print(cJSON_Parse(buffer)));
+
+                    const Char *json_error = NULL;
+                    cJSON *root = cJSON_ParseWithOpts(buffer, &json_error, true);
+
+                    if (root == NULL) {
+                        // TODO(naman): Error
+                    } else {
+                        array = cJSON_GetObjectItem(root, "ip");
+                    }
+
+                    free(buffer);
+                    break;
+                }
+            }
+        }
+    }
+
+    return 0;
+}

resource_manager/version.linux

+368