walloc 0.0.2

Author: pepsipu

benchmark.py

@@ -0,0 +1,20 @@
+import subprocess
+import statistics
+import matplotlib.pyplot as plt
+
+runs = 25
+runs_array = [num + 1 for num in range(runs)]
+malloc = []
+walloc = []
+for x in range(runs):
+    malloc.append(int(subprocess.check_output(['./build/malloc_benchmark']).decode()))
+    walloc.append(int(subprocess.check_output(['./build/walloc_benchmark']).decode()))
+
+plt.plot(runs_array, malloc, label="ptalloc benchmark")
+plt.plot(runs_array, walloc, label="warpalloc benchmark")
+plt.legend()
+plt.title("ptalloc vs warpalloc time to run the same benchmark")
+plt.xlabel("Trials")
+plt.ylabel("Time")
+plt.xticks(runs_array)
+plt.show()

build/prealloctaing_x86 build/malloc_benchmark

@@ -0,0 +1,65 @@
+#include <time.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include "../walloc.h"
+
+int main() {
+    int startTime = clock();
+    char *myMemory = malloc(20); // takes significantly less time since memory does not need to be requested from the OS.
+    free(myMemory); // frees the memory, and saves it for later allocations
+    char *myMemory2 = malloc(10);
+    free(myMemory2);
+    char *myMemory3 = malloc(90); // takes significantly less time since memory does not need to be requested from the OS.
+    char *myMemory4 = malloc(70);
+    free(myMemory3);
+    char *myMemory5 = malloc(20);
+    free(myMemory4);
+    char *myMemory6 = malloc(40);
+    char *myMemory7 = malloc(20);
+    free(myMemory5);
+    free(myMemory7);
+    char *myMemory8 = malloc(40);
+    char *myMemory9 = malloc(20);
+    free(myMemory9);
+    free(myMemory8);
+    free(myMemory6);
+    char *myMemory10 = malloc(40);
+    char *myMemory11 = malloc(20);
+    free(myMemory10);
+    free(myMemory11);
+    char *myMemory12 = malloc(40);
+    char *myMemory13 = malloc(20);
+    free(myMemory13);
+    free(myMemory12);
+
+    char *myMemoryz = malloc(20); // takes significantly less time since memory does not need to be requested from the OS.
+    free(myMemoryz); // frees the memory, and saves it for later allocations
+    char *myMemoryz2 = malloc(10);
+    free(myMemoryz2);
+    char *myMemoryz3 = malloc(90); // takes significantly less time since memory does not need to be requested from the OS.
+    char *myMemoryz4 = malloc(70);
+    free(myMemoryz3);
+    char *myMemoryz5 = malloc(20);
+    free(myMemoryz4);
+    char *myMemoryz6 = malloc(40);
+    char *myMemoryz7 = malloc(20);
+    free(myMemoryz5);
+    free(myMemoryz7);
+    char *myMemoryz8 = malloc(40);
+    char *myMemoryz9 = malloc(20);
+    free(myMemoryz9);
+    free(myMemoryz8);
+    free(myMemoryz6);
+    char *myMemoryz10 = malloc(40);
+    char *myMemoryz11 = malloc(20);
+    free(myMemoryz10);
+    free(myMemoryz11);
+    char *myMemoryz12 = malloc(40);
+    char *myMemoryz13 = malloc(20);
+    free(myMemoryz13);
+    free(myMemoryz12);
+
+    int endTime = clock();
+
+    printf("%d", endTime - startTime);
+}

build/walloc.o

@@ -0,0 +1,66 @@
+#include <time.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include "../walloc.h"
+
+int main() {
+    prewalloc(800); // preallocate 255 bytes. will make subsequent allocations faster. Done at the start of the program.
+    int startTime = clock();
+
+    char *myMemory = walloc(20); // takes significantly less time since memory does not need to be requested from the OS.
+    wfree(myMemory); // frees the memory, and saves it for later allocations
+    char *myMemory2 = walloc(10);
+    wfree(myMemory2);
+    char *myMemory3 = walloc(90); // takes significantly less time since memory does not need to be requested from the OS.
+    char *myMemory4 = walloc(70);
+    wfree(myMemory3);
+    char *myMemory5 = walloc(20);
+    wfree(myMemory4);
+    char *myMemory6 = walloc(40);
+    char *myMemory7 = walloc(20);
+    wfree(myMemory5);
+    wfree(myMemory7);
+    char *myMemory8 = walloc(40);
+    char *myMemory9 = walloc(20);
+    wfree(myMemory9);
+    wfree(myMemory8);
+    wfree(myMemory6);
+    char *myMemory10 = walloc(40);
+    char *myMemory11 = walloc(20);
+    wfree(myMemory10);
+    wfree(myMemory11);
+    char *myMemory12 = walloc(40);
+    char *myMemory13 = walloc(20);
+    wfree(myMemory13);
+    wfree(myMemory12);
+
+    char *myMemoryz = walloc(20); // takes significantly less time since memory does not need to be requested from the OS.
+    wfree(myMemoryz); // frees the memory, and saves it for later allocations
+    char *myMemoryz2 = walloc(10);
+    wfree(myMemoryz2);
+    char *myMemoryz3 = walloc(90); // takes significantly less time since memory does not need to be requested from the OS.
+    char *myMemoryz4 = walloc(70);
+    wfree(myMemoryz3);
+    char *myMemoryz5 = walloc(20);
+    wfree(myMemoryz4);
+    char *myMemoryz6 = walloc(40);
+    char *myMemoryz7 = walloc(20);
+    wfree(myMemoryz5);
+    wfree(myMemoryz7);
+    char *myMemoryz8 = walloc(40);
+    char *myMemoryz9 = walloc(20);
+    wfree(myMemoryz9);
+    wfree(myMemoryz8);
+    wfree(myMemoryz6);
+    char *myMemoryz10 = walloc(40);
+    char *myMemoryz11 = walloc(20);
+    wfree(myMemoryz10);
+    wfree(myMemoryz11);
+    char *myMemoryz12 = walloc(40);
+    char *myMemoryz13 = walloc(20);
+    wfree(myMemoryz13);
+    wfree(myMemoryz12);
+
+    int endTime = clock();
+    printf("%d", endTime - startTime);
+}

build/walloc_benchmark

@@ -49,6 +49,7 @@ section .text
 
         ;--check_free_chunks--
         mov eax, [fbin]
+        mov ebx, fbin + 4
         .size_check_loop:
         test eax, eax
         je .check_wilderness ; if end of free chunks, then use space of wilderness