#include "ace/Malloc.h"

//A chunk of size 1K is created. In our case we decided to use a simple array

//as the type for the chunk. Instead of this we could use any struct or class

//that we think is appropriate.

typedef char MEMORY_BLOCK[1024];

//Create an ACE_Cached_Allocator which is passed in the type of the

//“chunk” that it must pre-allocate and assign on the free list.

// Since the Cached_Allocator is a template class we can pretty much

//pass it ANY type we think is appropriate to be a memory block.

typedef ACE_Cached_Allocator<MEMORY_BLOCK,ACE_SYNCH_MUTEX> Allocator;

{

public:

//The constructor is passed the number of chunks that the allocator

//should pre-allocate and maintain on its free list.

allocator_(n_blocks),message_count_(0)

{

mesg_array_=new char*[n_blocks];

}

//Allocate memory for a message using the Allocator. Remember the message

//in an array and then increase the message count of valid messages

//on the message array.

{

mesg_array_[message_count_]=allocator_.malloc(ACE_OS::strlen(msg)+1);

ACE_OS::strcpy(mesg_array_[message_count_],msg);

message_count_++;

}

//Free all the memory that was allocated. This will cause the chunks

//to be returned to the allocator’s internal free list

//and NOT to the OS.

{

for(int i=0;i<message_count_;i++)

allocator_.free(mesg_array_[i]);

　

message_count_=0;

}

//Just show all the currently allocated messages in the message array.

{

for(int i=0;i<message_count_;i++)

ACE_OS::printf("%s\n",mesg_array_[i]);

}

private:

char **mesg_array_;

Allocator allocator_;

int message_count_;

};

{

if(argc<2)

{

ACE_DEBUG((LM_DEBUG, "Usage: %s <Number of blocks>\n", argv[0]));

exit(1);

}

int n_blocks=ACE_OS::atoi(argv[1]);

//Instantiate the Memory Manager class and pass in the number of blocks

//you want on the internal free list.

MessageManager mm(n_blocks);

//Use the Memory Manager class to assign messages and free them.

//Run this in your favorite debug environment and you will notice that the

//amount of memory your program uses after Memory Manager has been

//instantiated remains the same. That means the Cached Allocator

//controls or manages all the memory for the application.

//Do forever.

while(1)

{

//allocate the messages somewhere

ACE_DEBUG((LM_DEBUG,"\n\n\nAllocating Messages\n"));

for(int i=0; i<n_blocks;i++){

ACE_OS::sprintf(message,"Message %d: Hi There",i);

mm.allocate_msg(message);

}

　

//show the messages

ACE_DEBUG((LM_DEBUG,"Displaying the messages\n"));

ACE_OS::sleep(2);

mm.display_all_msg();

　

//free up the memory for the messages.

ACE_DEBUG((LM_DEBUG,"Releasing Messages\n"));

ACE_OS::sleep(2);

mm.free_all_msg();

}

return 0;

}

这个简单的例子包含了一个消息管理器，它对缓存式分配器进行实例化。该分配器随即用于无休止地分配、显示和释放消息。但是，该应用的内存使用并没有变化。你可以通过你喜欢的调试工具来检查这一点。

#include "ace/Shared_Memory_MM.h"

#include "ace/Malloc.h"

#include "ace/Malloc_T.h"

#define DATA_SIZE 100

#define MESSAGE1 "Hiya over there client process"

#define MESSAGE2 "Did you hear me the first time?"

LPCTSTR poolname="My_Pool";

typedef ACE_Malloc<ACE_SHARED_MEMORY_POOL,ACE_Null_Mutex> Malloc_Allocator;

static void server (void)

{

//Create the memory allocator passing it the shared memory

//pool that you want to use

Malloc_Allocator shm_allocator(poolname);

//Create a message, allocate memory for it and bind it with

//a name so that the client can the find it in the memory

//pool

char* Message1=(char*)shm_allocator.malloc(strlen(MESSAGE1));

ACE_OS::strcpy(Message1,MESSAGE1);

shm_allocator.bind("FirstMessage",Message1);

ACE_DEBUG((LM_DEBUG,"<<%s\n",Message1));

//How about a second message

char* Message2=(char*)shm_allocator.malloc(strlen(MESSAGE2));

ACE_OS::strcpy(Message2,MESSAGE2);

shm_allocator.bind("SecondMessage",Message2);

ACE_DEBUG((LM_DEBUG,"<<%s\n",Message2));

//Set the Server to go to sleep for a while so that the client has

//a chance to do its stuff

ACE_DEBUG((LM_DEBUG,

"Server done writing.. going to sleep zzz..\n\n\n"));

ACE_OS::sleep(2);

//Get rid of all resources allocated by the server. In other

//words get rid of the shared memory pool that had been

//previously allocated

shm_allocator.remove();

}

static void client(void)

{

//Create a memory allocator. Be sure that the client passes

// in the "right" name here so that both the client and the

//server use the same memory pool. We wouldn’t want them to

// BOTH create different underlying pools.

Malloc_Allocator shm_allocator(poolname);

//Get that first message. Notice that the find is looking up the

//memory based on the "name" that was bound to it by the server.

void *Message1;

if(shm_allocator.find("FirstMessage",Message1)==-1)

{

ACE_ERROR((LM_ERROR,

"Client: Problem cant find data that server has sent\n"));

ACE_OS::exit(1);

}

ACE_OS::printf(">>%s\n",(char*) Message1);

ACE_OS::fflush(stdout);

//Lets get that second message now.

void *Message2;

if(shm_allocator.find("SecondMessage",Message2)==-1)

{

ACE_ERROR((LM_ERROR,

"Client: Problem cant find data that server has sent\n"));

ACE_OS::exit(1);

}

ACE_OS::printf(">>%s\n",(char*)Message2);

ACE_OS::fflush(stdout);

ACE_DEBUG((LM_DEBUG,"Client done reading! BYE NOW\n"));

ACE_OS::fflush(stdout);

}

int main (int, char *[])

{

switch (ACE_OS::fork ())

{

case -1:

ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "fork"), 1);

　

case 0:

// Make sure the server starts up first.

ACE_OS::sleep (1);

client ();

break;

　

default:

server ();

break;

}

return 0;

}

typedef ACE_Allocator_Adapter<ACE_Malloc<ACE_SHARED_MEMORY_POOL,ACE_Null_Mutex>> Allocator;