Estou tentando usar um boost::pool_allocator
para alocar (eficientemente) std::shared_ptr<T>
. Conceitualmente, quero algo assim:
struct Foo {};
std::shared_ptr<Foo> create() {
static boost::pool_alloator<Foo> alloc;
return std::allocate_shared<Foo>(alloc);
}
Há um problema com este exemplo: boost::pool_allocator<Foo>
é otimizado para alocações de tamanho sizeof(Foo)
(na verdade, estou surpreso que ele suporte alocações de tamanhos diferentes…). Mas std::allocate_shared<Foo>(…)
não aloca sizeof(Foo)
bytes, porque aloca o bloco de controle e a carga útil de uma só vez.
Para usar boost::pool_allocator<…>
with com eficiência std::allocate_shared
, eu precisaria informar pool_allocator
sobre o tamanho das alocações esperadas. Para fazer isso, provavelmente precisaria do tipo que allocate_shared
aloca internamente. Tenho certeza de que para a implementação STL do GCC, esse tipo seria _Sp_counted_ptr_inplace , e para o libc++ do Clang parece que é __shared_ptr_emplace::_Storage - mas usar esses tipos obviamente não seria portátil.
Existe alguma maneira compatível com o padrão de descobrir o tamanho das alocações que std::allocate_shared
serão executadas? Ou alguma outra maneira de usar (eficientemente) um alocador de pool para allocate_shared
?
O alocador é religado ao tipo interno do que quer que esteja alocando e, em vez disso, é usada uma cópia do alocador com o tipo apropriado.
pool_allocator<Foo>
é um pouco enganador, pois se refere ao tipo maior. Normalmente, você usaallocator<void>
quando sabe que será rebote:Dessa forma, você tem certeza de que nenhum trabalho extra será feito para lidar com alocadores para um objeto de tamanho menor que nunca é realmente usado