Yeah, I usually do. Probably these files were gone from the very beginning (before pushing Head for the first time) , and since I never used dynamic allocation in this project... never noticed.
Now, I made a few new projects. Sometimes the files are gone, sometimes not.
Didn't find the way to always reproduce the problem, it's very random.
The problem now is that it seems I'm having internal fragmentation. Not external. Let me explain:
From malloc.h:
struct mallinfo {
size_t arena; /* total space allocated from system */
size_t ordblks; /* number of non-inuse chunks */
size_t smblks; /* unused -- always zero */
size_t hblks; /* number of mmapped regions */
size_t hblkhd; /* total space in mmapped regions */
size_t usmblks; /* unused -- always zero */
size_t fsmblks; /* unused -- always zero */
size_t uordblks; /* total allocated space */
size_t fordblks; /* total non-inuse space */
size_t keepcost; /* top-most, releasable (via malloc_trim) space */
};
Test:
#include <malloc.h>
struct mallinfo info; // To gather current mem info
uint8_t *a, *b, *c, *d; // Test ptr
a = malloc(8192); // Allocate 8KB
b = malloc(1024); // Allocate 1KB
c = malloc(810); // Allocate 810B
d = malloc(1492); // Allocate 1492B
info = mallinfo(); // arena=11552 , uordblks=11552
free(a);
free(b);
free(c);
free(d);
info = mallinfo(); // arena=11552, fordblks=11552
a = malloc(10240); // Allocate 12KB
info = mallinfo(); // arena=23848, uordblks=12296, fordblks=11552
free(a);
info = mallinfo(); // arena=23848, fordblks=23848
After freeing up all the memory, it will not reuse it if the next allocation is bigger than the total previous.
So it gets fragmented anyway, although the heap is completely free.
After few runs the heap will fail.
After 1st malloc:
Heap: [8192][1024][810][1492] (11552 due alignment, usage variables)
(a) (b) (c) (d)
After free:
Heap: [11552]
(free)
Then, when allocating 12KB, this happens;
Heap: [11552] [12296]
(free) (new alloc)
Instead:
Heap: [12296]
(new alloc)
If the free region is smaller, it works:
a = malloc(106736);
info = mallinfo(); // Total used = 106744
free(a);
a = malloc(100000); // Works
But if you request only 1 byte more, it try to allocate at the end of the free space, and fail:
a = malloc(106736);
info = mallinfo(); // Total used = 106744
free(a);
a = malloc(106745); // Doesn't work
A fix is to first allocate all the heap:
a = malloc(121*1024); // Allocate 121KB (Max heap)
free(a);
// Now any allocation will work and not cause any fragmentation when freed up
