// What the allocation tracker is for: a linked list of N nodes built and // torn down, beside one of each other way to allocate. #include #include #include struct node { struct node *next; long value; }; int main(int argc, char **argv) { long n = argc > 1 ? atol(argv[1]) : 100; struct node *head = NULL; for (long i = 0; i < n; i++) { struct node *node = malloc(sizeof *node); node->value = i; node->next = head; head = node; } // A vector that grows: realloc in place and realloc that moves. size_t cap = 4, len = 0; long *values = calloc(cap, sizeof *values); for (struct node *node = head; node; node = node->next) { if (len == cap) values = realloc(values, (cap *= 2) * sizeof *values); values[len++] = node->value; } void *aligned = NULL; if (posix_memalign(&aligned, 64, 100)) return 1; void *page = aligned_alloc(4096, 4096); memset(page, 1, 4096); // Read through a volatile pointer: at -O1 the compiler otherwise knows // the answer and deletes the allocation it came from. volatile char *probe = page; long sum = probe[100] - 1; while (head) { struct node *node = head; head = node->next; sum += node->value; free(node); } free(values); free(aligned); free(page); printf("sum %ld of %zu\n", sum, len); return 0; }