Implement arena allocator to reduce allocation

In this patch, by introducing arena allocator, also known as regional
allocator, and optimizing calloc byte buffer clearing algorithm, the
compiler's memory usage, page fault occurrence frequency, and
performance are significantly improved. The resident set size has been
reduced up to 2/3.

Arena allocator's introduction allows future development safely
allocating structures without worrying their lifetime. This has already
been implemented in SSA unit's "basic_block_t" allocation, which now
doesn't require traversal to free up all connected detached basic
blocks.

In addition, calloc's byte buffer clearing algorithm has been changed
into bulk clearing algorithm, which clears up 4 bytes at a time when
requested byte buffer's size is large enough.

Author: ChAoSUnItY

lib/c.c

@@ -629,12 +629,27 @@ void *malloc(int size)
 
 void *calloc(int n, int size)
 {
-    char *p = malloc(n * size);
+    int total = n * size;
+    char *p = malloc(total);
 
     if (!p)
         return NULL;
-    for (int i = 0; i < n * size; i++)
-        p[i] = 0;
+
+    /* TODO: Replace the byte buffer clearing algorithm with memset once
+     * implemented.
+     */
+
+    /* Currently malloc uses mmap(2) to request allocation, which guarantees
+     * memory to be page-aligned
+     */
+    int *pi = p, num_words = total >> 2, offset = num_words << 2;
+
+    for (int i = 0; i < num_words; i++)
+        pi[i] = 0;
+
+    while (offset < total)
+        p[offset++] = 0;
+
     return p;
 }
 

src/arm-codegen.c

