我正在寻找一种方法来跟踪我程序的一部分内存消耗。我在实际用例中尝试实现的是编写具有大小上限的缓存类。由于缓存数据是一些嵌套类的相当复杂的层次结构,因此向所有这些类添加getSize()
方法应该是可能的,但在性能方面可能是一个糟糕的选择。到目前为止,我的方法是尝试为缓存的类使用自定义分配器。虽然这也不是一个过于优雅的解决方案,但它可以正确跟踪已用内存。但是它还要求对模板进行模板化,这会破坏与非高速缓存实例的兼容性。考虑:
std::string foo;
std::basic_string<char, std::char_traits<char>, MyAllocator<char> > bar( "text" );
foo = bar; // this will not work
将数据重组为一些可能更适合缓存机制的布局(假设某些数组)可能也不是一个好的选择,因为它需要(除了重写大多数代码之外)其他步骤来组装从缓存请求时再次出现数据,这意味着缓存会降低性能。
我会很感激任何建议,并期待了解你对此的看法。
#include <string>
namespace
{
template <class T>
class CountAlloc : public MemUsage
{
public:
typedef size_t size_type;
typedef T value_type;
CountAlloc(){}
T* allocate( size_t n, const void* = 0 )
{
n *= sizeof( T );
sum() += n;
std::cout << "+ " << n << " = " << sum() << std::endl;
return static_cast<T*>(::operator new(n));
}
void deallocate( T* const p, std::size_t const n )
{
if( p )
{
sum() -= n * sizeof( T );
::operator delete(p);
std::cout << "- " << n * sizeof( T ) << " = " << sum() << std::endl;
}
}
T* address( T& x ) const { return &x; }
T const* address( T const& x ) const { return &x; }
CountAlloc<T>& operator=( const CountAlloc& ) { return *this; }
void construct( T* p, const T& val ) { new ((T*)p) T( val ); }
void destroy( T* p ) { p->~T(); }
size_type max_size() const { return size_t( -1 ); }
template <class U>
struct rebind
{
typedef CountAlloc<U> other;
};
template <class U>
CountAlloc( const CountAlloc<U>& other )
{
}
template <class U>
CountAlloc<T>& operator=( CountAlloc<U> const& other )
{
return *this;
}
};
}
int main( int argc, char *argv[] )
{
std::string foo;
std::basic_string<char, std::char_traits<char>, CountAlloc<char> > bar( "text" );
foo = bar; // this is not working
}