return 1;
if (strcmp(argv[1], "depends") == 0) {
+ printf("ccan/alignof\n");
printf("ccan/compiler\n");
printf("ccan/likely\n");
printf("ccan/list\n");
all: speed samba-allocs
-speed: speed.o tal.o talloc.o time.o list.o take.o
+speed: speed.o tal.o talloc.o time.o list.o take.o str.o
samba-allocs: samba-allocs.o tal.o talloc.o time.o list.o take.o
tal.o: ../tal.c
$(CC) $(CFLAGS) -c -o $@ $<
+str.o: ../str/str.c
+ $(CC) $(CFLAGS) -c -o $@ $<
talloc.o: ../../talloc/talloc.c
$(CC) $(CFLAGS) -c -o $@ $<
time.o: ../../time/time.c
static void do_tallocs(struct node *node)
{
unsigned int i;
-
- node->n = talloc_size(node->parent ? node->parent->n : NULL, node->len);
+ static int count;
+
+ if (count++ % 16 == 0)
+ node->n = talloc_array(node->parent ? node->parent->n : NULL,
+ char, node->len);
+ else
+ node->n = talloc_size(node->parent ? node->parent->n : NULL,
+ node->len);
if (node->destructor)
talloc_set_destructor(node->n, unused_talloc_destructor);
if (node->name)
static void do_tals(struct node *node)
{
unsigned int i;
+ static int count;
+
+ /* Tal pays a penalty for arrays, but we can't tell which is an array
+ * and which isn't. Grepping samba source gives 1221 talloc_array of
+ * 33137 talloc occurrences, so conservatively assume 1 in 16 */
+ if (count++ % 16 == 0)
+ node->n = tal_arr(node->parent ? node->parent->n : NULL,
+ char, node->len);
+ else
+ node->n = tal_alloc_(node->parent ? node->parent->n : NULL,
+ node->len, false, TAL_LABEL(type, ""));
- node->n = tal_arr(node->parent ? node->parent->n : NULL,
- char, node->len);
if (node->destructor)
tal_add_destructor(node->n, unused_tal_destructor);
if (node->name)
printf("Tal time: %lluns\n", time_to_nsec(alloc_time));
printf("Tal_free time: %lluns\n", time_to_nsec(free_time));
-after_tal:
free_time.tv_sec = free_time.tv_nsec = 0;
for (i = 0; i < LOOPS; i++) {
do_tals(root);
}
free_time = time_divide(free_time, i);
printf("Single tal_free time: %lluns\n", time_to_nsec(free_time));
+after_tal:
return 0;
}
*/
#include <ccan/talloc/talloc.h>
#include <ccan/tal/tal.h>
+#include <ccan/tal/str/str.h>
#include <ccan/time/time.h>
#include <ccan/err/err.h>
#include <string.h>
#include <ccan/compiler/compiler.h>
#include <ccan/list/list.h>
#include <ccan/take/take.h>
+#include <ccan/alignof/alignof.h>
#include <assert.h>
#include <stdio.h>
#include <stddef.h>
static void *(*resizefn)(void *, size_t size) = realloc;
static void (*freefn)(void *) = free;
static void (*errorfn)(const char *msg) = (void *)abort;
-static bool initialized = false;
/* Count on non-destrutor notifiers; often stays zero. */
static size_t notifiers = 0;
}
/* This means valgrind can see leaks. */
-static void tal_cleanup(void)
+void tal_cleanup(void)
{
struct tal_hdr *i;
- while ((i = list_top(&null_parent.c.children, struct tal_hdr, list)))
+ while ((i = list_top(&null_parent.c.children, struct tal_hdr, list))) {
list_del(&i->list);
+ memset(i, 0, sizeof(*i));
+ }
/* Cleanup any taken pointers. */
take_cleanup();
}
-/* For allocation failures inside ccan/take */
-static void take_alloc_failed(const void *p)
-{
- tal_free(p);
-}
-
/* We carefully start all real properties with a zero byte. */
static bool is_literal(const struct prop_hdr *prop)
{
return prop;
}
-static struct length *add_length_property(struct tal_hdr *t, size_t count)
-{
- struct length *prop;
-
- prop = allocate(sizeof(*prop));
- if (prop) {
- init_property(&prop->hdr, t, LENGTH);
- prop->count = count;
- }
- return prop;
-}
-
static struct children *add_child_property(struct tal_hdr *parent,
struct tal_hdr *child)
{
struct children *children = find_property(parent, CHILDREN);
if (!children) {
- if (unlikely(!initialized)) {
- atexit(tal_cleanup);
- take_allocfail(take_alloc_failed);
- initialized = true;
- }
children = add_child_property(parent, child);
if (!children)
return false;
/* Finally free our properties. */
for (p = t->prop; p && !is_literal(p); p = next) {
next = p->next;
- freefn(p);
+ /* LENGTH is appended, so don't free separately! */
+ if (p->type != LENGTH)
+ freefn(p);
}
freefn(t);
}
static bool adjust_size(size_t *size, size_t count)
{
+ const size_t extra = sizeof(struct tal_hdr) + sizeof(struct length)*2;
+
/* Multiplication wrap */
if (count && unlikely(*size * count / *size != count))
goto overflow;
*size *= count;
- /* Make sure we don't wrap adding header. */
- if (*size + sizeof(struct tal_hdr) < sizeof(struct tal_hdr))
+ /* Make sure we don't wrap adding header/tailer. */
+ if (*size + extra < extra)
goto overflow;
return true;
overflow:
return false;
}
+static size_t extra_for_length(size_t size)
+{
+ size_t extra;
+ const size_t align = ALIGNOF(struct length);
+
+ /* Round up size, and add tailer. */
+ extra = ((size + align-1) & ~(align-1)) - size;
+ extra += sizeof(struct length);
+ return extra;
+}
+
void *tal_alloc_arr_(const tal_t *ctx, size_t size, size_t count, bool clear,
bool add_count, const char *label)
{
if (!adjust_size(&size, count))
return NULL;
+ if (add_count)
+ size += extra_for_length(size);
+
ret = tal_alloc_(ctx, size, clear, label);
- if (likely(ret) && add_count) {
- if (unlikely(!add_length_property(to_tal_hdr(ret), count)))
- ret = tal_free(ret);
+ if (unlikely(!ret))
+ return ret;
+
+ if (add_count) {
+ struct length *lprop;
+ lprop = (struct length *)((char *)ret + size) - 1;
+ init_property(&lprop->hdr, to_tal_hdr(ret), LENGTH);
+ lprop->count = count;
}
return ret;
}
{
struct tal_hdr *old_t, *t;
struct children *child;
- struct length *len;
+ struct prop_hdr **lenp;
+ struct length len;
+ size_t extra = 0;
old_t = debug_tal(to_tal_hdr(*ctxp));
if (!adjust_size(&size, count))
return false;
- t = resizefn(old_t, size + sizeof(struct tal_hdr));
+ lenp = find_property_ptr(old_t, LENGTH);
+ if (lenp) {
+ /* Copy here, in case we're shrinking! */
+ len = *(struct length *)*lenp;
+ extra = extra_for_length(size);
+ }
+
+ t = resizefn(old_t, sizeof(struct tal_hdr) + size + extra);
if (!t) {
call_error("Reallocation failure");
return false;
}
+ /* Copy length to end. */
+ if (lenp) {
+ struct length *new_len;
+
+ new_len = (struct length *)((char *)(t + 1) + size);
+ len.count = count;
+ *new_len = len;
+
+ /* Be careful replacing next ptr; could be old hdr. */
+ if (lenp == &old_t->prop)
+ t->prop = &new_len->hdr;
+ else
+ *lenp = &new_len->hdr;
+ }
+
+ update_bounds(t, sizeof(struct tal_hdr) + size + extra);
+
/* If it didn't move, we're done! */
if (t != old_t) {
- update_bounds(t, size + sizeof(struct tal_hdr));
-
/* Fix up linked list pointers. */
- if (list_entry(t->list.next, struct tal_hdr, list) != old_t)
- t->list.next->prev = t->list.prev->next = &t->list;
+ t->list.next->prev = t->list.prev->next = &t->list;
/* Fix up child property's parent pointer. */
child = find_property(t, CHILDREN);
if (notifiers)
notify(t, TAL_NOTIFY_MOVE, from_tal_hdr(old_t));
}
- len = find_property(t, LENGTH);
- if (len)
- len->count = count;
if (notifiers)
notify(t, TAL_NOTIFY_RESIZE, (void *)size);
bool tal_expand_(tal_t **ctxp, const void *src, size_t size, size_t count)
{
struct length *l;
+ size_t old_count;
bool ret = false;
l = find_property(debug_tal(to_tal_hdr(*ctxp)), LENGTH);
+ old_count = l->count;
/* Check for additive overflow */
- if (l->count + count < count) {
+ if (old_count + count < count) {
call_error("dup size overflow");
goto out;
}
/* Don't point src inside thing we're expanding! */
assert(src < *ctxp
- || (char *)src >= (char *)(*ctxp) + (size * l->count));
+ || (char *)src >= (char *)(*ctxp) + (size * old_count));
- /* Note: updates l->count. */
- if (!tal_resize_(ctxp, size, l->count + count))
+ if (!tal_resize_(ctxp, size, old_count + count))
goto out;
- memcpy((char *)*ctxp + size * (l->count - count),
- src, count * size);
+ memcpy((char *)*ctxp + size * old_count, src, count * size);
ret = true;
out:
tal_expand_((void **)(a1p), (a2), sizeof**(a1p), \
(num2) + 0*sizeof(*(a1p) == (a2)))
+/**
+ * tal_cleanup - remove pointers from NULL node
+ *
+ * Internally, tal keeps a list of nodes allocated from @ctx NULL; this
+ * prevents valgrind from noticing memory leaks. This re-initializes
+ * that list to empty.
+ *
+ * It also calls take_cleanup() for you.
+ */
+void tal_cleanup(void);
+
/**
* tal_check - set the allocation or error functions to use
ok1(err_count == when_to_fail - 1);
tal_free(p);
+ tal_cleanup();
return exit_status();
}
ok1(tal_first(parent) == NULL);
tal_free(parent);
+ tal_cleanup();
return exit_status();
}
#include <ccan/tal/tal.c>
#include <ccan/tap/tap.h>
+static bool move;
+#define ALIGN (sizeof(void *)*2)
+
+static void *my_alloc(size_t len)
+{
+ char *ret = malloc(len + ALIGN);
+ memcpy(ret, &len, sizeof(len));
+ return ret + ALIGN;
+}
+
+static void my_free(void *p)
+{
+ if (p)
+ free((char *)p - ALIGN);
+}
+
+static void *my_realloc(void *old, size_t new_size)
+{
+ char *ret;
+
+ /* Test what happens if we always move */
+ if (move) {
+ size_t old_size = *(size_t *)((char *)old - ALIGN);
+ ret = my_alloc(new_size);
+ memcpy(ret, old, old_size > new_size ? new_size : old_size);
+ my_free(old);
+ } else {
+ ret = realloc((char *)old - ALIGN, new_size + ALIGN);
+ memcpy(ret, &new_size, sizeof(new_size));
+ ret += ALIGN;
+ }
+ return ret;
+}
+
int main(void)
{
char *p1, *p2;
+ unsigned int i;
+
+ tal_set_backend(my_alloc, my_realloc, my_free, NULL);
+
+ plan_tests(19 * 3);
+
+ for (i = 0; i < 3; i++) {
+ move = i;
+
+ p1 = tal(NULL, char);
+ ok1(p1);
+ ok1(tal_count(p1) == 0);
+
+ p2 = tal_arr(p1, char, 1);
+ ok1(p2);
+ ok1(tal_count(p2) == 1);
+ ok1(tal_resize(&p2, 2));
+ ok1(tal_count(p2) == 2);
+ ok1(tal_check(NULL, NULL));
+ tal_free(p2);
- plan_tests(12);
-
- p1 = tal(NULL, char);
- ok1(p1);
- ok1(tal_count(p1) == 0);
-
- p2 = tal_arr(p1, char, 1);
- ok1(p2);
- ok1(tal_count(p2) == 1);
- ok1(tal_resize(&p2, 2));
- ok1(tal_count(p2) == 2);
- ok1(tal_check(NULL, NULL));
- tal_free(p2);
-
- p2 = tal_arrz(p1, char, 7);
- ok1(p2);
- ok1(tal_count(p2) == 7);
- ok1(tal_resize(&p2, 0));
- ok1(tal_count(p2) == 0);
- ok1(tal_check(NULL, NULL));
- tal_free(p2);
- tal_free(p1);
+ /* Resize twice. */
+ p2 = tal_arrz(p1, char, 7);
+ ok1(p2);
+ ok1(tal_count(p2) == 7);
+ ok1(tal_check(NULL, NULL));
+ tal_resize(&p2, 20);
+ ok1(p2);
+ ok1(tal_check(NULL, NULL));
+ ok1(tal_count(p2) == 20);
+ /* Tickles non-moving logic, as we do not update bounds. */
+ if (i == 2)
+ move = false;
+ tal_resize(&p2, 300);
+ ok1(p2);
+ ok1(tal_check(NULL, NULL));
+ ok1(tal_count(p2) == 300);
+ ok1(tal_resize(&p2, 0));
+ ok1(tal_count(p2) == 0);
+ ok1(tal_check(NULL, NULL));
+ tal_free(p2);
+ tal_free(p1);
+ }
+ tal_cleanup();
return exit_status();
}
tal_free(parent);
ok1(destroy_count == 4);
+ tal_cleanup();
return exit_status();
}
tal_free(a);
+ tal_cleanup();
return exit_status();
}
tal_free(p);
ok1(errno == EINVAL);
+ tal_cleanup();
return exit_status();
}
/* We can expect some residue from having any child, but limited! */
ok1(num_allocated <= allocated_after_first);
+ tal_free(p);
+ tal_cleanup();
return exit_status();
}
ok1(*p[i] == '1');
tal_free(p[i]);
}
+ tal_cleanup();
return exit_status();
}
ok1(strcmp(tal_name(p), __FILE__ ":29:int[]") == 0);
tal_free(p);
+ tal_cleanup();
return exit_status();
}
tal_free(p);
+ tal_cleanup();
return exit_status();
}
ok1(strcmp(tal_name(p), "int[]") == 0);
tal_free(p);
+ tal_cleanup();
return exit_status();
}
tal_del_notifier(new_ctx, resize_notifier);
tal_free(new_ctx);
+ tal_cleanup();
return exit_status();
}
ok1(error_count == 3);
tal_free(origpi);
+ tal_cleanup();
return exit_status();
}
ok1(tal_parent(p[4]) == p[0]);
tal_free(p[0]);
+ tal_cleanup();
return exit_status();
}
ok1(tal_dup(NULL, char, take(c), 5, 5) == NULL);
ok1(!taken_any());
+ tal_cleanup();
return exit_status();
}
/* Finally, free the parent. */
tal_free(p);
+ tal_cleanup();
return exit_status();
}
}
tal_free(parent);
+ tal_cleanup();
return exit_status();
}
for (i = 1; argv[i]; i++) {
strcpy(ret + len, argv[i]);
len += strlen(argv[i]);
- ret[len++] = ' ';
+ if (argv[i+1])
+ ret[len++] = ' ';
}
strcpy(ret + len, extra);
return ret;
if (argc == 1)
argv = default_args;
- cmd = connect_args(argv, "-o " OUTPUT_FILE " " INPUT_FILE);
+ cmd = connect_args(argv, " -o " OUTPUT_FILE " " INPUT_FILE);
for (i = 0; i < sizeof(tests)/sizeof(tests[0]); i++)
run_test(cmd, &tests[i]);
unlink(OUTPUT_FILE);
unlink(INPUT_FILE);
- cmd[strlen(cmd) - strlen(" -o " OUTPUT_FILE " " INPUT_FILE)] = '\0';
printf("/* Generated by CCAN configurator */\n"
"#ifndef CCAN_CONFIG_H\n"
"#define CCAN_CONFIG_H\n");
printf("#define _GNU_SOURCE /* Always use GNU extensions. */\n");
printf("#endif\n");
printf("#define CCAN_COMPILER \"%s\"\n", argv[1]);
- printf("#define CCAN_CFLAGS \"%s\"\n\n", cmd + strlen(argv[1]) + 1);
+ printf("#define CCAN_CFLAGS \"%s\"\n\n", connect_args(argv+1, ""));
/* This one implies "#include <ccan/..." works, eg. for tdb2.h */
printf("#define HAVE_CCAN 1\n");
for (i = 0; i < sizeof(tests)/sizeof(tests[0]); i++)
projects / ccan / commitdiff