ACE提供的分配器

ACE提供的分配器

ACE提供的分配器大都是在原始的无类型(void)的内存上进行操作，就像C的malloc()一样。这一点和C++库的分配器不一样，C++库的分配器在实例化时使用你提供的类型，并会进行类型检查。

分配器	描述
ACE_New_Allocator	使用new关键字直接从堆中分配内存
ACE_Static_Allocator	预分配一个固定的内存池，然后以优化的从池中分配内存。内存永不释放
ACE_Cacjed_Allocator	固定尺寸的强化类型分配器，它会分配一些强类型化的尺寸固定的内存块
ACE_Duma,oc_Cacjed_Allocator	在程序运行时动态的分配内存块与ACE_Cacjed_Allocator不同，这些块不是强类型化的

代码示例

Allocator.cpp

此示例演示了为ACE_Unbounded_Stack容器指定了一个ACE_Dynamic_Cached_Allocator分配器进行内存管理控制。

// Allocator.cpp,v 1.2 2004/01/02 23:12:18 shuston Exp

#include "ace/Containers.h"

#include "ace/Malloc_T.h"

#include "ace/Synch.h" // Needed for the lock.

#include "DataElement.h"

class StackExample

{

public:

  // Illustrate all the differnet

  // types of stacks provided by ACE.

  int run (void);

private:

  // Illustrate the use of an unbounded stack.

  int runUnboundedStack (ACE_Allocator* allocator);

};

// Listing 1 code/ch05

int StackExample::run (void)

{

  ACE_TRACE (ACE_TEXT ("StackUser::run"));

  ACE_Allocator *allocator = 0;

  //通过分配器分配一块内存空间，堆栈是动态链接栈需要分配器为数据元素动态分配存储空间

  size_t block_size = sizeof(ACE_Node<DataElement>);

  ACE_NEW_RETURN

    (allocator,

     ACE_Dynamic_Cached_Allocator<ACE_Null_Mutex>

       (100 + 1, block_size),

     -1);

  ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("/n# of live objects %d/n"),

              DataElement::numOfActiveObjects ()));

  ACE_ASSERT (this->runUnboundedStack (allocator) != -1);

  ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("/n# of live objects %d/n"),

              DataElement::numOfActiveObjects ()));

  delete allocator;

  return 0;

}

// Listing 1

// Listing 2 code/ch05

int StackExample::runUnboundedStack (ACE_Allocator* allocator)

{

  ACE_TRACE (ACE_TEXT ("StackExample::runUnboundedStack"));

  // Pass in an allocator during construction.

  ACE_Unbounded_Stack<DataElement> ustack (allocator);

  for (int m = 0; m < 100; m++)

    {

      DataElement elem (m);

      int result = ustack.push (elem);

      if (result == -1)

        ACE_ERROR_RETURN

          ((LM_ERROR, ACE_TEXT ("%p/n"),

            ACE_TEXT ("Push Next Element")),

           -1);

    }

  ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("/n# of live objects %d/n"),

              DataElement::numOfActiveObjects ()));

  void* furtherMemory = 0;

  furtherMemory = allocator->malloc

    (sizeof(ACE_Node<DataElement>));

  //分配器分配的内存已经用完，没有空闲内存了

  ACE_ASSERT (furtherMemory == 0);

  // No memory left..

  ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("%p/n"),

              ACE_TEXT ("No memory..")));

  // Free up some memory in the allocator.

  DataElement e;

  for (int n = 0; n < 10; n++)

    {

      ustack.pop (e);

    }

  ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("/n# of live objects %d/n"),

              DataElement::numOfActiveObjects ()));

  //出栈以后释放部分内存，又可以分配新的内存

  furtherMemory =

    allocator->malloc (sizeof (ACE_Node<DataElement>));

  ACE_ASSERT (furtherMemory != 0);

  return 0;

}

// Listing 2

int ACE_TMAIN (int, ACE_TCHAR *[])

{

  StackExample se;

  return se.run ();

}

#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)

template class ACE_Dynamic_Cached_Allocator<ACE_Null_Mutex>;

template class ACE_Unbounded_Stack<DataElement>;

template class ACE_Node<DataElement>;

template class ACE_Cached_Mem_Pool_Node<char>;

template class ACE_Free_List<ACE_Cached_Mem_Pool_Node<char> >;

template class ACE_Locked_Free_List<ACE_Cached_Mem_Pool_Node<char>,ACE_Null_Mutex>;

#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)

#pragma instantiate ACE_Dynamic_Cached_Allocator<ACE_Null_Mutex>

#pragma instantiate ACE_Unbounded_Stack<DataElement>

#pragma instantiate ACE_Node<DataElement>

#pragma instantiate ACE_Cached_Mem_Pool_Node<char>

#pragma instantiate ACE_Free_List<ACE_Cached_Mem_Pool_Node<char> >

#pragma instantiate ACE_Locked_Free_List<ACE_Cached_Mem_Pool_Node<char>,ACE_Null_Mutex>

#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION*/

演示结果

D:/project/ACE_wrappers/examples/APG/Containers>Allocator

# of live objects 0

# of live objects 101

No memory..: No error

# of live objects 92

# of live objects 0

¹⁾ 大多数队列的实现都是只允许从队列的尾部插入数据