Использование памяти учетной записи с помощью специального распределителя
Я использую пользовательский распределитель для учета использования памяти в нескольких контейнерах. В настоящее время я использую статическую переменную для учета использования памяти. Как можно разделить эту учетную запись на несколько контейнеров, не переписывая распределитель для использования различных статических переменных?
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;
}
4 ответа
Если вы хотите иметь отдельный счетчик для каждого типа контейнера, вы можете просто включить тип контейнера в качестве параметра шаблона и раскомментировать static size_t allocated так что это статическая переменная-член. Таким образом, отдельная переменная счетчика будет сгенерирована для каждого типа контейнера.
Если вы говорите, что хотите отдельный счетчик для каждого экземпляра контейнера, вам нужно сделать size_t allocated нестатическая переменная-член. Проблема в том, что вам также понадобится какой-то хук, чтобы вы могли получить доступ к счетчику распределения снаружи каждого контейнера. Конструкция распределителя STL затрудняет это. Некоторые контейнеры STL имеют конструктор, который позволяет передавать экземпляр распределителя, но не все контейнеры поддерживают это. В контейнерах, которые поддерживают это, вы можете включить ссылку на некоторую глобальную карту в свой класс распределителя, а затем передать экземпляр своего распределителя в конструктор каждого контейнера. Затем, когда вы звоните accounting_allocator::allocate()распределитель запишет количество байтов, выделенных на глобальной карте. Тем не менее, я не вижу, как вы могли бы легко связать эту информацию с конкретным экземпляром контейнера, поскольку объект распределителя не знает, к какому контейнеру он принадлежит.
Честно говоря, если вы просто собираете отладочную информацию, возможно, проще просто определить нестатический size_t allocated, и имеют accounting_allocator::allocate() просто выведите статистику в файл или на стандартный вывод. В качестве альтернативы, обратите внимание на использование инструмента профилирования памяти для платформы, на которой вы разрабатываете.
Смотрите мои примеры кода:
// uintptr_t represents an object address
// as a numerical value.
// you could use unsigned long insead if
// sizeof(long) == sizeof(void*) on your system.
struct AllocCounter {
static size_t *Register(uintptr_t uContainer)
{
// insert container address into map, and
// return an associated allocation counter.
}
static bool Unregister(uintptr_t uContainer)
{
// remove container address and the
// associated allocation counter from the map
}
static void DebugCounter(void)
{
// statistic of all container objects.
}
protected:
static hash_map<uintptr_t, size_t> m_aCounter;
};
Кроме того, вы можете связать имя контейнера или класса объекта и т. Д. Со счетчиком распределения, увеличив выше AllocCounter.
И пример контейнера:
class Container
{
public:
Container(void)
{
m_pAllocCounter = AllocCounter::Register((uintptr_t)this);
....
}
~Container()
{
AllocCounter::Unregister((uintptr_t)this);
}
pointer ObjectAllocate(void)
{
pointer obj;
*m_pAllocCounter += sizeof *obj;
obj = new CObject;
return obj;
}
void ObjectDealloc(pointer pObj)
{
*m_pAllocCounter -= sizeof *pObj;
delete pObj;
}
....
private:
size_t *m_pAllocCounter;
....
};
Поместите объявление "static size_t selected" в определение класса. У каждого экземпляра шаблона будет отдельный счетчик, общий для всех объектов этого шаблона.
Это старый вопрос, но в любом случае, вот решение вашей проблемы. Идея состоит в том, чтобы собирать статистику на основе типа распределителя.
Итак, мы создаем реестр, который сопоставляет тип распределителя со структурой сбора статистики, например:
struct registry
{
struct alloc_track
{
size_t count;
size_t max;
size_t current;
alloc_track() : count(0), max(0), current(0) {}
};
// Not using a STL container here for the key to avoid allocation */
std::unordered_map<const char *, alloc_track> registry;
static registry & get_instance() { static registry a; return a; }
void credit(const char * key, std::size_t count, std::size_t size) {
alloc_track & track = registry[key];
track.count += count;
track.max += size;
track.current += size;
}
void debit(const char * key, std::size_t count, std::size_t size) {
alloc_track & track = registry[key];
track.count -= count;
track.current -= size;
}
void dump() {
// Not using C++ iostream here to avoid triggering the allocator itself
printf("Allocator registry:\n");
for (auto it : registry) {
printf("%s: %lu instances %lu bytes, max usage %lu\n", it.first, it.second.count, it.second.current, it.second.max);
}
}
~registry() {
dump();
}
};
Затем вы подключите реестр к своему распределителю следующим образом:
template <class T>
class accounting_allocator {
[...]
// allocate but don't initialize num elements of type T
pointer allocate (size_type num, const void* = 0) {
pointer ret = (pointer)(::operator new(num*sizeof(T)));
registry::get_instance().credit(typeid(T).name(), num, num * sizeof(T));
return ret;
}
// deallocate storage p of deleted elements
void deallocate (pointer p, size_type num) {
// print message and deallocate memory with global delete
::operator delete((void*)p);
registry::get_instance().debit(typeid(T).name(), num, num * sizeof(T));
}
В любое время, когда вы хотите получить текущую статистику распределения, вы можете вызвать:
registry::get_instance().dump();
Полный код можно найти здесь