Lecture 4.

And adjust arena names.

Author: kohler

fundamentals3x/GNUmakefile

@@ -1,10 +1,10 @@
 PROGRAMS = $(patsubst mb-%.c,membench-%,$(wildcard mb-*.c))
-#ifeq ($(strip $(shell ld -jemalloc 2>&1 | grep -- -ljemalloc)),)
-#PROGRAMS += membench-jemalloc
-#endif
-#ifneq ($(wildcard /usr/lib/libtcmalloc.so.4),)
-#PROGRAMS += membench-tcmalloc
-#endif
+ifeq ($(strip $(shell ld -ljemalloc 2>&1 | grep -- -ljemalloc)),)
+PROGRAMS += membench-jemalloc
+endif
+ifneq ($(wildcard /usr/lib/libtcmalloc.so.4),)
+PROGRAMS += membench-tcmalloc
+endif
 all: $(PROGRAMS)
 
 DEFS += -pthread
@@ -23,7 +23,7 @@ membench-tcmalloc: membench.o mb-malloc.o
 	$(CC) $(CFLAGS) $(O) -o $@ $^ /usr/lib/libtcmalloc.so.4
 
 clean:
-	rm -f *.o $(PROGRAMS)
+	rm -f *.o $(PROGRAMS) membench-jemalloc membench-tcmalloc
 	rm -rf $(DEPSDIR) *.dSYM
 
 .PHONY: all clean

fundamentals3x/mb-arena.c

@@ -58,7 +58,7 @@ struct membench_arena {
 };
 
 
