Ответ 1
Во-первых, мы должны знать основную идею библиотеки Boost Pool: simple_segregated_storage, она похожа на односвязный список и отвечает за разделение блока памяти на блоки фиксированного размера:
Пул памяти содержит свободный список фрагментов памяти. Таким образом, мы упоминали блоки и фрагменты: пул памяти использует new или malloc для выделения блока памяти и делит его на многие куски памяти, которые имеют одинаковый размер.
Предположим, что адрес выровнен на 8,4 байта для хранения адреса следующего фрагмента, так что блок памяти (8 байт * 32 фрагмента) выглядит следующим образом (адрес памяти предназначен только для иллюстрации вопроса, а не для реального): < ш > 
Теперь предположим, что пользователь дважды выделяет 8-байтную память, поэтому используются куски: [0xDD00,0xDD08], [0xDD08,0xDD10). Через некоторое время пользователь освобождает память на [0xDD00,0xDD08), поэтому этот кусок вернется в свободный список. Теперь блок выглядит следующим образом:
После этого пользователь освобождает память в [0xDD08,0xDD10), самый простой способ разместить этот фрагмент в списке - это обновить first, чтобы указать на него, постоянную временную сложность. simple_segregated_storage<T>::free() делает это точно:
void free BOOST_PREVENT_MACRO_SUBSTITUTION(void * const chunk)
{ //! Free a chunk.
//! \pre chunk was previously returned from a malloc() referring to the same free list.
//! \post !empty()
BOOST_POOL_VALIDATE_INTERNALS
nextof(chunk) = first;
first = chunk;
BOOST_POOL_VALIDATE_INTERNALS
}
После этого список будет выглядеть следующим образом: 
Теперь мы заметили, что список блоков не упорядочен по их адресу после этих операций!
Если мы хотим сохранить порядок при выделении, вызовите pool<>::ordered_free() вместо pool<>::free(), чтобы вернуть память в список в правильном порядке. Теперь мы знаем, какой порядок в пуле памяти, оставьте в исходном коде boost::pool<>::malloc и boost::pool<>::ordered_malloc:
void * malloc BOOST_PREVENT_MACRO_SUBSTITUTION()
{
if (!store().empty())
return (store().malloc)();
return malloc_need_resize();
}
void * ordered_malloc()
{
if (!store().empty())
return (store().malloc)();
return ordered_malloc_need_resize();
}
Как мы видим, они отличаются только тогда, когда в списке блоков памяти нет свободного фрагмента. В этом случае он выделяет новый блок памяти, объединяет его свободный список с пустым списком, разница между этими двумя методами заключается в том, что boost::pool<>::ordered_malloc сохраняет порядок при объединении свободных списков.
Выше приведено вопрос 1.
Итак, почему вопрос порядка? Кажется, что пул памяти отлично работает с неупорядоченными кусками!
Во-первых, если мы хотим найти непрерывную последовательность n кусков, упорядоченный бесплатный список упростит его. Во-вторых, давайте посмотрим на производный класс boost::pool: boost::object_pool, он обеспечивает автоматическое уничтожение нераспределенных объектов при уничтожении объекта object_pool, в то время как вы также можете уничтожить объект вручную, например:
class X { … };
void func()
{
boost::object_pool<X> alloc;
X* obj1 = alloc.construct();
X* obj2 = alloc.construct();
alloc.destroy(obj2);
}
приведенный выше код в порядке, утечка памяти или двойное удаление! Как boost::object_pool делает эту магию? Давайте найдем реализацию деструктора boost::object_pool (у меня на компьютере повышена скорость 1.48):
template <typename T, typename UserAllocator>
object_pool<T, UserAllocator>::~object_pool()
{
#ifndef BOOST_POOL_VALGRIND
// handle trivial case of invalid list.
if (!this->list.valid())
return;
details::PODptr<size_type> iter = this->list;
details::PODptr<size_type> next = iter;
// Start 'freed_iter' at beginning of free list
void * freed_iter = this->first;
const size_type partition_size = this->alloc_size();
do
{
// increment next
next = next.next();
// delete all contained objects that aren't freed.
// Iterate 'i' through all chunks in the memory block.
for (char * i = iter.begin(); i != iter.end(); i += partition_size)
{
// If this chunk is free,
if (i == freed_iter)
{
// Increment freed_iter to point to next in free list.
freed_iter = nextof(freed_iter);
// Continue searching chunks in the memory block.
continue;
}
// This chunk is not free (allocated), so call its destructor,
static_cast<T *>(static_cast<void *>(i))->~T();
// and continue searching chunks in the memory block.
}
// free storage.
(UserAllocator::free)(iter.begin());
// increment iter.
iter = next;
} while (iter.valid());
// Make the block list empty so that the inherited destructor doesn't try to
// free it again.
this->list.invalidate();
#else
// destruct all used elements:
for(std::set<void*>::iterator pos = this->used_list.begin(); pos != this->used_list.end(); ++pos)
{
static_cast<T*>(*pos)->~T();
}
// base class will actually free the memory...
#endif
}
он проходит через все куски в списке блоков памяти (list, член данных boost::pool<>, содержит местоположения и размеры всех блоков памяти, выделенных из системы), чтобы определить, содержит ли какой-либо фрагмент в нем показывает в свободном списке, если нет, вызывает деструктор объекта, а затем освобождает память. Так что это получение пересечения двух наборов, так же как std:: set_intersection()! Если список отсортирован, было бы намного быстрее сделать это. Фактически в boost::object_pool<> требуется порядок, открытый член выполняет функции: boost::object_pool<>::malloc() и boost::object_pool<>::free() просто вызывает boost::pool<>::ordered_malloc() и boost::pool<>::ordered_free() соответственно:
element_type * malloc BOOST_PREVENT_MACRO_SUBSTITUTION()
{ //! Allocates memory that can hold one object of type ElementType.
//!
//! If out of memory, returns 0.
//!
//! Amortized O(1).
return static_cast<element_type *>(store().ordered_malloc());
}
void free BOOST_PREVENT_MACRO_SUBSTITUTION(element_type * const chunk)
{ //! De-Allocates memory that holds a chunk of type ElementType.
//!
//! Note that p may not be 0.\n
//!
//! Note that the destructor for p is not called. O(N).
store().ordered_free(chunk);
}
Итак, для queston 2: В большинстве ситуаций вам не нужно использовать boost::pool<>::ordered_malloc.