@@ -156,8 +156,7 @@ void cfg_flatten()
 
             for (ph2_ir_t *insn = bb->ph2_ir_list.head; insn;
                  insn = insn->next) {
-                flatten_ir = add_ph2_ir(OP_generic);
-                memcpy(flatten_ir, insn, sizeof(ph2_ir_t));
+                flatten_ir = add_existed_ph2_ir(insn);
 
                 if (insn->op == OP_return) {
                     /* restore sp */
@@ -470,7 +469,7 @@ void code_generate()
     emit(__b(__AL, MAIN_BB->elf_offset - elf_code_idx));
 
     for (int i = 0; i < ph2_ir_idx; i++) {
-        ph2_ir = &PH2_IR[i];
+        ph2_ir = PH2_IR_FLATTEN[i];
         emit_ph2_ir(ph2_ir);
     }
 }

src/defs.h

@@ -41,6 +41,10 @@
 #define MAX_OPERAND_STACK_SIZE 32
 #define MAX_ANALYSIS_STACK_SIZE 750
 
+/* Default capacities for common data structures */
+/* Default arena size is initialized with 256 KiB */
+#define DEFAULT_ARENA_SIZE 262144
+
 #define ELF_START 0x10000
 #define PTR_SIZE 4
 
@@ -62,6 +66,18 @@
 #define HOST_PTR_SIZE __SIZEOF_POINTER__
 #endif
 
+/* Common data structures */
+typedef struct arena_block {
+    char *memory;
+    int capacity;
+    int offset;
+    struct arena_block *next;
+} arena_block_t;
+
+typedef struct {
+    arena_block_t *head;
+} arena_t;
+
 /* builtin types */
 typedef enum {
     TYPE_void = 0,

src/globals.c

@@ -32,7 +32,12 @@ int global_ir_idx = 0;
 ph1_ir_t *PH1_IR;
 int ph1_ir_idx = 0;
 
-ph2_ir_t *PH2_IR;
+arena_t *INSN_ARENA;
+
+/* BB_ARENA is responsible for basic_block_t / ph2_ir_t allocation */
+arena_t *BB_ARENA;
+
+ph2_ir_t **PH2_IR_FLATTEN;
 int ph2_ir_idx = 0;
 
 label_lut_t *LABEL_LUT;
@@ -69,6 +74,121 @@ char *elf_symtab;
 char *elf_strtab;
 char *elf_section;
 
+/**
+ * arena_block_create() - creates a new arena block with given capacity.
+ * The created arena block is guaranteed to be zero-initialized.
+ * @capacity: The capacity of the arena block. Must be positive.
+ *
+ * Return: The pointer of created arena block. NULL if failed to allocate.
+ */
+arena_block_t *arena_block_create(int capacity)
+{
+    arena_block_t *block = malloc(sizeof(arena_block_t));
+
+    if (!block) {
+        printf("Failed to allocate memory for arena block\n");
+        exit(1);
+    }
+
+    block->memory = calloc(capacity, sizeof(char));
+
+    if (!block->memory) {
+        printf("Failed to allocate memory for arena block\n");
+        free(block);
+        exit(1);
+    }
+
+    block->capacity = capacity;
+    block->offset = 0;
+    block->next = NULL;
+    return block;
+}
+
+/**
+ * arena_init() - initializes the given arena with initial capacity.
+ * @initial_capacity: The initial capacity of the arena. Must be positive.
+ *
+ * Return: The pointer of initialized arena.
+ */
+arena_t *arena_init(int initial_capacity)
+{
+    arena_t *arena = malloc(sizeof(arena_t));
+    arena->head = arena_block_create(initial_capacity);
+    return arena;
+}
+
+/**
+ * arena_alloc() - allocates memory from the given arena with given size.
+ * The arena may create a new arena block if no space is available.
+ * @arena: The arena to allocate memory from. Must not be NULL.
+ * @size: The size of memory to allocate. Must be positive.
+ *
+ * Return: The pointer of allocated memory. NULL if new arena block is failed to
+ * allocate.
+ */
+void *arena_alloc(arena_t *arena, int size)
+{
+    char *ptr;
+    arena_block_t *block = arena->head;
+
+    while (block) {
+        if (block->offset + size <= block->capacity) {
+            ptr = block->memory + block->offset;
+            block->offset += size;
+            return ptr;
+        }
+        if (!block->next)
+            break;
+        block = block->next;
+    }
+
+    /* If no space is available, create a new block
+     * Allocate at least 256 KiB or the requested size
+     */
+    int new_capacity = size > DEFAULT_ARENA_SIZE ? size : DEFAULT_ARENA_SIZE;
+    arena_block_t *new_block = arena_block_create(new_capacity);
+
+    if (!new_block)
+        return NULL;
+
+    block->next = new_block;
+    ptr = new_block->memory + new_block->offset;
+    new_block->offset += size;
+    return ptr;
+}
+
+/**
+ * arena_reset() - resets the given arena by resetting all blocks' offset to 0.
+ * @arena: The arena to reset. Must not be NULL.
+ */
+void arena_reset(arena_t *arena)
+{
+    arena_block_t *block = arena->head;
+
+    while (block) {
+        block->offset = 0;
+        block = block->next;
+    }
+}
+
+/**
+ * arena_free() - frees the given arena and all its blocks.
+ * @arena: The arena to free. Must not be NULL.
+ */
+void arena_free(arena_t *arena)
+{
+    arena_block_t *block = arena->head, *next;
+
+    while (block) {
+        next = block->next;
+        free(block->memory);
+        free(block);
+        block = next;
+    }
+
+    free(arena);
+}
+
 /**
  * hashmap_hash_index() - hashses a string with FNV-1a hash function
  * and converts into usable hashmap index. The range of returned
@@ -312,11 +432,17 @@ ph1_ir_t *add_ph1_ir(opcode_t op)
     return ph1_ir;
 }
 
+ph2_ir_t *add_existed_ph2_ir(ph2_ir_t *ph2_ir)
+{
+    PH2_IR_FLATTEN[ph2_ir_idx++] = ph2_ir;
+    return ph2_ir;
+}
+
 ph2_ir_t *add_ph2_ir(opcode_t op)
 {
-    ph2_ir_t *ph2_ir = &PH2_IR[ph2_ir_idx++];
+    ph2_ir_t *ph2_ir = arena_alloc(BB_ARENA, sizeof(ph2_ir_t));
     ph2_ir->op = op;
-    return ph2_ir;
+    return add_existed_ph2_ir(ph2_ir);
 }
 
 void set_var_liveout(var_t *var, int end)
@@ -579,7 +705,7 @@ fn_t *add_fn()
 /* Create a basic block and set the scope of variables to 'parent' block */
 basic_block_t *bb_create(block_t *parent)
 {
-    basic_block_t *bb = calloc(1, sizeof(basic_block_t));
+    basic_block_t *bb = arena_alloc(BB_ARENA, sizeof(basic_block_t));
 
     for (int i = 0; i < MAX_BB_PRED; i++) {
         bb->prev[i].bb = NULL;
@@ -691,7 +817,7 @@ void add_insn(block_t *block,
 
     bb->scope = block;
 
-    insn_t *n = calloc(1, sizeof(insn_t));
+    insn_t *n = arena_alloc(INSN_ARENA, sizeof(insn_t));
     n->opcode = op;
     n->rd = rd;
     n->rs1 = rs1;
@@ -725,7 +851,9 @@ void global_init()
     TYPES = malloc(MAX_TYPES * sizeof(type_t));
     GLOBAL_IR = malloc(MAX_GLOBAL_IR * sizeof(ph1_ir_t));
     PH1_IR = malloc(MAX_IR_INSTR * sizeof(ph1_ir_t));
-    PH2_IR = malloc(MAX_IR_INSTR * sizeof(ph2_ir_t));
+    INSN_ARENA = arena_init(DEFAULT_ARENA_SIZE);
+    BB_ARENA = arena_init(DEFAULT_ARENA_SIZE);
+    PH2_IR_FLATTEN = malloc(MAX_IR_INSTR * sizeof(ph2_ir_t *));
     LABEL_LUT = malloc(MAX_LABEL * sizeof(label_lut_t));
     SOURCE = malloc(MAX_SOURCE);
     ALIASES = malloc(MAX_ALIASES * sizeof(alias_t));
@@ -755,7 +883,9 @@ void global_release()
     free(TYPES);
     free(GLOBAL_IR);
     free(PH1_IR);
-    free(PH2_IR);
+    arena_free(INSN_ARENA);
+    arena_free(BB_ARENA);
+    free(PH2_IR_FLATTEN);
     free(LABEL_LUT);
     free(SOURCE);
     free(ALIASES);

src/main.c

@@ -115,7 +115,6 @@ int main(int argc, char *argv[])
     elf_generate(out);
 
     /* release allocated objects */
-    ssa_release();
     global_release();
 
     exit(0);

src/reg-alloc.c

@@ -49,7 +49,7 @@ void refresh(basic_block_t *bb, insn_t *insn)
 
 ph2_ir_t *bb_add_ph2_ir(basic_block_t *bb, opcode_t op)
 {
-    ph2_ir_t *n = calloc(1, sizeof(ph2_ir_t));
+    ph2_ir_t *n = arena_alloc(BB_ARENA, sizeof(ph2_ir_t));
     n->op = op;
 
     if (!bb->ph2_ir_list.head)
@@ -640,7 +640,7 @@ void reg_alloc()
 void dump_ph2_ir()
 {
     for (int i = 0; i < ph2_ir_idx; i++) {
-        ph2_ir_t *ph2_ir = &PH2_IR[i];
+        ph2_ir_t *ph2_ir = PH2_IR_FLATTEN[i];
 
         int rd = ph2_ir->dest + 48;
         int rs1 = ph2_ir->src0 + 48;

src/riscv-codegen.c

@@ -128,8 +128,7 @@ void cfg_flatten()
 
             for (ph2_ir_t *insn = bb->ph2_ir_list.head; insn;
                  insn = insn->next) {
-                flatten_ir = add_ph2_ir(OP_generic);
-                memcpy(flatten_ir, insn, sizeof(ph2_ir_t));
+                flatten_ir = add_existed_ph2_ir(insn);
 
                 if (insn->op == OP_return) {
                     /* restore sp */
@@ -446,7 +445,7 @@ void code_generate()
     emit(__jal(__zero, MAIN_BB->elf_offset - elf_code_idx));
 
     for (int i = 0; i < ph2_ir_idx; i++) {
-        ph2_ir = &PH2_IR[i];
+        ph2_ir = PH2_IR_FLATTEN[i];
         emit_ph2_ir(ph2_ir);
     }
 }

src/ssa.c

@@ -588,7 +588,7 @@ bool insert_phi_insn(basic_block_t *bb, var_t *var)
         return false;
 
     insn_t *head = bb->insn_list.head;
-    insn_t *n = calloc(1, sizeof(insn_t));
+    insn_t *n = arena_alloc(INSN_ARENA, sizeof(insn_t));
     n->opcode = OP_phi;
     n->rd = var;
     n->rs1 = var;
@@ -810,7 +810,7 @@ void solve_phi_params()
 
 void append_unwound_phi_insn(basic_block_t *bb, var_t *dest, var_t *rs)
 {
-    insn_t *n = calloc(1, sizeof(insn_t));
+    insn_t *n = arena_alloc(INSN_ARENA, sizeof(insn_t));
     n->opcode = OP_unwound_phi;
     n->rd = dest;
     n->rs1 = rs;
@@ -1770,52 +1770,3 @@ void liveness_analysis()
         } while (changed);
     }
 }
-
-void bb_release(fn_t *fn, basic_block_t *bb)
-{
-    UNUSED(fn);
-
-    insn_t *insn = bb->insn_list.head;
-    insn_t *next_insn;
-    while (insn) {
-        next_insn = insn->next;
-        free(insn);
-        insn = next_insn;
-    }
-
-    /* disconnect all predecessors */
-    for (int i = 0; i < MAX_BB_PRED; i++) {
-        if (!bb->prev[i].bb)
-            continue;
-        switch (bb->prev[i].type) {
-        case NEXT:
-            bb->prev[i].bb->next = NULL;
-            break;
-        case THEN:
-            bb->prev[i].bb->then_ = NULL;
-            break;
-        case ELSE:
-            bb->prev[i].bb->else_ = NULL;
-            break;
-        default:
-            abort();
-        }
-
-        bb->prev[i].bb = NULL;
-    }
-    free(bb);
-}
-
-void ssa_release()
-{
-    bb_traversal_args_t *args = calloc(1, sizeof(bb_traversal_args_t));
-    for (fn_t *fn = FUNC_LIST.head; fn; fn = fn->next) {
-        args->fn = fn;
-        args->bb = fn->bbs;
-
-        fn->visited++;
-        args->postorder_cb = bb_release;
-        bb_forward_traversal(args);
-    }
-    free(args);
-}