initial commit

Author: portasynthinca3

.gitignore

@@ -0,0 +1 @@
+main

LICENSE.txt

@@ -0,0 +1,13 @@
+            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+                    Version 2, December 2004
+
+ Copyright (C) 2004 Sam Hocevar <[email protected]>
+
+ Everyone is permitted to copy and distribute verbatim or modified
+ copies of this license document, and changing it is allowed as long
+ as the name is changed.
+
+            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. You just DO WHAT THE FUCK YOU WANT TO.

README.md

@@ -0,0 +1,52 @@
+# randalloc
+randalloc is a 🚀 **BLAZING FAST**, 🚀 **MEMORY SAFE** and 🚀 **THREAD SAFE**
+memory allocator. It works like this:
+```c
+void* malloc(size_t s) { return (void*)rand(); }
+```
+
+Actually, _a bit more_ is required to actually make `rand` work like that. Go
+read [`randalloc.c`](https://github.com/portasynthinca3/randalloc/blob/master/randalloc.c),
+it's just 36 lines long.
+
+## Run it!
+```
+git clone https://github.com/portasynthinca3/randalloc.git
+cd randalloc
+cat main.c # just kinda look at what the code does
+sh randalloc.sh
+```
+
+## Use it!
+  - Yank [`randalloc.c`](https://github.com/portasynthinca3/randalloc/blob/master/randalloc.c)
+    from this repo and paste it into your project.
+  - Call `_init_alloc` as close to entry as possible.
+  - Compile your project with `-Wl,--wrap=malloc -Wl,--wrap=free -Wl,--wrap=realloc`.
+  - Enjoy  🚀 **BLAZING FASTNESS**, 🚀 **MEMORY SAFETY** and 🚀 **THREAD
+    SAFETY** in your very own project that you chose to write in a legacy
+    language!
+
+## Performance
+The allocator runs in O(1) time. And that constant is quite small, not gonna lie.
+
+Have I measured it? No. But it's fast; like look at it!
+
+## Memory safety
+Assuming you are fortunate enough that your allocations don't overlap, your code
+will be memory safe!
+
+## Thread safety
+This allocator does not need to take any extra precautions to ensure thread
+safety. That not only means it's 🚀 **BLAZING SAFE**, it's also 🚀 **THREAD
+FAST**!
+
+Wait, no, I think I might have mixed up something.
+
+## Why?
+  - I just discovered the `--wrap` linker flag and my mind was absolutely
+    **blown**.
+  - I saw the original implementation in someone's Discord status.
+  - Yes, I am a little child.
+
+## Licensing
+This project is hereby licensed under the [WTFPL](http://www.wtfpl.net/txt/copying/).

main.c

@@ -0,0 +1,14 @@
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+
+void _init_alloc(void);
+
+int main(int argc, const char** argv) {
+    _init_alloc();
+
+    const char* static_str = "Hello, World!";
+    char* dynamic = malloc(strlen(static_str) + 1);
+    strcpy(dynamic, static_str);
+    printf("%p: %s", dynamic, dynamic);
+}

randalloc.c

@@ -0,0 +1,36 @@
+#include <stdint.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <time.h>
+#include <string.h>
+
+#define RANDALLOC_SIZE (1*1024*1024)
+_Static_assert(RANDALLOC_SIZE < RAND_MAX);
+
+static void* rand_start;
+
+void _init_alloc(void) {
+    srand(time(NULL));
+    rand_start = sbrk(0);
+    sbrk(RANDALLOC_SIZE);
+}
+
+void* __wrap_malloc(size_t size) {
+    int offset = rand() % RANDALLOC_SIZE;
+    return (uint8_t*)rand_start + offset;
+}
+
+void __wrap_free(void* ptr) {
+    // BLAZING FAST
+}
+
+void* __wrap_calloc(size_t nmemb, size_t size) {
+    return malloc(nmemb * size);
+}
+
+void* __wrap_realloc(void* ptr, size_t size) {
+    void* new = malloc(size);
+    memcpy(new, ptr, size);
+    free(ptr);
+    return new;
+}

randalloc.sh

@@ -0,0 +1,3 @@
+#!/usr/bin/env sh
+gcc -O0 -g -Wl,--wrap=malloc -Wl,--wrap=free -Wl,--wrap=realloc main.c randalloc.c -o main
+./main

regular.c

@@ -0,0 +1 @@
+void _init_alloc(void) { /* stub */ }

regular.sh

@@ -0,0 +1,3 @@
+#!/usr/bin/env sh
+gcc -O0 -g main.c regular.c -o main
+./main