On Mon, Dec 14, 2009 at 09:58:19AM +0100, Otto Moerbeek wrote:
> On Wed, Dec 02, 2009 at 10:38:10AM +0100, Otto Moerbeek wrote:
> > [A]part from the random page addresses obtained form mmap(2) malloc(3)
> > itself also randomizes cache en chunk operations. It uses a nibble of
> > randomness per call, so optimize that to not waste half the random
> > bits. 
> > 
> > Please test, should be a bit faster.
> 
> Anybody?

I just built a recent checkout with and without this patch included. It
seems to be stable. Somewhat to my surprise, it also seems to be
measurably faster on my system.

Without patch:
$ gcc -Wall -O2 -DNDEBUG -o malloc-test malloc-test.c && time ./malloc-test && 
time ./malloc-test && time ./malloc-test && time ./malloc-test && time 
./malloc-test && time ./malloc-test
    0m32.11s real     0m28.88s user     0m2.60s system
    0m32.05s real     0m28.22s user     0m3.17s system
    0m44.20s real     0m40.11s user     0m3.36s system
    0m32.25s real     0m28.52s user     0m3.40s system
    0m31.57s real     0m28.41s user     0m3.02s system
    0m31.74s real     0m28.36s user     0m2.98s system

With patch:
$ gcc -Wall -O2 -DNDEBUG -o malloc-test malloc-test.c && time ./malloc-test && 
time ./malloc-test && time ./malloc-test && time ./malloc-test && time 
./malloc-test && time ./malloc-test
    0m32.11s real     0m28.88s user     0m2.60s system
    0m29.64s real     0m26.39s user     0m3.21s system
    0m29.32s real     0m26.21s user     0m3.05s system
    0m29.31s real     0m25.89s user     0m3.35s system
    0m29.57s real     0m26.51s user     0m3.01s system
    0m29.56s real     0m26.44s user     0m3.10s system
    0m29.50s real     0m26.06s user     0m3.36s system

The program I used to test this is very much ad-hoc, does not use memory
in a realistic fashion, etc, so this is not a proper (hah!) benchmark.
But having some numbers may be better than nothing.

malloc-test.c:
#include <assert.h>
#include <err.h>
#include <stdlib.h>

int
main(void)
{
        void    *p[8][16 * 1024];
        int      i, j, k, l;

        for (l = 0; l < 512; l++) {
                for (i = 0; i < sizeof(p) / sizeof(*p); i++) {
                        for (j = 0; j < sizeof(p[i]) / sizeof(*p[i]); j++)
                                if ((p[i][j] = malloc(1 << i)) == NULL)
                                        err(1, "malloc() failed");

                        for (k = i; k >= 0; k--) {
                                for (j = i; j < sizeof(p[i]) / sizeof(*p[i]); j 
+= sizeof(p) / sizeof(*p)) {
                                        assert(p[k][j] != NULL);
                                        free(p[k][j]);
                                        p[k][j] = NULL;
                                }
                        }
                }

                for (i = 0; i < sizeof(p) / sizeof(*p); i++)
                        for (j = 0; j < sizeof(p[i]) / sizeof(*p[i]); j++)
                                free(p[i][j]);
        }

        return 0;
}

For completeness, a dmesg may be found at
http://www.joachimschipper.nl/posts/20091215/dmesg.

Should anyone care, the program above may be used for any purpose
whatsoever, with or without attribution ("public domain").

                Joachim

Reply via email to