6679l10100664000204600020460000000266207667440667010354 0ustar jilljill/* * Using the malloc hooks to substitute GC functions * to existing malloc/free. * Similar wrapper functions can be written * to redirect calloc() and realloc() */ #include #include static void gc_wrapper_init(void); static void *gc_wrapper_malloc(size_t,const void *); static void gc_wrapper_free(void*, const void *); __malloc_ptr_t (*old_malloc_hook) __MALLOC_PMT((size_t __size, __const __malloc_ptr_t)); void (*old_free_hook) __MALLOC_PMT ((__malloc_ptr_t __ptr, __const __malloc_ptr_t)); /* Override initializing hook from the C library. */ void (*__malloc_initialize_hook)(void) = gc_wrapper_init; static void gc_wrapper_init() { old_malloc_hook = __malloc_hook; old_free_hook = __free_hook; __malloc_hook = gc_wrapper_malloc; __free_hook = gc_wrapper_free; } void * gc_wrapper_malloc(size_t size, const void *ptr) { void *result; /* Restore all old hooks */ __malloc_hook = old_malloc_hook; __free_hook = old_free_hook; /* Call the Boehm malloc */ result = GC_malloc(size); /* Save underlying hooks */ old_malloc_hook = __malloc_hook; old_free_hook = __free_hook; /* Restore our own hooks */ __malloc_hook = gc_wrapper_malloc; __free_hook = gc_wrapper_free; return result; } static void gc_wrapper_free(void *ptr, const void *caller) { /* Nothing done! */ } Makefile0100664000204600020460000000022007667440625011177 0ustar jilljill SRCS=gctest.c gctest_parseopts.c gctest_aux.c gctest_instrument.c LIBS=-lgc -ldl -lm gctest: $(SRCS) gctest.h gcc $(SRCS) -o gctest $(LIBS) gctest.c0100664000204600020460000001033507667440647011210 0ustar jilljill/* * Garbage Collection test program * Author: G. Insolvibile * This program is part of * "Garbage Collection in C programs", * published in 2003 by Linux Journal */ #include #include #include #include #include #include #include "gctest.h" test_ops_t *ops; opts_t options; extern void instrument_init(test_ops_t *ops); extern void instrument_report(); void print_gc_info(); void ignore(void *); unsigned int malloc_heapsize(); void print_graph_info_gc(); void print_graph_info_malloc(); /* Operations for traditional mode testing */ test_ops_t traditional = { malloc, malloc, free, malloc_stats, malloc_heapsize, print_graph_info_malloc}; /* Operations for GC mode testing */ test_ops_t garbagecoll = { GC_malloc, GC_malloc_atomic, ignore, print_gc_info, GC_get_heap_size, print_graph_info_gc }; void test_report(struct timeval *delta, unsigned int heap); void print_gc_info() { printf("Number of bytes in the heap: %d\n", GC_get_heap_size()); printf("Lower bound on free bytes in the heap:" " %d\n", GC_get_free_bytes()); printf("Number of bytes allocated since last " "collection: %d\n", GC_get_bytes_since_gc()); printf("Total number of bytes allocated: %d\n", GC_get_total_bytes()); } void print_malloc_info() { malloc_stats(); } void print_graph_info_gc() { printf("== %d %d\n", GC_get_total_bytes(), GC_get_heap_size()); } void print_graph_info_malloc() { struct mallinfo minfo; minfo = mallinfo(); printf("== %d %d\n", minfo.uordblks, minfo.arena+minfo.hblkhd); } unsigned int malloc_heapsize() { struct mallinfo minfo; minfo = mallinfo(); return minfo.arena + minfo.hblkhd; } void *calloc_wrap(unsigned int size) { return calloc(1, size); } void ignore(void *p) {} void test_report(struct timeval *delta, unsigned int heapsize) { unsigned int listsize; unsigned long long overall; listsize = options.nelem * (options.elemsize +sizeof(list_t)); overall = options.loops * listsize; printf("\nTest conditions:\n----------------\n"); if (options.gc) printf("Boehm-Demers Garbage Collector\n"); else printf("Traditional malloc/free\n"); printf("Loops : %7d\nLength : %7d nodes\n" "Node size: %7d bytes\n", options.loops, options.nelem, options.elemsize + sizeof(list_t)); printf("List size : %10d bytes\n" "Overall alloc: %10lld bytes\n", listsize, overall); printf("Unlink during loop : %s\n", options.unlink?"yes":"no"); if (options.gc) { printf("Collect during loop: %s\n", options.collect?"yes":"no"); printf("Incremental GC : %s\n", options.incr?"yes":"no"); printf("Free space divisor : %d\n", GC_free_space_divisor); } printf("\nTest results:\n-------------\n"); printf("Peak heap size %d bytes\n", heapsize); printf("Heap/overall_alloc ratio %f\n", (float)heapsize/(float)overall); printf("Heap/list_size ratio %f\n", (float)heapsize/(float)listsize); if (delta) printf("Elapsed time %f sec\n", (float)delta->tv_sec +(float)delta->tv_usec/1000000.0); if (options.instr) instrument_report(); } int main(int argc, char **argv) { int heapsize, maxheap=0, n; struct timeval start, end, diff; char *hugewaste; options.fdiv = GC_free_space_divisor; if (parseopts(argc, argv, &options) == -1) { exit(0); } if (options.gc) { ops = &garbagecoll; } else { ops = &traditional; } if (options.incr) GC_enable_incremental(); GC_free_space_divisor = options.fdiv; if (options.instr) instrument_init(ops); if (!options.gc && options.calloc) { ops->alloc = calloc_wrap; } gettimeofday(&start, NULL); for (n=0; nprint_info(); if (options.graph) ops->print_graph_info(); if (options.gc && options.collect) GC_gcollect(); heapsize = ops->heap_size(); if (heapsize > maxheap) maxheap = heapsize; } gettimeofday(&end, NULL); timersub(&end, &start, &diff); test_report(&diff, maxheap); } gctest.h0100664000204600020460000000215107667440647011212 0ustar jilljill/* * Garbage Collection test program * Author: G. Insolvibile * This program is part of * "Garbage Collection in C programs", * published in 2003 by Linux Journal */ typedef struct { unsigned char gc:1; /* Use Garbage Collection */ unsigned char unlink:1; /* Unlink list */ unsigned char collect:1; /* Collect during loop */ unsigned char incr:1; /* Incremental GC */ unsigned char verbose:1; /* Verbose report */ unsigned char graph:1; /* Print graph info */ unsigned char instr:1; /* Collect time stats */ unsigned char calloc:1; /* Use calloc() instead * of malloc() */ unsigned char gcfree:1; /* Use GC_free() when * unlinking */ unsigned int fdiv; /* Free space divisor */ unsigned int elemsize; unsigned int nelem; unsigned int loops; } opts_t; typedef struct list { struct list *next; unsigned int key; unsigned char *waste; } list_t; typedef struct test_ops { void *(*alloc)(unsigned int); void *(*alloc_atomic)(unsigned int); void (*free)(void *); void (*print_info)(); unsigned int (*heap_size)(); void (*print_graph_info)(); } test_ops_t; gctest_aux.c0100664000204600020460000000240507667440647012064 0ustar jilljill/* * Garbage Collection test program * Author: G. Insolvibile * This program is part of * "Garbage Collection in C programs", * published in 2003 by Linux Journal */ #include #include "gctest.h" extern opts_t options; extern test_ops_t *ops; /* Add a new node to the list */ list_t *add_node(list_t *head, unsigned int key) { list_t *newnode; newnode = ops->alloc(sizeof(list_t)); if (!newnode) { printf("Fatal!\n"); return NULL; } newnode->waste = ops->alloc_atomic(options .elemsize); if (!newnode->waste) { printf("Fatal!\n"); return NULL; } newnode->key = key; newnode->next = head; return newnode; } /* Create a list of 'n' random elements */ list_t *create_list(int n) { list_t *head = NULL; int i; for (i=0; inext; ptr->next = NULL; if (options.gcfree) { GC_free(ptr->waste); GC_free(ptr); } else { ops->free(ptr->waste); ops->free(ptr); } ptr->waste = NULL; ptr = next; } } gctest_instrument.c0100664000204600020460000000371707667440647013506 0ustar jilljill/* * Garbage Collection test program * Author: G. Insolvibile * This program is part of * "Garbage Collection in C programs", * published in 2003 by Linux Journal */ #include #include #include #include "gctest.h" static void * (*origmalloc)(unsigned int); static void * (*origmallocat)(unsigned int); #define STATLEN 16384 /* must be a power of 2 */ static struct timeval measures[STATLEN]; static struct timeval start, end; static unsigned int stat_idx = 0; void *instr_malloc(unsigned int len) { void *tmp; gettimeofday(&start, NULL); tmp = origmalloc(len); gettimeofday(&end, NULL); timersub(&end, &start, &measures[stat_idx]); stat_idx = (stat_idx+1) & (STATLEN-1); return tmp; } void *instr_mallocat(unsigned int len) { void *tmp; gettimeofday(&start, NULL); tmp = origmallocat(len); gettimeofday(&end, NULL); timersub(&end, &start, &measures[stat_idx]); stat_idx = (stat_idx+1) & (STATLEN-1); return tmp; } void instrument_init(test_ops_t *ops) { origmalloc = ops->alloc; ops->alloc = instr_malloc; origmallocat = ops->alloc_atomic; ops->alloc_atomic = instr_mallocat; } void instrument_report() { int i; double delta, tavg=0.0, tvar=0.0, tmin=HUGE, tmax=0.0; printf("\nTiming measurements results\n" "---------------------------\n"); printf("Collected %d allocation times\n", stat_idx); /* Only (stat_idx % STATLEN) valus are counted */ for (i=0; i tmax) tmax = delta; else if (delta < tmin) tmin = delta; tavg += delta; } tavg /= stat_idx; for (i=0; i #include #include #include "gctest.h" static struct option long_options[] = { {"gc", 0, 0, 'g'}, {"trad", 0, 0, 't'}, {"elemsize", 1, 0, 's'}, {"nelem", 1, 0, 'n'}, {"loops", 1, 0, 'l'}, {"unlink", 0, 0, 'u'}, {"gcoll", 0, 0, 'G'}, {"incr", 0, 0, 'i'}, {"fdiv", 1, 0, 'f'}, {"verbose", 0, 0, 'v'}, {"graph", 0, 0, 'x'}, {"instrument", 0, 0, 'm'}, {"calloc", 0, 0, 'c'}, {"gcfree", 0, 0, 'F'}, {0, 0, 0, 0} }; #define OPTS_STRING "gts:n:l:uGif:xvmcF" void usage() { printf("Usage: gctest -g | -t [options]\n" " -g --gc use garbage collection (default)\n" " -t --trad use traditional malloc/free\n" " -s --elemsize list element size (default 10000)\n" " -n --nelem number of elements for each list (default 100)\n" " -l --loops number of loops (default 20)\n" " -v --verbose report stats for each loop\n" " -x --graph print graph info for each loop\n" " -m --instrument collect malloc delay stats\n" " -c --calloc use calloc() instead of malloc() [trad only]\n" "\n" "GC specific options:\n" " -u --unlink explicitly unlink list (default no)\n" " -G --gcoll perform GC during loop (default no)\n" " -i --incr enable incremental GC (default no)\n" " -f --fdiv set GC free space divisor (default 3)\n" " -F --gcfree use GC_free() when unlinking the list\n"); } int parseopts(int argc, char **argv, opts_t *opts) { int c; int result = -1; /* Set defaults */ opts->gc = 1; opts->unlink = 0; opts->collect = 0; opts->incr = 0; opts->instr = 0; opts->elemsize = 10000; opts->nelem = 100; opts->loops = 20; opts->calloc = 0; opts->gcfree = 0; while (1) { int this_option_optind = optind ? optind : 1; int option_index = 0; c = getopt_long (argc, argv, OPTS_STRING, long_options, &option_index); if (c == -1) break; switch (c) { case 'g': opts->gc = 1; result = 0; break; case 't': opts->gc = 0; result = 0; break; case 's': opts->elemsize = atoi(optarg); break; case 'n': opts->nelem = atoi(optarg); break; case 'l': opts->loops = atoi(optarg); break; case 'u': opts->unlink = 1; break; case 'G': opts->collect = 1; break; case 'i': opts->incr = 1; break; case 'f': opts->fdiv = atoi(optarg); break; case 'v': opts->verbose = 1; break; case 'x': opts->graph = 1; break; case 'm': opts->instr = 1; break; case 'c': opts->calloc = 1; break; case 'F': opts->gcfree = 1; break; default: usage(); return -1; } } if (result == -1) usage(); return result; }