Make malloc chunk head a separate structure
diff --git a/preload.c b/preload.c
index 0e0c253..45d4a37 100644
--- a/preload.c
+++ b/preload.c
@@ -28,29 +28,30 @@
/* segment size. Matches hugepage size */
#define SEG_SIZE 2*1024*1024
-#define CHUNK_SIZE (2 * sizeof(size_t))
-#define CHUNK_ALIGNMENT 0xf
-
static int debug = 0;
#define DEBUG(...) do { if (debug) printf(__VA_ARGS__); } while(0)
-static size_t pad_request(size_t s)
-{
- return (s + CHUNK_SIZE + CHUNK_ALIGNMENT) & ~CHUNK_ALIGNMENT;
-}
#define PINUSE_BIT 0x01
#define CINUSE_BIT 0x02
#define FLAG_BITS (CINUSE_BIT | PINUSE_BIT)
-struct malloc_chunk {
- size_t prev_foot; /* Size of previous chunk (if free). */
- size_t head; /* Size and inuse bits. */
- struct malloc_chunk* fd; /* double links -- used only if free. */
- struct malloc_chunk* bk;
+struct malloc_chunk_head {
+ int prev_foot; /* size of previous if free */
+ int head; /* entire size of this chunk */
};
+struct malloc_chunk {
+ struct malloc_chunk_head h;
+ struct malloc_chunk *fd;
+ struct malloc_chunk *bk;
+};
+
+#define CHUNK_SIZE (sizeof(struct malloc_chunk_head))
+#define MIN_CHUNK 0x10
+#define CHUNK_ALIGNMENT (MIN_CHUNK - 1)
+
struct segptr {
char *base;
/* no size because they're always SEG_SIZE */
@@ -64,14 +65,19 @@
static struct malloc_state m;
+static size_t pad_request(size_t s)
+{
+ return (s + CHUNK_SIZE + CHUNK_ALIGNMENT) & ~CHUNK_ALIGNMENT;
+}
+
static int in_use(struct malloc_chunk *c)
{
- return c->head & CINUSE_BIT ? 1 : 0;
+ return c->h.head & CINUSE_BIT ? 1 : 0;
}
static int prev_in_use(struct malloc_chunk *c)
{
- return c->head & PINUSE_BIT ? 1 : 0;
+ return c->h.head & PINUSE_BIT ? 1 : 0;
}
static void check(int cond, const char *str)
@@ -105,7 +111,7 @@
static size_t chunk_size(struct malloc_chunk *c)
{
- return c->head & ~FLAG_BITS;
+ return c->h.head & ~FLAG_BITS;
}
static struct malloc_chunk *next_chunk(struct malloc_chunk *c)
@@ -127,7 +133,7 @@
static struct malloc_chunk *prev_chunk(struct malloc_chunk *c)
{
- return (struct malloc_chunk *)((char*)c - c->prev_foot);
+ return (struct malloc_chunk *)((char*)c - c->h.prev_foot);
}
static void link_free_chunk(struct malloc_chunk *c)
@@ -164,7 +170,7 @@
printf("SHOW SEGMENT %i\n", i);
for (c = (struct malloc_chunk *)seg->base; c != NULL; c = next_chunk(c)) {
printf("%p:%d:%d:%04x:%04x", c, in_use(c), prev_in_use(c),
- c->prev_foot, chunk_size(c));
+ c->h.prev_foot, chunk_size(c));
if (!in_use(c))
printf(":%p:%p", c->fd, c->bk);
printf("\n");
@@ -207,8 +213,8 @@
seg = chunk2mem(c);
memset(seg, 0, sizeof(*seg));
seg->base = p;
- c->head = ssize | CINUSE_BIT | PINUSE_BIT;
- c->prev_foot = 0;
+ c->h.head = ssize | CINUSE_BIT | PINUSE_BIT;
+ c->h.prev_foot = 0;
if (m.seg == NULL) {
m.seg = seg;
@@ -218,9 +224,9 @@
sp->next = seg;
}
c = next_chunk(c);
- c->head = (size_t)(((char *)p + SEG_SIZE) - (char *)c) | PINUSE_BIT;
- c->prev_foot = ssize;
- DEBUG("next chunk at 0x%p, head=%x, prev=%x\n", c, chunk_size(c), c->prev_foot);
+ c->h.head = (size_t)(((char *)p + SEG_SIZE) - (char *)c) | PINUSE_BIT;
+ c->h.prev_foot = ssize;
+ DEBUG("next chunk at 0x%p, head=%x, prev=%x\n", c, chunk_size(c), c->h.prev_foot);
link_free_chunk(c);
}
@@ -260,23 +266,23 @@
if (csize - size < pad_request(1)) {
/* nothing to split, just give everything up */
unlink_free_chunk(c);
- c->head |= CINUSE_BIT;
+ c->h.head |= CINUSE_BIT;
new_c = next_chunk(c);
if (new_c) {
ASSERT(!prev_in_use(new_c));
- ASSERT(new_c->prev_foot == chunk_size(c));
+ ASSERT(new_c->h.prev_foot == chunk_size(c));
- new_c->head |= PINUSE_BIT;
+ new_c->h.head |= PINUSE_BIT;
}
return;
}
/* set the old chunk to the size */
- c->head = size | CINUSE_BIT | PINUSE_BIT;
+ c->h.head = size | CINUSE_BIT | PINUSE_BIT;
/* get the new part of the split */
new_c = next_chunk(c);
- new_c->head = (csize - size) | PINUSE_BIT;
- new_c->prev_foot = size;
+ new_c->h.head = (csize - size) | PINUSE_BIT;
+ new_c->h.prev_foot = size;
/* now replace the new chunk with the old chunk */
new_c->fd = c->fd;
new_c->bk = c->bk;
@@ -286,8 +292,8 @@
n = next_chunk(new_c);
if (n) {
ASSERT(!prev_in_use(n));
- ASSERT(n->prev_foot == csize);
- n->prev_foot = chunk_size(new_c);
+ ASSERT(n->h.prev_foot == csize);
+ n->h.prev_foot = chunk_size(new_c);
}
}
@@ -339,9 +345,9 @@
if (!prev_in_use(c)) {
struct malloc_chunk *p = prev_chunk(c);
- p->head += chunk_size(c);
+ p->h.head += chunk_size(c);
if (n)
- n->prev_foot = chunk_size(p);
+ n->h.prev_foot = chunk_size(p);
/* the new consolidated chunk becomes our current
* chunk for the next free check below. The previous
@@ -355,14 +361,14 @@
/* and finally consolidation with next */
if (n && !in_use(n)) {
unlink_free_chunk(n);
- c->head += chunk_size(n);
+ c->h.head += chunk_size(n);
n = next_chunk(c);
if (n)
- n->prev_foot = chunk_size(c);
+ n->h.prev_foot = chunk_size(c);
} else if (n) {
ASSERT(prev_in_use(n));
- n->head &= ~PINUSE_BIT;
+ n->h.head &= ~PINUSE_BIT;
}
- c->head &= ~CINUSE_BIT;
+ c->h.head &= ~CINUSE_BIT;
show_segment();
}
