自定义分配器的帐户内存使用情况

Question

我正在使用自定义分配器来计算几个容器中的内存使用情况.目前我使用静态变量来计算内存使用量.如何在不必重写分配器以使用不同的静态变量的情况下将此帐户分隔到多个容器中？

---

static size_t allocated = 0;


   template <class T>
   class accounting_allocator {
     public:
       // type definitions
       typedef T        value_type;
       typedef T*       pointer;
       typedef const T* const_pointer;
       typedef T&       reference;
       typedef const T& const_reference;
       typedef std::size_t    size_type;
       typedef std::ptrdiff_t difference_type;
       //static size_t allocated;

       // rebind allocator to type U
       template <class U>
       struct rebind {
           typedef accounting_allocator<U> other;
       };

       // return address of values
       pointer address (reference value) const {
           return &value;
       }
       const_pointer address (const_reference value) const {
           return &value;
       }

       /* constructors and destructor
        * - nothing to do because the allocator has no state
        */
       accounting_allocator() throw() {
       }
       accounting_allocator(const accounting_allocator&) throw() {
       }
       template <class U>
         accounting_allocator (const accounting_allocator<U>&) throw() {
       }
       ~accounting_allocator() throw() {
       }

       // return maximum number of elements that can be allocated
       size_type max_size () const throw() {
        //  std::cout << "max_size()" << std::endl;
           return std::numeric_limits<std::size_t>::max() / sizeof(T);
       }

       // allocate but don't initialize num elements of type T
       pointer allocate (size_type num, const void* = 0) {
           // print message and allocate memory with global new
           //std::cerr << "allocate " << num << " element(s)" << " of size " << sizeof(T) << std::endl;
           pointer ret = (pointer)(::operator new(num*sizeof(T)));
           //std::cerr << " allocated at: " << (void*)ret << std::endl;
           allocated += num * sizeof(T);
            //std::cerr << "allocated: " << allocated/(1024*1024) << " MB" << endl;
           return ret;
       }

       // initialize elements of allocated storage p with value value
       void construct (pointer p, const T& value) {
           // initialize memory with placement new
           new((void*)p)T(value);
      }

       // destroy elements of initialized storage p
       void destroy (pointer p) {
           // destroy objects by calling their destructor
           p->~T();
       }

       // deallocate storage p of deleted elements
       void deallocate (pointer p, size_type num) {
           // print message and deallocate memory with global delete
#if 0
           std::cerr << "deallocate " << num << " element(s)"
                     << " of size " << sizeof(T)
                     << " at: " << (void*)p << std::endl;
#endif
           ::operator delete((void*)p);
           allocated -= num * sizeof(T);
       }
   };
  template<>
    class accounting_allocator<void>
    {
    public:
      typedef size_t      size_type;
      typedef ptrdiff_t   difference_type;
      typedef void*       pointer;
      typedef const void* const_pointer;
      typedef void        value_type;

      template<typename _Tp1>
        struct rebind
        { typedef allocator<_Tp1> other; };
    };


   // return that all specializations of this allocator are interchangeable
   template <class T1, class T2>
   bool operator== (const accounting_allocator<T1>&,
                    const accounting_allocator<T2>&) throw() {
       return true;
   }
   template <class T1, class T2>
   bool operator!= (const accounting_allocator<T1>&,
                    const accounting_allocator<T2>&) throw() {
       return false;
   }

Answer 1

如果您想要为每个容器类型设置一个单独的计数器,您可以简单地将容器类型包括为模板参数并取消注释,static size_t allocated这样它就是一个静态成员变量.这样,将为每种类型的容器生成单独的计数器变量.

如果您说要为容器的每个实例创建单独的计数器,则需要创建size_t allocated非静态成员变量.问题是,你还需要某种钩子,这样你就可以从每个容器外部访问分配计数器.STL分配器设计使得这很难做到.某些STL容器有一个构造函数,允许您传递分配器的实例,但并非所有容器都支持此.在支持此功能的容器上,您可以在allocator类中包含对某些全局映射的引用,然后将分配器的实例传递给每个容器的构造函数.然后,当您调用时accounting_allocator::allocate(),分配器将记录它在全局映射中分配的字节数.但是,我无法看到如何轻松地将此信息与特定容器实例相关联,因为allocator对象不知道它属于哪个容器.

老实说,如果你只是收集调试信息,它可能更容易只限定非静态的size_t allocated,并有accounting_allocator::allocate()简单的输出统计到文件或stdout.或者,考虑使用内存分析器工具为您开发的平台.

Answer 2

将“static size_t allocate”的声明放入类定义中。每个模板实例都会有一个单独的计数器，该计数器在该模板的所有对象之间共享。