| |
| #include <stdlib.h> |
| #include <stdint.h> |
| #include <assert.h> |
| #include <string.h> |
| |
| #include "../memcheck.h" |
| |
| struct cell |
| { |
| struct cell *next; |
| int x; |
| }; |
| |
| struct pool |
| { |
| size_t allocated; |
| size_t used; |
| uint8_t *buf; |
| }; |
| |
| void * |
| allocate_from_pool(struct pool *p, size_t n) |
| { |
| void *a = p->buf + p->used; |
| assert(p->used + n < p->allocated); |
| VALGRIND_MEMPOOL_ALLOC(p, a, n); |
| p->used += n; |
| return a; |
| } |
| |
| struct pool * |
| allocate_pool() |
| { |
| struct pool *p = malloc(sizeof(struct pool)); |
| assert(p); |
| p->allocated = 4096; |
| p->used = 0; |
| p->buf = malloc(p->allocated); |
| assert(p->buf); |
| memset(p->buf, 0, p->allocated); |
| VALGRIND_CREATE_MEMPOOL(p, 0, 0); |
| VALGRIND_MAKE_MEM_NOACCESS(p->buf, p->allocated); |
| return p; |
| } |
| |
| #define N 100 |
| |
| /* flags */ |
| int static_roots = 0; |
| int trim_pool = 0; |
| int destroy_pool = 0; |
| void set_flags ( int n ) |
| { |
| switch (n) { |
| case 0: |
| static_roots = 0; |
| trim_pool = 0; |
| destroy_pool = 0; |
| break; |
| case 1: |
| static_roots = 0; |
| trim_pool = 1; |
| destroy_pool = 0; |
| break; |
| case 2: |
| static_roots = 0; |
| trim_pool = 0; |
| destroy_pool = 1; |
| break; |
| case 3: |
| static_roots = 1; |
| trim_pool = 0; |
| destroy_pool = 0; |
| break; |
| case 4: |
| static_roots = 1; |
| trim_pool = 1; |
| destroy_pool = 0; |
| break; |
| case 5: |
| static_roots = 1; |
| trim_pool = 0; |
| destroy_pool = 1; |
| break; |
| default: |
| assert(0); |
| } |
| } |
| |
| |
| struct cell *cells_static[N]; |
| |
| |
| int main( int argc, char** argv ) |
| { |
| struct cell *cells_local[N]; |
| int arg; |
| size_t i; |
| struct pool *p = allocate_pool(); |
| struct cell **cells = static_roots ? cells_static : cells_local; |
| |
| assert(argc == 2); |
| assert(argv[1]); |
| assert(strlen(argv[1]) == 1); |
| assert(argv[1][0] >= '0' && argv[1][0] <= '5'); |
| arg = atoi( argv[1] ); |
| set_flags( arg ); |
| |
| memset(cells_static, 0, sizeof(cells_static)); |
| memset(cells_local, 0, sizeof(cells_local)); |
| |
| for (i = 0; i < N; ++i) { |
| cells[i] = allocate_from_pool(p, sizeof(struct cell)); |
| } |
| |
| if (trim_pool) |
| VALGRIND_MEMPOOL_TRIM(p, |
| p->buf+(10 * sizeof(struct cell)), |
| 20 * sizeof(struct cell) + 2); |
| |
| if (destroy_pool) |
| VALGRIND_DESTROY_MEMPOOL(p); |
| |
| return 0; |
| } |