mirror/guile
mirror/guile
1
Fork 0
mirror of https://git.savannah.gnu.org/git/guile.git synced 2025-05-09 15:10:29 +02:00
Code Activity

Refactor to separate gcbench from gc

Browse source
This commit is contained in:
Andy Wingo 2022-03-11 10:17:05 +01:00
parent 77ac530360
commit f57a1b8a55
10 changed files with 132 additions and 101 deletions
Download patch file Download diff file Expand all files Collapse all files

2
Makefile
View file

@ -1,4 +1,4 @@
TESTS=GCBench # MT_GCBench MT_GCBench2
TESTS=gcbench # MT_GCBench MT_GCBench2
COLLECTORS=bdw semi mark-sweep parallel-mark-sweep
CC=gcc

11
bdw.h
View file

@ -16,19 +16,16 @@
struct context {};
enum alloc_kind { NODE, DOUBLE_ARRAY };
typedef void (*field_visitor)(struct context *, void **ref);
#define GC_HEADER /**/
static inline void* allocate(struct context *cx, enum alloc_kind kind,
size_t size) {
// memset to 0 by the collector.
switch (kind) {
case NODE:
case ALLOC_KIND_NODE:
// cleared to 0 by the collector.
return GC_malloc(size);
case DOUBLE_ARRAY:
case ALLOC_KIND_DOUBLE_ARRAY:
// warning: not cleared!
return GC_malloc_atomic(size);
}
abort();

17
gc.h Normal file
View file

@ -0,0 +1,17 @@
#ifndef GC_H_
#define GC_H_
#if defined(GC_BDW)
#include "bdw.h"
#elif defined(GC_SEMI)
#include "semi.h"
#elif defined(GC_MARK_SWEEP)
#include "mark-sweep.h"
#elif defined(GC_PARALLEL_MARK_SWEEP)
#define GC_PARALLEL_MARK 1
#include "mark-sweep.h"
#else
#error unknown gc
#endif
#endif // GC_H_

30
gcbench-types.h Normal file
View file

@ -0,0 +1,30 @@
#ifndef GCBENCH_TYPES_H
#define GCBENCH_TYPES_H
#include "inline.h"
#define FOR_EACH_HEAP_OBJECT_KIND(M) \
M(node, Node, NODE) \
M(double_array, DoubleArray, DOUBLE_ARRAY)
#define DECLARE_NODE_TYPE(name, Name, NAME) \
struct Name; \
typedef struct Name Name;
FOR_EACH_HEAP_OBJECT_KIND(DECLARE_NODE_TYPE)
#undef DECLARE_NODE_TYPE
#define DEFINE_ENUM(name, Name, NAME) ALLOC_KIND_##NAME,
enum alloc_kind {
FOR_EACH_HEAP_OBJECT_KIND(DEFINE_ENUM)
};
#undef DEFINE_ENUM
#define DEFINE_METHODS(name, Name, NAME) \
static inline size_t name##_size(Name *obj) ALWAYS_INLINE; \
static inline void visit_##name##_fields(Name *obj,\
void (*visit)(void **loc, void *visit_data), \
void *visit_data) ALWAYS_INLINE;
FOR_EACH_HEAP_OBJECT_KIND(DEFINE_METHODS)
#undef DEFINE_METHODS
#endif // GCBENCH_TYPES_H

44
GCBench.c → gcbench.c
View file

