alloc: first cut of tiny allocator (down to 2 bytes!)

[ccan] / ccan / alloc / test / run-testsize.c

diff --git a/ccan/alloc/test/run-testsize.c b/ccan/alloc/test/run-testsize.c
index 2f0b772a4a3ba2a6c3f379b7b55581a51c810f63..5ad8d2311983fc32250762a5ac162748dc8ff507 100644 (file)
--- a/ccan/alloc/test/run-testsize.c
+++ b/ccan/alloc/test/run-testsize.c
@@ -1,13 +1,12 @@
 #include <ccan/alloc/alloc.h>
 #include <ccan/tap/tap.h>
 #include <ccan/alloc/alloc.c>
+#include <ccan/alloc/bitops.c>
+#include <ccan/alloc/tiny.c>
 #include <stdlib.h>
 #include <stdbool.h>
 #include <err.h>
 
-#define POOL_ORD 16
-#define POOL_SIZE (1 << POOL_ORD)
-
 static void invert_bytes(unsigned char *p, unsigned long size)
 {
        unsigned int i;
@@ -21,49 +20,62 @@ static bool sizes_ok(void *mem, unsigned long poolsize, void *p[], unsigned num)
        unsigned int i;
 
        for (i = 0; i < num; i++)
-               if (alloc_size(mem, poolsize, p[i]) < i)
+               if (p[i] && alloc_size(mem, poolsize, p[i]) < i)
                        return false;
        return true;
 }
 
-int main(int argc, char *argv[])
+static void test_pool(unsigned long pool_size)
 {
+       unsigned int i, j, num;
        void *mem;
-       unsigned int i, num;
-       void *p[POOL_SIZE];
-
-       plan_tests(5);
+       void **p;
+       bool flip = false;
 
-       /* FIXME: Needs to be page aligned for now. */
-       if (posix_memalign(&mem, 1 << POOL_ORD, POOL_SIZE) != 0)
-               errx(1, "Failed allocating aligned memory"); 
+       p = calloc(pool_size, sizeof(void *));
+       mem = malloc(pool_size);
 
-       alloc_init(mem, POOL_SIZE);
+       alloc_init(mem, pool_size);
 
        /* Check that alloc_size() gives reasonable answers. */
-       for (i = 0; i < POOL_SIZE; i++) {
-               p[i] = alloc_get(mem, POOL_SIZE, i, 1);
+       for (i = 0; i < pool_size; i = i * 3 / 2 + 1) {
+               p[i] = alloc_get(mem, pool_size, i, 1);
                if (!p[i])
                        break;
-               invert_bytes(p[i], alloc_size(mem, POOL_SIZE, p[i]));
+               invert_bytes(p[i], alloc_size(mem, pool_size, p[i]));
        }
-       ok1(i < POOL_SIZE);
+       ok1(i < pool_size);
        num = i;
-       ok1(alloc_check(mem, POOL_SIZE));
-       ok1(sizes_ok(mem, POOL_SIZE, p, num));
+       ok1(alloc_check(mem, pool_size));
+       ok1(sizes_ok(mem, pool_size, p, num));
 
        /* Free every second one. */
-       for (i = 0; i < num; i+=2) {
-               alloc_free(mem, POOL_SIZE, p[i]);
-               /* Compact. */
-               if (i + 1 < num) {
-                       p[i/2] = p[i + 1];
-                       invert_bytes(p[i/2], alloc_size(mem,POOL_SIZE,p[i/2]));
+       for (i = j = 0; i < num; i = i * 3 / 2 + 1) {
+               flip = !flip;
+               if (flip) {
+                       /* Compact. */
+                       p[j++] = p[i];
+                       invert_bytes(p[i], alloc_size(mem,pool_size,p[i]));
+                       continue;
                }
+               alloc_free(mem, pool_size, p[i]);
        }
        num /= 2;
-       ok1(alloc_check(mem, POOL_SIZE));
-       ok1(sizes_ok(mem, POOL_SIZE, p, num));
+       ok1(alloc_check(mem, pool_size));
+       ok1(sizes_ok(mem, pool_size, p, num));
+       free(p);
+       free(mem);
+}
+
+int main(int argc, char *argv[])
+{
+       plan_tests(10);
+
+       /* Large test. */
+       test_pool(MIN_USEFUL_SIZE * 2);
+
+       /* Small test. */
+       test_pool(MIN_USEFUL_SIZE / 2);
 
        return exit_status();
 }