自定义分配器的帐户内存使用情况 [英] Account memory usage with custom allocator
问题描述
我使用自定义分配器来处理多个容器中的内存使用情况。目前我使用静态变量来计算内存使用。如何在多个容器中分离此帐户，而无需重写分配器以使用不同的静态变量？
I'm using a custom allocator to account for memory usage in several containers. Currently I use a static variable to account for the memory usage. How could I separate this account across several containers without having to rewrite the allocator to use different static variables?
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;
}
推荐答案
一个单独的计数器为每个容器类型，你可以简单地包括容器类型作为模板参数，并取消注释 static size_t allocated ，因此它是一个静态成员变量。这样，将为每种类型的容器生成单独的计数器变量。
If you mean that you want a separate counter for each container type, you could simply include the container type as a template parameter and uncomment static size_t allocated so it's a static member variable. This way, a separate counter variable will be generated for each type of container.
如果您想要为容器的每个 实例 创建单独的计数器， size_t allocated 一个非静态成员变量。问题是，你还需要某种钩子，所以你可以从每个容器的外部访问分配计数器。 STL分配器设计使得很难做到这一点。一些STL容器有一个构造函数，允许你传递一个分配器的实例，但并不是所有的容器都支持这个。在支持此操作的容器上，您可以在allocator类中包含对某个全局映射的引用，然后将分配器的实例传递到每个容器的构造函数。然后，当调用 accounting_allocator :: allocate（）时，分配器将记录它在全局映射中分配的字节数。仍然，我不能看到你如何可以轻松地将此信息与特定的容器实例，因为allocator对象不知道它属于哪个容器。
If you're saying you want a separate counter for each instance of a container, you need to make size_t allocated a non-static member variable. The problem is, you'll also need some kind of hook so you can access the allocation counter from outside each container. The STL allocator design makes it difficult to do this. Some STL containers have a constructor that lets you pass an instance of an allocator, but not all containers support this. On containers that support this, you can include a reference to some global map inside your allocator class, and then pass an instance of your allocator to the constructor of each container. Then, when you call accounting_allocator::allocate(), the allocator would record the number of bytes it has allocated in the global map. Still, I can't see how you could easily associate this information with a particular container instance, since the allocator object does not know which container it belongs to.
老实说，如果你只是收集调试信息，可能更容易定义一个非静态 size_t allocated ，并且 accounting_allocator :: allocate（）只需将stats输出到文件或stdout。或者，使用内存分析器工具查看您开发的平台。
Honestly, if you're just collecting debug info, it's probably easier to just define a non static size_t allocated, and have accounting_allocator::allocate() simply output the stats to a file or to stdout. Alternatively, look into using a memory profiler tool for the platform you develop on.
这篇关于自定义分配器的帐户内存使用情况的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！
