Loki::SmallObjAllocator ga;

class Test
{
   int i_;
public:
   Test(int i) : i_(i) {}

   static void* operator new(size_t sz)
   {
      return ga.Allocate(sz);
   }

   static void operator delete(void* ptr, size_t sz)
   {
      ga.Deallocate(ptr, sz);
   }
};

int main()
{
   try
   {
      for(int i = 0; i < 20000000; ++i)
         new Test(i);
   }
   catch(const bad_alloc&)
   {
      cout << "bad_alloc\n";
   }

   cout << "end\n";

   return 0;
}

void* FixedAllocator::Allocate()
{
    if (allocChunk_ == 0 || allocChunk_->blocksAvailable_ == 0)
    {
        Chunks::iterator i = chunks_.begin();
        for (;; ++i)
        {
            if (i == chunks_.end())
            {
                // Initialize
                chunks_.reserve(chunks_.size() + 1);
                //...
                chunks_.push_back(newChunk); 
                //...

B>Похоже, что автор попытался сэкономить память, занимаемую вектором chunks_ за счет постоянного копирования содержимиого вектора при увеличении размера. Наверное, на небольших объемах это имеет смысл Однако, когда счет идет на десятки миллионов мелких объектов, у менеджера памяти просто напросто срывает крышу

B>Наверное, проблема может крыться и в стандартном аллокаторе, но ИМХО маловероятно, чтобы такая проблема возникала в реализации STL от двух разных разроботчиков

B>Впрочем, сильно глубоко я не капал

template<class Calculator> // CRTP
struct ReservePolicy
{
    template<class Vec>
    static void reserve(Vec& vec, size_t more)
    {
        size_t const newsize = vec.size()+more;
        if(vec.capacity() < newsize)
            vec.reserve( Calculator::capacity(newsize) );
    }
};

struct DefaultReservePolicy
{
    template<class Vec>
    static void reserve(Vec& vec, size_t more)
    {} // пускай STL позаботится о себе сама
};

struct ScrudgeReservePolicy : ReservePolicy<ScrudgeReservePolicy> // дядюшка Скрудж любит золото...
{
    static size_t capacity(size_t size) { return size; }
};

struct GoldenReservePolicy : ReservePolicy<GoldenReservePolicy> // но золото не знает про дядюшку Скруджа :)
{
    static size_t capacity(size_t size) { return size*161/100; }
};

struct DoubleReservePolicy : ReservePolicy<DoubleReservePolicy>
{
    static size_t capacity(size_t size) { return size*2; }
};

B>Решил я прикрутить SOA к очередному проекту. Подправил код, собрал дебаг-версию, запустил, полюбовался на экономию памяти. Собрал релиз, запустил, и словил bad_alloc

class Test : public Loki::SmallObject<>
{
   int i_;
public:
   Test(int i) : i_(i) {}
};

R>class Test : public Loki::SmallObject<>
R>{
R>   int i_;
R>public:
R>   Test(int i) : i_(i) {}
R>};
R>

std::size_t size = chunks_.size();
// Calling chunks_.reserve *before* creating and initializing the new
// Chunk means that nothing is leaked by this function in case an
// exception is thrown from reserve.
if ( chunks_.capacity() == size )
{
   if ( 0 == size ) size = 4;
   chunks_.reserve( size * 2 );
}