memory allocation again...

On May 8, 2007, at 10:04 AM, Mark Pauley wrote:

> Has the cycling team done any perf analysis of getbytes vs.
> malloc? OSX's malloc routine has a staggered / pooled allocation
> strategy as well, eventually degenerating into vm_alloc as the
> allocated chunks approach 4k (the system page size).

Good point. A quick test on my MBP shows that usually malloc is
faster or approximately the same. Here's the results for the code
snippet at bottom with various fixed sizes. Seems like it's about 2-3
times faster when quickly reallocating/deallocating the same size
over and over again, and then a bit of a toss up when growing the
memory pool or allocating random memory sizes.

ITERATION COUNT: 100000; ALLOC SIZE(BYTES): 16
POOL REUSE
getbytes: 22.827000 ms
malloc: 11.202000 ms
POOL GROW
getbytes: 30.482000 ms
malloc: 34.919000 ms
POOL RANDOM
getbytes: 25.689000 ms
malloc: 12.784000 ms

ITERATION COUNT: 100000; ALLOC SIZE(BYTES): 128
POOL REUSE
getbytes: 22.871000 ms
malloc: 10.882000 ms
POOL GROW
getbytes: 65.705000 ms
malloc: 60.475000 ms
POOL RANDOM
getbytes: 30.505000 ms
malloc: 35.556000 ms

ITERATION COUNT: 100000; ALLOC SIZE(BYTES): 1024
POOL REUSE
getbytes: 24.227000 ms
malloc: 8.754000 ms
POOL GROW
getbytes: 258.164000 ms
malloc: 225.734000 ms
POOL RANDOM
getbytes: 26.731000 ms
malloc: 22.175000 ms

> I'm just wondering if this isn't a bit like double-caching. In any
> event, it's probably useful to have an allocation interface that
> more or less works uniformly across platforms.

Yes. Most of this is legacy based on NewPtr not being accessible in
interrupt. We could probably change to use the malloc pool in all
cases, or tune some of the bottlenecks in our mem pool
implementation. However, as hinted in the last message, optimization
of things which aren't the bottleneck isn't usually the best use of
one's time. Will try to shark it and tune a bit before Max 5 release,
though.

-Joshua

# define A_BIG_NUMBER        100000
# define A_SMALL_NUMBER        16
    // malloc test
    {
        long i,count;
        char *p;
        char *q[A_BIG_NUMBER];
        double start,end;

        cpost ("ITERATION COUNT: %d; ALLOC SIZE(BYTES): %dn",
A_BIG_NUMBER, A_SMALL_NUMBER);
        cpost("POOL REUSE n");
        start = mactimer_gettime();
        for (i=0;i
            p = getbytes(A_SMALL_NUMBER);
            freebytes(p,A_SMALL_NUMBER);
        }
        end = mactimer_gettime();
        cpost("getbytes: %f msn",end-start);

        start = mactimer_gettime();
        for (i=0;i
            p = (char *)malloc(A_SMALL_NUMBER);
            free(p);
        }
        end = mactimer_gettime();
        cpost("malloc: %f msn",end-start);

        cpost("POOL GROW n");
        start = mactimer_gettime();
        for (i=0;i
            q[i] = getbytes(A_SMALL_NUMBER);
        for (i=0;i
            freebytes(q[i],A_SMALL_NUMBER);
        end = mactimer_gettime();
        cpost("getbytes: %f msn",end-start);

        start = mactimer_gettime();
        for (i=0;i
            q[i] = (char *)malloc(A_SMALL_NUMBER);
        for (i=0;i
            free(q[i]);
        end = mactimer_gettime();
        cpost("malloc: %f msn",end-start);

        cpost("POOL RANDOM n");
        start = mactimer_gettime();
        for (i=0;i
            count = (rand()%A_SMALL_NUMBER) + 1;
            p = getbytes(count);
            freebytes(p,count);
        }
        end = mactimer_gettime();
        cpost("getbytes: %f msn",end-start);

        start = mactimer_gettime();
        for (i=0;i
            count = (rand()%A_SMALL_NUMBER) + 1;
            p = (char *)malloc(count);
            free(p);
        }
        end = mactimer_gettime();
        cpost("malloc: %f msn",end-start);

    }