@ -43,19 +43,8 @@
#include <sys/time.h>
#include "assert.h"
#if defined(GC_BDW)
#include "bdw.h"
#elif defined(GC_SEMI)
#include "semi.h"
#elif defined(GC_MARK_SWEEP)
#include "mark-sweep.h"
#elif defined(GC_PARALLEL_MARK_SWEEP)
#define GC_PARALLEL_MARK 1
#include "mark-sweep.h"
#else
#error unknown gc
#endif
#include "gcbench-types.h"
#include "gc.h"
static const int kStretchTreeDepth = 18; // about 16Mb
static const int kLongLivedTreeDepth = 16; // about 4Mb
@ -76,21 +65,23 @@ typedef struct DoubleArray {
double values[0];
} DoubleArray;
static inline size_t node_size(void *obj) {
static inline size_t node_size(Node *obj) {
return sizeof(Node);
}
static inline size_t double_array_size(void *obj) {
DoubleArray *array = obj;
static inline size_t double_array_size(DoubleArray *array) {
return sizeof(*array) + array->length * sizeof(double);
}
static inline void visit_node_fields(struct context *cx, void *obj,
field_visitor visit) {
Node *node = obj;
visit(cx, (void**)&node->left);
visit(cx, (void**)&node->right);
static inline void
visit_node_fields(Node *node,
void (*visit)(void **loc, void *visit_data),
void *visit_data) {
visit((void**)&node->left, visit_data);
visit((void**)&node->right, visit_data);
}
static inline void visit_double_array_fields(struct context *cx, void *obj,
field_visitor visit) {
static inline void
visit_double_array_fields(DoubleArray *obj,
void (*visit)(void **loc, void *visit_data),
void *visit_data) {
}
typedef HANDLE_TO(Node) NodeHandle;
@ -98,13 +89,14 @@ typedef HANDLE_TO(DoubleArray) DoubleArrayHandle;
static Node* allocate_node(struct context *cx) {
// memset to 0 by the collector.
return allocate(cx, NODE, sizeof (Node));
return allocate(cx, ALLOC_KIND_NODE, sizeof (Node));
}
static struct DoubleArray* allocate_double_array(struct context *cx,
size_t size) {
// note, not memset to 0 by the collector.
DoubleArray *ret = allocate(cx, DOUBLE_ARRAY, sizeof (double) * size);
// note, we might allow the collector to leave this data uninitialized.
DoubleArray *ret = allocate(cx, ALLOC_KIND_DOUBLE_ARRAY,
sizeof(DoubleArray) + sizeof (double) * size);
ret->length = size;
return ret;
}

7
inline.h Normal file
View file

@ -0,0 +1,7 @@
#ifndef INLINE_H
#define INLINE_H
#define ALWAYS_INLINE __attribute__((always_inline))
#define NEVER_INLINE __attribute__((noinline))
#endif // INLINE_H

38
mark-sweep.h
View file

@ -6,6 +6,7 @@
#include "assert.h"
#include "debug.h"
#include "inline.h"
#include "precise-roots.h"
#ifdef GC_PARALLEL_MARK
#include "parallel-marker.h"
@ -162,20 +163,11 @@ get_small_object_freelist(struct context *cx, enum small_object_size kind) {
#define GC_HEADER uintptr_t _gc_header
enum alloc_kind { NODE, DOUBLE_ARRAY };
typedef void (*field_visitor)(struct context *, void **ref);
static inline size_t node_size(void *obj) __attribute__((always_inline));
static inline size_t double_array_size(void *obj) __attribute__((always_inline));
static inline void visit_node_fields(struct context *cx, void *obj, field_visitor visit) __attribute__((always_inline));
static inline void visit_double_array_fields(struct context *cx, void *obj, field_visitor visit) __attribute__((always_inline));
static inline void clear_memory(uintptr_t addr, size_t size) {
memset((char*)addr, 0, size);
}
static void collect(struct context *cx) __attribute__((noinline));
static void collect(struct context *cx) NEVER_INLINE;
static inline uint8_t* mark_byte(struct context *cx, struct gcobj *obj) {
uintptr_t granule = (((uintptr_t) obj) - cx->heap_base) / GRANULE_SIZE;
@ -193,12 +185,12 @@ static inline int mark_object(struct context *cx, struct gcobj *obj) {
static void process(struct context *cx, struct gcobj *obj) {
switch (tag_live_alloc_kind(obj->tag)) {
case NODE:
visit_node_fields(cx, obj, marker_visit);
break;
case DOUBLE_ARRAY:
visit_double_array_fields(cx, obj, marker_visit);
break;
#define SCAN_OBJECT(name, Name, NAME) \
case ALLOC_KIND_##NAME: \
visit_##name##_fields((Name*)obj, marker_visit, cx); \
break;
FOR_EACH_HEAP_OBJECT_KIND(SCAN_OBJECT)
#undef SCAN_OBJECT
default:
abort ();
}
@ -215,7 +207,7 @@ static void collect(struct context *cx) {
DEBUG("start collect #%ld:\n", cx->count);
marker_prepare(cx);
for (struct handle *h = cx->roots; h; h = h->next)
marker_visit_root(cx, &h->v);
marker_visit_root(&h->v, cx);
marker_trace(cx, process);
marker_release(cx);
DEBUG("done marking\n");
@ -301,12 +293,12 @@ static size_t live_object_granules(struct gcobj *obj) {
return 1;
size_t bytes;
switch (tag_live_alloc_kind (obj->tag)) {
case NODE:
bytes = node_size(obj);
break;
case DOUBLE_ARRAY:
bytes = double_array_size(obj);
break;
#define COMPUTE_SIZE(name, Name, NAME) \
case ALLOC_KIND_##NAME: \
bytes = name##_size((Name*)obj); \
break;
FOR_EACH_HEAP_OBJECT_KIND(COMPUTE_SIZE)
#undef COMPUTE_SIZE
default:
abort ();
}

14
parallel-marker.h
View file

@ -7,6 +7,7 @@
#include "assert.h"
#include "debug.h"
#include "inline.h"
// The Chase-Lev work-stealing deque, as initially described in "Dynamic
// Circular Work-Stealing Deque" (Chase and Lev, SPAA'05)
@ -236,22 +237,23 @@ static void marker_release(struct context *cx) {
}
struct gcobj;
static inline void marker_visit(struct context *cx, void **loc) __attribute__((always_inline));
static inline void marker_visit(void **loc, void *mark_data) ALWAYS_INLINE;
static inline void marker_trace(struct context *cx,
void (*)(struct context *, struct gcobj *))
__attribute__((always_inline));
ALWAYS_INLINE;
static inline int mark_object(struct context *cx,
struct gcobj *obj) __attribute__((always_inline));
struct gcobj *obj) ALWAYS_INLINE;
static inline void
marker_visit(struct context *cx, void **loc) {
marker_visit(void **loc, void *mark_data) {
struct context *cx = mark_data;
struct gcobj *obj = *loc;
if (obj && mark_object(cx, obj))
mark_deque_push(&context_marker(cx)->deque, (uintptr_t)obj);
}
static inline void
marker_visit_root(struct context *cx, void **loc) {
marker_visit(cx, loc);
marker_visit_root(void **loc, struct context *cx) {
marker_visit(loc, cx);
}
static inline void
marker_trace(struct context *cx,

55
semi.h
View file

@ -23,22 +23,13 @@ static uintptr_t align_up(uintptr_t addr, size_t align) {
#define GC_HEADER uintptr_t _gc_header
enum alloc_kind { NODE, DOUBLE_ARRAY };
typedef void (*field_visitor)(struct context *, void **ref);
static inline size_t node_size(void *obj) __attribute__((always_inline));
static inline size_t double_array_size(void *obj) __attribute__((always_inline));
static inline void visit_node_fields(struct context *cx, void *obj, field_visitor visit) __attribute__((always_inline));
static inline void visit_double_array_fields(struct context *cx, void *obj, field_visitor visit) __attribute__((always_inline));
static inline void clear_memory(uintptr_t addr, size_t size) {
memset((char*)addr, 0, size);
}
static void collect(struct context *cx, size_t bytes) __attribute__((noinline));
static void collect(struct context *cx, size_t bytes) NEVER_INLINE;
static void process(struct context *cx, void **loc);
static void visit(void **loc, void *visit_data);
static void flip(struct context *cx) {
uintptr_t split = cx->base + (cx->size >> 1);
@ -55,12 +46,12 @@ static void flip(struct context *cx) {
static void* copy(struct context *cx, uintptr_t kind, void *obj) {
size_t size;
switch (kind) {
case NODE:
size = node_size(obj);
break;
case DOUBLE_ARRAY:
size = double_array_size(obj);
break;
#define COMPUTE_SIZE(name, Name, NAME) \
case ALLOC_KIND_##NAME: \
size = name##_size(obj); \
break;
FOR_EACH_HEAP_OBJECT_KIND(COMPUTE_SIZE)
#undef COMPUTE_SIZE
default:
abort ();
}
@ -75,14 +66,12 @@ static uintptr_t scan(struct context *cx, uintptr_t grey) {
void *obj = (void*)grey;
uintptr_t kind = *(uintptr_t*) obj;
switch (kind) {
case NODE:
visit_node_fields(cx, obj, process);
return grey + align_up (node_size(obj), ALIGNMENT);
break;
case DOUBLE_ARRAY:
visit_double_array_fields(cx, obj, process);
return grey + align_up (double_array_size(obj), ALIGNMENT);
break;
#define SCAN_OBJECT(name, Name, NAME) \
case ALLOC_KIND_##NAME: \
visit_##name##_fields((Name*)obj, visit, cx); \
return grey + align_up(name##_size((Name*)obj), ALIGNMENT);
FOR_EACH_HEAP_OBJECT_KIND(SCAN_OBJECT)
#undef SCAN_OBJECT
default:
abort ();
}
@ -91,15 +80,18 @@ static uintptr_t scan(struct context *cx, uintptr_t grey) {
static void* forward(struct context *cx, void *obj) {
uintptr_t header_word = *(uintptr_t*)obj;
switch (header_word) {
case NODE:
case DOUBLE_ARRAY:
#define CASE_ALLOC_KIND(name, Name, NAME) \
case ALLOC_KIND_##NAME:
FOR_EACH_HEAP_OBJECT_KIND(CASE_ALLOC_KIND)
#undef CASE_ALLOC_KIND
return copy(cx, header_word, obj);
default:
return (void*)header_word;
}
}
static void process(struct context *cx, void **loc) {
static void visit(void **loc, void *visit_data) {
struct context *cx = visit_data;
void *obj = *loc;
if (obj != NULL)
*loc = forward(cx, obj);
@ -109,7 +101,7 @@ static void collect(struct context *cx, size_t bytes) {
flip(cx);
uintptr_t grey = cx->hp;
for (struct handle *h = cx->roots; h; h = h->next)
process(cx, &h->v);
visit(&h->v, cx);
// fprintf(stderr, "pushed %zd bytes in roots\n", cx->hp - grey);
while(grey < cx->hp)
grey = scan(cx, grey);
@ -134,8 +126,9 @@ static inline void* allocate(struct context *cx, enum alloc_kind kind,
void *ret = (void *)addr;
uintptr_t *header_word = ret;
*header_word = kind;
if (kind == NODE)
clear_memory(addr + sizeof(uintptr_t), size - sizeof(uintptr_t));
// FIXME: Allow allocator to avoid initializing pointerless memory?
// if (kind == NODE)
clear_memory(addr + sizeof(uintptr_t), size - sizeof(uintptr_t));
return ret;
}
}

15
serial-marker.h
View file

@ -49,7 +49,7 @@ mark_queue_put(struct mark_queue *q, size_t idx, uintptr_t x) {
q->buf[idx & (q->size - 1)] = x;
}
static int mark_queue_grow(struct mark_queue *q) __attribute__((noinline));
static int mark_queue_grow(struct mark_queue *q) NEVER_INLINE;
static int
mark_queue_grow(struct mark_queue *q) {
@ -125,22 +125,23 @@ static void marker_release(struct context *cx) {
}
struct gcobj;
static inline void marker_visit(struct context *cx, void **loc) __attribute__((always_inline));
static inline void marker_visit(void **loc, void *mark_data) ALWAYS_INLINE;
static inline void marker_trace(struct context *cx,
void (*)(struct context *, struct gcobj *))
__attribute__((always_inline));
ALWAYS_INLINE;
static inline int mark_object(struct context *cx,
struct gcobj *obj) __attribute__((always_inline));
struct gcobj *obj) ALWAYS_INLINE;
static inline void
marker_visit(struct context *cx, void **loc) {
marker_visit(void **loc, void *mark_data) {
struct context *cx = mark_data;
struct gcobj *obj = *loc;
if (obj && mark_object(cx, obj))
mark_queue_push(&context_marker(cx)->queue, obj);
}
static inline void
marker_visit_root(struct context *cx, void **loc) {
marker_visit(cx, loc);
marker_visit_root(void **loc, struct context *cx) {
marker_visit(loc, cx);
}
static inline void
marker_trace(struct context *cx,