shitalloc.c
1
Name:
Anonymous
2009-02-02 2:34
I was bored, so I wrote an extremely shitty "memory allocator", if you could call it that.
#include <stdbool.h>
#include <stdlib.h>
typedef struct Node {
bool in_use; // whether the node is in use.
size_t size; // the size of the node
struct Node *next; // the next node in the list.
} Node;
static Node *heap = NULL;
void shitalloc_init(size_t size)
{
if((heap = malloc(size))) {
heap->in_use = false;
heap->size = size - sizeof(Node);
heap->next = NULL;
}
}
void shitalloc_cleanup()
{
free(heap);
}
void *shitalloc(size_t size)
{
Node *n = heap;
void *ptr = NULL;
// Look for a node that's not in use and that's big enough.
while(n && (n->in_use || n->size < size))
n = n->next;
// If we've found a node that's too big, split it up.
if(n && n->size > size) {
Node *n2 = (void*)n + sizeof(Node) + size;
n2->in_use = false;
n2->size = n->size - size - sizeof(Node);
n2->next = n->next;
n->next = n2;
n->size = size;
}
// If we've found a node, mark it as in-use and get the pointer.
if(n) {
n->in_use = true;
ptr = (void*)n + sizeof(Node);
}
return ptr;
}
void shitfree(void *ptr)
{
Node *n;
if(ptr) {
n = ptr - sizeof(Node);
n->in_use = false;
}
}
size_t shitused()
{
Node *n;
size_t size = 0;
for(n = heap; n; n = n->next)
size += sizeof(Node) + (n->in_use ? n->size : 0);
return size;
}
2
Name:
Anonymous
2009-02-02 2:57
I was bored, so I wrote an extremely shitty "sorting algorithm", if you could call it that.
void shitsort(int* a, int n)
{
while (1) {
int i, r, tmp;
for (i = 0; i < (n-1); i++) {
if (a[i] > a[i+1])
break;
}
if (i == (n-1))
return;
r = rand() % n;
tmp = a[0];
a[0] = a[r];
a[r] = tmp;
}
}
3
Name:
Anonymous
2009-02-02 3:13
OP, in case you didn't know, malloc is usually implemented in a similar(but more complex) way, with the exception of not using malloc inside of it of course, but some OS API for allocating memory pages directly.
4
Name:
Anonymous
2009-02-02 3:26
>>3
Obviously the OP knew that. What, did you think he was being innovative and original for figuring that out on his own? Haha, good one.
5
Name:
Anonymous
2009-02-02 4:47
>>3
Really? Huh, I just came up with that on my own. It kind of made sense, but I didn't think it would really be useful. I guess that a real malloc() would have a better way to find available space than just walking down a list of nodes.
>>4
Yes, I really did come up with
>>1 on my own.
6
Name:
Anonymous
2009-02-02 6:46
OP is a moran, GO USA! you can't just write a bunch of functions that use malloc and call is a memory allocation implementaion, it's nothing but a wrapper for malloc
7
Name:
Anonymous
2009-02-02 8:35
mcurrent: dq START_OF_MEMORY
malloc:
mov rax, [mcurrent]
add [mcurrent], rdi
ret
The one my kernel currently uses. I have another one that looks like OP's (except that it uses bit 63 for the bool, and next and length is the same thing), but it's currently horribly broken.
8
Name:
=+=F=R=N==V=D=+=!FrOzEn2BUo
2009-02-02 9:13
>>7
Funny thing is, that's pretty much how malloc looks like in managed environments like CLR/JVM. Obviously there is a bit more cudd allocating memory from OS or triggering GC if needed, but mostly that's all.
That's why C/C++ sucks hard at performance unless you are an embedded or a game programmer and use known at compile time amounts of memory for everything, thus not needing malloc at all, except for fast fixed-size allocs from various arenas.
9
Name:
Anonymous
2009-02-02 10:23
>>6
If the algorithm is tuned to the task at hand it is likely to give better results than using the system malloc. Fragmentation is a real problem for big applications that are made of shit (real men use the stack or statically allocated areas for everything).
10
Name:
Anonymous
2009-02-02 12:31
OP here, here's basically the same thing as
>>1 but changed to be an actual allocator using sbrk().
myalloc.c
#include "myalloc.h"
#include <stdbool.h>
#include <unistd.h>
struct Node {
bool in_use; // flag whether this block is in use.
size_t size; // the size of this block in bytes.
};
typedef struct Node Node;
static Node *heap = NULL;
void *myalloc(size_t size)
{
Node *n;
void *pbrk = NULL;
void *ptr = NULL;
// No heap? Then make one!
if(!heap) {
// The heap will start at the end of the program break.
heap = sbrk(0);
// Allocate enough for two requests of this size.
sbrk(2 * (size + sizeof(Node)));
// Structure the heap correctly.
heap->in_use = false;
heap->size = (pbrk = sbrk(0)) - (void*)heap - sizeof(Node);
}
// If we don't know where the program break is, find it.
if(!pbrk)
pbrk = sbrk(0);
// Try to find a node within the heap that's free and has enough space.
for(n = heap;
(void*)n < pbrk && (n->in_use || size > n->size);
n = (void*)n + n->size + sizeof(Node));
// If the node isn't within the heap, then we gotta expand the heap.
if(n == pbrk) {
// Allocate enough for this request and another same-sized request.
sbrk(2 * (size + sizeof(Node)));
pbrk = sbrk(0);
// Structure the heap correctly.
n->in_use = false;
n->size = pbrk - (void*)n - sizeof(Node);
}
// If the node is too big for this request, split it up.
if(n->size > size) {
Node *n2 = (void*)n + size + sizeof(Node);
n2->in_use = false;
n2->size = n->size - size - sizeof(Node);
n->size = size;
}
// If we really have a node, get the pointer.
if(n) {
n->in_use = true;
ptr = (void*)n + sizeof(Node);
}
return ptr;
}
void myfree(void *ptr)
{
Node *n = ptr - sizeof(Node);
void *pbrk = sbrk(0);
bool in_use;
// Deallocate the node!
n->in_use = in_use = false;
// See if everything from here until the break is not in use.
for(; !in_use && (void*)n < pbrk; n = (void*)n + n->size + sizeof(Node))
in_use = in_use || n->in_use;
// If nothing is in use, shrink the heap.
if(!in_use)
sbrk(-(pbrk - ptr) - sizeof(Node));
}
size_t myheapsize()
{
return sbrk(0) - (void*)heap;
}
myalloc.h
#ifndef MYALLOC_H
#define MYALLOC_H
#include <stddef.h>
void *myalloc(size_t size);
void myfree(void *ptr);
size_t myheapsize();
#endif
test.c
#include "myalloc.h"
#include <stdio.h>
struct Foo
{
int foo;
char bar;
double baz;
};
int main()
{
void *p = myalloc(1024);
printf("p: %p\n", p);
printf("heap size: %zu\n", myheapsize());
struct Foo *f = myalloc(sizeof(struct Foo));
f->foo = 123;
f->bar = '!';
f->baz = 3.14;
printf("f: %p\n", f);
printf("heap size: %zu\n", myheapsize());
void *q = myalloc(1024);
printf("q: %p\n", q);
printf("heap size: %zu\n", myheapsize());
myfree(q);
printf("Freed q\n");
printf("heap size: %zu\n", myheapsize());
q = myalloc(1024);
printf("q: %p\n", q);
printf("heap size: %zu\n", myheapsize());
myfree(q);
myfree(f);
myfree(p);
printf("heap size: %zu\n", myheapsize());
f = myalloc(sizeof(struct Foo));
printf("heap size: %zu\n", myheapsize());
myfree(f);
printf("heap size: %zu\n", myheapsize());
return 0;
}
11
Name:
Anonymous
2009-02-02 16:16
>>10
Is it Enterprise-ready? I know I wouldn't want to release my Enterprise product without at least one custom memory allocator.
12
Name:
Anonymous
2009-02-02 16:24
>>5
Lol at you playing "oh, look how surprised I am"
You may fool these people, but you do not fool me.
13
Name:
Anonymous
2009-02-02 16:26
>>12
OP here, okay so I lied. I read about malloc in my OS class. But that's neither here nor there.
14
Name:
Anonymous
2009-02-02 17:04
Now write shitgc
15
Name:
Anonymous
2009-02-02 17:06
One day I created a very fast version of malloc.
16
Name:
Anonymous
2009-02-02 17:30
>>13
This is why I should use tripcodes.
Anyways, here's a new-and-improved version of
>>10 . This one handles sbrk() errors and fixes a bug when splitting a node. It also groups unused nodes into larger nodes when freeing.
hajj-malloc.tar.bz2.b64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17
Name:
Anonymous
2009-02-02 17:30
could someone provide a haskell version. need this before tomorrow or my boss will be pissed. kthx
18
Name:
Anonymous
2009-02-02 17:31
19
Name:
Anonymous
2009-02-02 18:08
I'M HERE TO sbrk YOUR FUCKING SPINE
20
Name:
Anonymous
2009-02-02 18:22
how do i do this in php??
thanks
21
Name:
Anonymous
2009-02-02 18:25
free YOUR MIND
22
Name:
Anonymous
2009-02-03 2:13
Another update. I've renamed the functions so that this can work as a library with LD_PRELOAD. Most programs crash, but some survive. newlisp 9.4.0 seems to work perfectly.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23
Name:
Anonymous
2009-02-03 13:35
could someone provide a fjölnir version. need this before tomorrow or my boss will be pissed. kthx
24
Name:
Anonymous
2009-02-03 18:14
>>23
if u payme enough ;)
25
Name:
Anonymous
2009-02-03 18:18
>>24
please be posting a price quote good sir
thank you
26
Name:
Anonymous
2009-02-03 22:23
PAYME ENOUGH ;)
27
Name:
Anonymous
2009-02-03 22:24
PAYME ENOUGH ;)
28
Name:
Anonymous
2009-02-03 22:25
PAYME ENOUGH ;)
30
Name:
Anonymous
2009-02-04 1:04
>>25
How much is your job worth?
In this economy, I'm guessing at least 6-12 months pay.
31
Name:
kinghajj
!kiNgHAJjDw
2009-02-04 1:32
Another update. I fixed a bug with realloc(), so now many more programs work with LD_PRELOAD. Try it with ruby; if you thought it was SLOW AS FUCK before, just wait 'til you try this memory allocator ;)
hajj-malloc-200902032230.tar.bz2.b64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33
Name:
Anonymous
2010-12-17 1:40
This post brought to you by the Gay Nigger Association of America
34
Name:
Anonymous
2011-02-03 5:23