一个测试ACE各种内存分配策略效率的程序

在256M内存的redhat9虚拟机上运行申请释放10000000，每次大小为1k，结果如下： testmalloc loop 10000 use time 32.950000 s

testcached loop 10000 use time 1.730000 s

testmallocmmap loop 10000 use time 5.050000 s

testmallocmmaplite loop 10000 use time 5.030000 s

testmalloclocal loop 10000 use time 0.620000 s

testmalloclocalmutex loop 10000 use time 4.250000 s

testmalloc_brk_mutex loop 10000 use time 0.600000 s

testmallocsharemutex loop 10000 use time 4.360000 s     #include "ace/OS_NS_stdio.h"

#include "ace/OS_NS_string.h"

#include "ace/Malloc_T.h"

#include "ace/Null_Mutex.h" #include "time.h"

#include "assert.h"   clock_t _begin;

clock_t _end;

int _loop;

#define BEGIN(n) /

    _begin = clock(); /

    for (_loop = 0; _loop < n; _loop++) {   #define END(s) /

    }          /

    _end = clock(); /

    printf("%s loop %d use time %lf s/n", s, _loop ,  (double)(_end - _begin) / (double)CLOCKS_PER_SEC);   const int MAXSIZE = 1024;   void *p[1000];

void testmalloc()

{

    int i = 0;

    for (i = 0; i < 1000; i++)

    {

        p[i] = malloc(MAXSIZE);

        assert(p[i] != NULL);

    }

    for (i = 0; i < 1000; i++)

    {

        free(p[i]);

    }

}   typedef char BLOCK[MAXSIZE];

typedef ACE_Dynamic_Cached_Allocator<ACE_SYNCH_NULL_MUTEX> Allocator;   Allocator cache(1000, MAXSIZE);

void testcached()

{

    int i = 0;

    for (i = 0; i < 1000; i++)

    {

        p[i] = cache.malloc(MAXSIZE);

        assert(p[i] != NULL);

    }

    for (i = 0; i < 1000; i++)

    {

         cache.free(p[i]);

    }

}   typedef ACE_Malloc<ACE_MMAP_MEMORY_POOL, ACE_SYNCH_MUTEX> malloc_mmap;

typedef ACE_Malloc<ACE_LOCAL_MEMORY_POOL, ACE_SYNCH_NULL_MUTEX> malloc_local;

typedef ACE_Malloc<ACE_LOCAL_MEMORY_POOL, ACE_SYNCH_MUTEX> malloc_local_mutex;

typedef ACE_Malloc<ACE_SHARED_MEMORY_POOL, ACE_SYNCH_MUTEX> malloc_share_mutex;

typedef ACE_Malloc<ACE_SBRK_MEMORY_POOL, ACE_SYNCH_MUTEX> malloc_sbrk_mutex;

typedef ACE_Malloc<ACE_LITE_MMAP_MEMORY_POOL, ACE_SYNCH_MUTEX> malloc_mmap_lite;   template<class T>

void testmalloc(T &ml)

{

    int i = 0;

    for (i = 0; i < 1000; i++)

    {

        p[i] = ml.malloc(MAXSIZE);

        assert(p[i] != NULL);                                                                   

    }

    for (i = 0; i < 1000; i++)

    {

         ml.free(p[i]);

         p[i] = NULL;

    }

}   int main(int argc,char* argv[])

{       BEGIN(10000)

        testmalloc();

    END("testmalloc")       BEGIN(10000)

        testcached();

    END("testcached")       ACE_MMAP_Memory_Pool_Options options(ACE_DEFAULT_BASE_ADDR, ACE_MMAP_Memory_Pool_Options::ALWAYS_FIXED, 1024 * 10000 );

    malloc_mmap mm("hello", "hello", &options);

    //fprintf(stderr, "%d chuncks/n", ml.avail_chunks(MAXSIZE));

    BEGIN(10000)

        testmalloc(mm);

    END("testmallocmmap")

    mm.remove();        malloc_mmap_lite mml("helloq", "helloq", &options);

    //fprintf(stderr, "%d chuncks/n", ml.avail_chunks(MAXSIZE));

    BEGIN(10000)

        testmalloc(mml);

    END("testmallocmmaplite")

    mml.remove();       malloc_local ml("hello1");

    //fprintf(stderr, "%d chuncks/n", ml.avail_chunks(MAXSIZE));

    BEGIN(10000)

        testmalloc(ml);

    END("testmalloclocal")

    ml.remove();       malloc_local_mutex mlm("hello2");

    //fprintf(stderr, "%d chuncks/n", ml.avail_chunks(MAXSIZE));

    BEGIN(10000)

        testmalloc(mlm);

    END("testmalloclocalmutex")

    mlm.remove();       malloc_local mlb("hellob");

    //fprintf(stderr, "%d chuncks/n", ml.avail_chunks(MAXSIZE));

    BEGIN(10000)

        testmalloc(mlb);

    END("testmalloc_brk_mutex")

    mlb.remove();

    ACE_Shared_Memory_Pool_Options options2(ACE_DEFAULT_BASE_ADDR, 1, ACE_DEFAULT_FILE_PERMS, 1,  1024 * 1200 );

    malloc_share_mutex msm("hello3", "hello3",&options2);

    BEGIN(10000)

        testmalloc(msm);

    END("testmallocsharemutex")

    msm.remove();

    return 0;

}