-membench_arena* membench_arena_new(void) {
+membench_arena* membench_arena_create(void) {
     // An arena initially contains a single chunk, which is free.
     // TODO: Change this!
     membench_arena* arena = (membench_arena*) malloc(sizeof(membench_arena));
@@ -77,6 +77,6 @@ void membench_free(membench_arena* arena, chunk* x) {
     arena->free = (free_chunk*) x; // OK because of the union
 }
 
-void membench_arena_free(membench_arena* arena) {
+void membench_arena_destroy(membench_arena* arena) {
     free(arena);
 }

fundamentals3x/mb-cheat.c

@@ -4,7 +4,7 @@
 
 static chunk the_only_chunk;
 
-membench_arena* membench_arena_new(void) {
+membench_arena* membench_arena_create(void) {
     return NULL;
 }
 
@@ -17,6 +17,6 @@ void membench_free(membench_arena* arena, chunk* x) {
     (void) arena, (void) x;
 }
 
-void membench_arena_free(membench_arena* arena) {
+void membench_arena_destroy(membench_arena* arena) {
     (void) arena;
 }

fundamentals3x/mb-malloc.c

@@ -1,30 +1,20 @@
 #include "membench.h"
 #include <stdlib.h>
 
-// membench_arena_new()
-//    Allocate and initialize a new arena, returning the arena.
-membench_arena* membench_arena_new(void) {
+membench_arena* membench_arena_create(void) {
     return NULL;
 }
 
-// membench_alloc(arena)
-//    Allocate and return a new chunk using the arena.
 chunk* membench_alloc(membench_arena* arena) {
     (void) arena;
     return (chunk*) malloc(sizeof(chunk));
 }
 
-// membench_free(arena)
-//    Free a chunk `x` that was previously allocated from this arena.
-//
-//    REQUIREMENT: `x` was previously returned by
-//    `membench_alloc(arena)` for this arena, and not previously
-//    freed, and `x != NULL`.
 void membench_free(membench_arena* arena, chunk* x) {
     (void) arena;
     free(x);
 }
 
-void membench_arena_free(membench_arena* arena) {
+void membench_arena_destroy(membench_arena* arena) {
     (void) arena;
 }

fundamentals3x/membench.c

@@ -12,7 +12,7 @@ void benchmark(void) {
     // Allocate a new memory arena for this thread.
     // An "arena" is an object that encapsulates a set of memory allocations.
     // Arenas can capture allocation statistics and improve speed.
-    membench_arena* arena = membench_arena_new();
+    membench_arena* arena = membench_arena_create();
 
     // Allocate `k` chunks.
     chunk** cs = (chunk**) malloc(sizeof(chunk*) * k);
@@ -33,7 +33,7 @@ void benchmark(void) {
     // Free the chunks and the arena.
     for (unsigned i = 0; i != k; ++i)
         membench_free(arena, cs[i]);
-    membench_arena_free(arena);
+    membench_arena_destroy(arena);
     free(cs);
 }
 

fundamentals3x/membench.h

@@ -10,9 +10,9 @@ typedef struct chunk {
 typedef struct membench_arena membench_arena;
 
 
-// membench_arena_new()
+// membench_arena_create()
 //    Allocate and initialize a new arena, returning the arena.
-membench_arena* membench_arena_new(void);
+membench_arena* membench_arena_create(void);
 
 
 // membench_alloc(arena)
@@ -29,12 +29,12 @@ chunk* membench_alloc(membench_arena* arena);
 void membench_free(membench_arena* arena, chunk* x);
 
 
-// membench_arena_free(arena)
+// membench_arena_destroy(arena)
 //    Clean up the arena and free its memory.
 //
-//    REQUIREMENT: Before `membench_arena_free(arena)` is called, all
+//    REQUIREMENT: Before `membench_arena_destroy(arena)` is called, all
 //    chunks previously returned by `membench_alloc(arena)` have been
 //    freed.
-void membench_arena_free(membench_arena* arena);
+void membench_arena_destroy(membench_arena* arena);
 
 #endif

fundamentals4/.gitignore

@@ -0,0 +1,6 @@
+add
+addu
+fib
+membench-malloc
+membench-arena
+membench-arena[0-9]

fundamentals4/GNUmakefile

@@ -0,0 +1,26 @@
+PROGRAMS = add addu fib membench-malloc membench-arena \
+	membench-arena1 membench-arena2 membench-arena3 \
+	membench-arena4
+
+all: $(PROGRAMS)
+
+DEFS += -pthread
+include ../common/rules.mk
+
+%.o: %.c $(BUILDSTAMP)
+	$(CC) $(CPPFLAGS) $(CFLAGS) $(DEPCFLAGS) $(O) -o $@ -c $<
+
+add: add.o
+	$(CC) $(CFLAGS) $(O) -o $@ $^
+
+addu: addu.o
+	$(CC) $(CFLAGS) $(O) -o $@ $^
+
+membench-%: membench.o mb-%.o
+	$(CC) $(CFLAGS) $(O) -o $@ $^
+
+clean:
+	rm -f $(PROGRAMS) *.o
+	rm -rf $(DEPSDIR) *.dSYM
+
+.PHONY: all clean

fundamentals4/add.c

@@ -0,0 +1,20 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <assert.h>
+
+int add(int a, int b) {
+    assert(a + 1 > a);
+    return a + b;
+}
+
+int main(int argc, char* argv[]) {
+    if (argc <= 2) {
+        fprintf(stderr, "Usage: add A B\n\
+    Prints A + B.\n");
+        exit(1);
+    }
+
+    int a = strtol(argv[1], 0, 0);
+    int b = strtol(argv[2], 0, 0);
+    printf("%d + %d = %d\n", a, b, add(a, b));
+}

fundamentals4/addu.c

@@ -0,0 +1,20 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <assert.h>
+
+unsigned add(unsigned a, unsigned b) {
+    assert(a + 1 > a);
+    return a + b;
+}
+
+int main(int argc, char* argv[]) {
+    if (argc <= 2) {
+        fprintf(stderr, "Usage: add A B\n\
+    Prints A + B.\n");
+        exit(1);
+    }
+
+    unsigned a = strtoul(argv[1], 0, 0);
+    unsigned b = strtoul(argv[2], 0, 0);
+    printf("%u + %u = %u\n", a, b, add(a, b));
+}

fundamentals4/fib.c

@@ -0,0 +1,17 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+int fib(int n) {
+    if (n < 2)
+        return n;
+    else
+        return fib(n - 1) + fib(n - 2);
+}
+
+int main(int argc, char* argv[]) {
+    int n = 6;
+    if (argc > 1)
+        n = strtol(argv[1], NULL, 0);
+
+    printf("%d\n", fib(n));
+}

fundamentals4/mb-arena.c

@@ -0,0 +1,63 @@
+#include "membench.h"
+#include <stdlib.h>
+#include <assert.h>
+#include <stdint.h>
+#include <stddef.h>
+
+/*
+
+Write an arena allocator for `chunk` objects. Your allocator should:
+
+* Allocate a chunk in O(1) time.
+* Free a chunk in O(1) time.
+* Use memory proportional to the peak number of actively allocated
+chunks (rather than, say, the total number of allocated chunks).
+* Run out of memory only if the system has no more memory available.
+
+More on arenas:
+https://en.wikipedia.org/wiki/Region-based_memory_management
+
+See "membench.h" for function semantics.
+
+*/
+
+
+#define GROUPSIZE 4096
+typedef struct membench_group {
+    int pos;
+    chunk chunks[GROUPSIZE];
+} membench_group;
+
+struct membench_arena {
+    membench_group* group;
+};
+
+
+static membench_group* membench_group_new(void) {
+    membench_group* g = (membench_group*) malloc(sizeof(membench_group));
+    g->pos = 0;
+    return g;
+}
+
+membench_arena* membench_arena_create(void) {
+    membench_arena* arena = (membench_arena*) malloc(sizeof(membench_arena));
+    arena->group = membench_group_new();
+    return arena;
+}
+
+chunk* membench_alloc(membench_arena* arena) {
+    membench_group* g = arena->group;
+    assert(g->pos < GROUPSIZE);
+    chunk* result = &g->chunks[g->pos];
+    ++g->pos;
+    return result;
+}
+
+void membench_free(membench_arena* arena, chunk* x) {
+    (void) arena, (void) x;
+}
+
+void membench_arena_destroy(membench_arena* arena) {
+    free(arena->group);
+    free(arena);
+}

fundamentals4/mb-arena1.c

@@ -0,0 +1,58 @@
+#include "membench.h"
+#include <stdlib.h>
+#include <assert.h>
+#include <stdint.h>
+#include <stddef.h>
+
+/*
+
+Write an arena allocator for `chunk` objects. Your allocator should:
+
+* Allocate a chunk in O(1) time.
+* Free a chunk in O(1) time.
+* Use memory proportional to the peak number of actively allocated
+chunks (rather than, say, the total number of allocated chunks).
+* Run out of memory only if the system has no more memory available.
+
+More on arenas:
+https://en.wikipedia.org/wiki/Region-based_memory_management
+
+See "membench.h" for function semantics.
+
+*/
+
+
+#define GROUPSIZE 1
+typedef struct membench_group {
+    int pos;
+    chunk chunks[GROUPSIZE];
+} membench_group;
+
+struct membench_arena {
+    membench_group* group;
+};
+
+
+membench_arena* membench_arena_create(void) {
+    membench_arena* arena = (membench_arena*) malloc(sizeof(membench_arena));
+    arena->group = (membench_group*) malloc(sizeof(membench_group));
+    arena->group->pos = 0;
+    return arena;
+}
+
+chunk* membench_alloc(membench_arena* arena) {
+    membench_group* g = arena->group;
+    assert(g->pos < GROUPSIZE);
+    chunk* result = &g->chunks[g->pos];
+    ++g->pos;
+    return result;
+}
+
+void membench_free(membench_arena* arena, chunk* x) {
+    (void) arena, (void) x;
+}
+
+void membench_arena_destroy(membench_arena* arena) {
+    free(arena->group);
+    free(arena);
+}