X-Git-Url: https://git.ozlabs.org/?p=ccan;a=blobdiff_plain;f=ccan%2Falloc%2Ftest%2Frun.c;h=f98eb7c5e9e90a620a06a370592314d913cae427;hp=8cfe8b42ba00d3c40a14a533f6d644426341ff9e;hb=7f9d956574d30f70d2260f4b7694f481e3765173;hpb=650c775ff00cccd03fc84e7789a03c51d9839004 diff --git a/ccan/alloc/test/run.c b/ccan/alloc/test/run.c index 8cfe8b42..f98eb7c5 100644 --- a/ccan/alloc/test/run.c +++ b/ccan/alloc/test/run.c @@ -1,10 +1,10 @@ -#include "alloc/alloc.h" -#include "tap/tap.h" -#include "alloc/alloc.c" +#include +#include +#include +#include +#include #include - -#define POOL_ORD 16 -#define POOL_SIZE (1 << POOL_ORD) +#include #define sort(p, num, cmp) \ qsort((p), (num), sizeof(*p), (int(*)(const void *, const void *))cmp) @@ -24,35 +24,36 @@ static bool unique(void *p[], unsigned int num) return true; } -static bool free_every_second_one(void *mem, unsigned int num, void *p[]) +static bool free_every_second_one(void *mem, unsigned int num, + unsigned long pool_size, void *p[]) { unsigned int i; /* Free every second one. */ for (i = 0; i < num; i += 2) { - alloc_free(mem, POOL_SIZE, p[i]); - if (!alloc_check(mem, POOL_SIZE)) - return false; + alloc_free(mem, pool_size, p[i]); } + if (!alloc_check(mem, pool_size)) + return false; for (i = 1; i < num; i += 2) { - alloc_free(mem, POOL_SIZE, p[i]); - if (!alloc_check(mem, POOL_SIZE)) - return false; + alloc_free(mem, pool_size, p[i]); } + if (!alloc_check(mem, pool_size)) + return false; return true; } - -int main(int argc, char *argv[]) +static void test(unsigned int pool_size) { void *mem; unsigned int i, num, max_size; - void *p[POOL_SIZE]; - - plan_tests(139); + void **p = calloc(pool_size, sizeof(*p)); + /* FIXME: Should be pool_size! */ + unsigned alloc_limit = (pool_size / MAX_LARGE_PAGES) >> MAX_PAGE_OBJECT_ORDER; /* FIXME: Needs to be page aligned for now. */ - posix_memalign(&mem, 1 << POOL_ORD, POOL_SIZE); + if (posix_memalign(&mem, pool_size, pool_size) != 0) + errx(1, "Failed allocating aligned memory"); /* Small pool, all allocs fail, even 0-length. */ alloc_init(mem, 0); @@ -64,31 +65,33 @@ int main(int argc, char *argv[]) /* Free of NULL should work. */ alloc_free(mem, 0, NULL); - alloc_init(mem, POOL_SIZE); - ok1(alloc_check(mem, POOL_SIZE)); + alloc_init(mem, pool_size); + ok1(alloc_check(mem, pool_size)); /* Find largest allocation which works. */ - for (max_size = POOL_SIZE * 2; max_size; max_size--) { - p[0] = alloc_get(mem, POOL_SIZE, max_size, 1); + for (max_size = pool_size + 1; max_size; max_size--) { + p[0] = alloc_get(mem, pool_size, max_size, 1); if (p[0]) break; } - ok1(max_size < POOL_SIZE); + ok1(max_size < pool_size); ok1(max_size > 0); - ok1(alloc_check(mem, POOL_SIZE)); + ok1(alloc_check(mem, pool_size)); + ok1(alloc_size(mem, pool_size, p[0]) >= max_size); /* Free it, should be able to reallocate it. */ - alloc_free(mem, POOL_SIZE, p[0]); - ok1(alloc_check(mem, POOL_SIZE)); + alloc_free(mem, pool_size, p[0]); + ok1(alloc_check(mem, pool_size)); - p[0] = alloc_get(mem, POOL_SIZE, max_size, 1); + p[0] = alloc_get(mem, pool_size, max_size, 1); ok1(p[0]); - ok1(alloc_check(mem, POOL_SIZE)); - alloc_free(mem, POOL_SIZE, p[0]); - ok1(alloc_check(mem, POOL_SIZE)); + ok1(alloc_size(mem, pool_size, p[0]) >= max_size); + ok1(alloc_check(mem, pool_size)); + alloc_free(mem, pool_size, p[0]); + ok1(alloc_check(mem, pool_size)); /* Allocate a whole heap. */ - for (i = 0; i < POOL_SIZE; i++) { - p[i] = alloc_get(mem, POOL_SIZE, 1, 1); + for (i = 0; i < pool_size; i++) { + p[i] = alloc_get(mem, pool_size, 1, 1); if (!p[i]) break; } @@ -96,13 +99,13 @@ int main(int argc, char *argv[]) /* Uncomment this for a more intuitive view of what the * allocator looks like after all these 1 byte allocs. */ #if 0 - alloc_visualize(stderr, mem, POOL_SIZE); + alloc_visualize(stderr, mem, pool_size); #endif num = i; /* Can't allocate this many. */ - ok1(num != POOL_SIZE); - ok1(alloc_check(mem, POOL_SIZE)); + ok1(num != pool_size); + ok1(alloc_check(mem, pool_size)); /* Sort them. */ sort(p, num, addr_cmp); @@ -110,86 +113,66 @@ int main(int argc, char *argv[]) /* Uniqueness check */ ok1(unique(p, num)); - ok1(free_every_second_one(mem, num, p)); - ok1(alloc_check(mem, POOL_SIZE)); + ok1(free_every_second_one(mem, num, pool_size, p)); + ok1(alloc_check(mem, pool_size)); /* Should be able to reallocate max size. */ - p[0] = alloc_get(mem, POOL_SIZE, max_size, 1); + p[0] = alloc_get(mem, pool_size, max_size, 1); ok1(p[0]); - ok1(alloc_check(mem, POOL_SIZE)); + ok1(alloc_check(mem, pool_size)); + ok1(alloc_size(mem, pool_size, p[0]) >= max_size); /* Re-initializing should be the same as freeing everything */ - alloc_init(mem, POOL_SIZE); - ok1(alloc_check(mem, POOL_SIZE)); - p[0] = alloc_get(mem, POOL_SIZE, max_size, 1); + alloc_init(mem, pool_size); + ok1(alloc_check(mem, pool_size)); + p[0] = alloc_get(mem, pool_size, max_size, 1); ok1(p[0]); - ok1(alloc_check(mem, POOL_SIZE)); - alloc_free(mem, POOL_SIZE, p[0]); - ok1(alloc_check(mem, POOL_SIZE)); + ok1(alloc_size(mem, pool_size, p[0]) >= max_size); + ok1(alloc_check(mem, pool_size)); + alloc_free(mem, pool_size, p[0]); + ok1(alloc_check(mem, pool_size)); /* Alignment constraints should be met, as long as powers of two */ - for (i = 0; i < POOL_ORD-1; i++) { - p[i] = alloc_get(mem, POOL_SIZE, i, 1 << i); + for (i = 0; (1 << i) < alloc_limit; i++) { + p[i] = alloc_get(mem, pool_size, i, 1 << i); ok1(p[i]); ok1(((unsigned long)p[i] % (1 << i)) == 0); - ok1(alloc_check(mem, POOL_SIZE)); + ok1(alloc_check(mem, pool_size)); + ok1(alloc_size(mem, pool_size, p[i]) >= i); } - for (i = 0; i < POOL_ORD-1; i++) { - alloc_free(mem, POOL_SIZE, p[i]); - ok1(alloc_check(mem, POOL_SIZE)); + for (i = 0; (1 << i) < alloc_limit; i++) { + alloc_free(mem, pool_size, p[i]); + ok1(alloc_check(mem, pool_size)); } /* Alignment constraints for a single-byte allocation. */ - for (i = 0; i < POOL_ORD; i++) { - p[0] = alloc_get(mem, POOL_SIZE, 1, 1 << i); + for (i = 0; (1 << i) < alloc_limit; i++) { + p[0] = alloc_get(mem, pool_size, 1, 1 << i); ok1(p[0]); - ok1(alloc_check(mem, POOL_SIZE)); - alloc_free(mem, POOL_SIZE, p[0]); - ok1(alloc_check(mem, POOL_SIZE)); + ok1(alloc_check(mem, pool_size)); + ok1(alloc_size(mem, pool_size, p[i]) >= 1); + alloc_free(mem, pool_size, p[0]); + ok1(alloc_check(mem, pool_size)); } /* Alignment check for a 0-byte allocation. Corner case. */ - p[0] = alloc_get(mem, POOL_SIZE, 0, 1 << (POOL_ORD - 1)); - ok1(alloc_check(mem, POOL_SIZE)); - alloc_free(mem, POOL_SIZE, p[0]); - ok1(alloc_check(mem, POOL_SIZE)); - - /* Force the testing of split metadata. */ - alloc_init(mem, POOL_SIZE); - for (i = 0; i < POOL_SIZE; i++) { - p[i] = alloc_get(mem, POOL_SIZE, getpagesize(), getpagesize()); - if (!p[i]) - break; - } - ok1(alloc_check(mem, POOL_SIZE)); - - /* Sort them. */ - sort(p, i-1, addr_cmp); - - /* Free all but the one next to the metadata. */ - for (i = 1; p[i]; i++) - alloc_free(mem, POOL_SIZE, p[i]); - ok1(alloc_check(mem, POOL_SIZE)); + p[0] = alloc_get(mem, pool_size, 0, alloc_limit); + ok1(alloc_check(mem, pool_size)); + ok1(alloc_size(mem, pool_size, p[0]) < pool_size); + alloc_free(mem, pool_size, p[0]); + ok1(alloc_check(mem, pool_size)); +} - /* Now do a whole heap of subpage allocs. */ - for (i = 1; i < POOL_SIZE; i++) { - p[i] = alloc_get(mem, POOL_SIZE, 1, 1); - if (!p[i]) - break; - } - ok1(alloc_check(mem, POOL_SIZE)); +int main(int argc, char *argv[]) +{ + plan_tests(112 + 92); - /* Free up our page next to metadata, and should be able to alloc */ - alloc_free(mem, POOL_SIZE, p[0]); - ok1(alloc_check(mem, POOL_SIZE)); - p[0] = alloc_get(mem, POOL_SIZE, 1, 1); - ok1(p[0]); + /* Large test. */ + test(MIN_USEFUL_SIZE * 2); - /* Clean up. */ - for (i = 0; p[i]; i++) - alloc_free(mem, POOL_SIZE, p[i]); - ok1(alloc_check(mem, POOL_SIZE)); + /* Small test. */ + test(MIN_USEFUL_SIZE / 2); return exit_status(); }