Стековая аллокация

C++ предлагает программистам на выбор аллокацию объектов в массиве или в стеке. Стековая аллокация является эффективной: аллокация недорога, затраты на деаллокацию почти равны нулю, а язык помогает демаркировать жизненные циклы объекта, снижая риск того, что объект забудут освободить. С другой стороны, в C++ вам нужно быть очень осторожными при публикации или совместном использовании ссылок на стековые объекты, потому что стековые объекты автоматически освобождаются, когда стековый фрейм раскрывается, приводя к появлению неработающих ссылок.

Другим преимуществом стековой аллокации является то, что она гораздо более удобна для кэша. В современных процессорах цена кэш-промахов весьма значительна, следовательно, если язык и рабочий цикл могут помочь вашей программе достичь лучшей локализации данных, то производительность улучшится. Верхушка стека почти всегда "горячая" в кэше, тогда как верхушка массива почти всегда "холодная" (потому что наверняка прошло достаточно времени с тех пор, как использовалась эта память). В результате аллокация объекта в массиве, скорее всего, повлечет за собой больше кэш-промахов, чем аллокация объекта в стеке.

Плохо то, что кэш-промах при аллокации объекта в массиве имеет особенно опасное взаимодействие с памятью. При аллокации памяти из массива содержимое данной памяти является мусором — любые биты, оставшиеся после того, как память использовалась в последний раз. Если вы размещаете блок памяти в массиве, который еще не находится в кэше, при выполнении возможны зависания, пока содержимое данной памяти будет переноситься в кэш. Затем вы немедленно перепишете эти значения, которые вы затратили на то, чтобы перенести в кэш с нулями или другими исходными данными, а это приводит к большим потерям работы памяти. (Некоторые процессоры, такие как Azul's Vega, включают аппаратную поддержку для ускорения аллокации массива).

Escape-анализ

Язык Java не предлагает никакого способа точно расположить объект в стеке, но этот факт не мешает JVM использовать стековую аллокацию, где это уместно. JVM может использовать технологию, именуемую escape-анализ, с помощью которой можно сказать, что определенные объекты удерживаются в одном потоке в течение всего жизненного цикла, а он связан со временем существования данного стекового фрейма. Такие объекты можно безопасно располагать в стеке вместо массива. Что даже лучше для маленьких объектов, JVM может полностью оптимизировать аллокацию и просто поднять поля объекта в списки.

(прим. ред. — далее приводятся примеры с псевдокодом оптимизации)

...

Escape-анализ в Mustang

Escape-анализ является оптимизацией, о которой уже давно говорилось, и наконец-то вот она — текущие сборки Mustang (Java SE 6) могут осуществлять escape-анализ и конвертировать аллокацию массива в стековую аллокацию (или без аллокации) там, где это уместно. Использование escape-анализа для устранения некоторых результатов аллокаций с более быстрым средним временем аллокации, уменьшенным потреблением ОЗУ и меньшим количеством кэш-промахов. Кроме этого, оптимизирование некоторых аллокаций уменьшает давление на сборщик мусора и позволяет реже запускать сборку.

© Теория и практика Java: Еще раз о городских легендах о производительности. Аллокация гораздо быстрее, чем вы думаете, и все больше ускоряется, Брайан Гетц

vector<int> v1, v2, v3;
push_back_tx tx1 (v1, 1);
push_back_tx tx2 (v2, 2);
v3.push_back(3);
tx1.commit();
tx2.commit();

shared_ptr<heavy_class> f()
{
  return shared_ptr<heavy_class>(new heavy_class());
}

shared_ptr<heavy_class> x = f();

using (var tran = partition.Store.TransactionManager.BeginTransaction())
{
    ...
    tran.Commit();
}

R>vector<int> v1, v2, v3;
R>push_back_tx tx1 (v1, 1);
R>push_back_tx tx2 (v2, 2);
R>v3.push_back(3);
R>tx1.commit();
R>tx2.commit();
R>

using (var tx1 = v1.TxPushBack(1))
using (var tx2 = v2.TxPushBack(2))
{
    v3.PushBack(3);
    tx1.Commit();
    tx2.Commit();
}

void f()
{
    lock l1 (m1);
    //...
    lock l2 (m2);
    //...
    file f;
    //...
}

void f()
{
    using (lock l1 = m1.lock())
    {
        //...
        using (lock l2 = m2.lock())
        {
            //...
            using (file f = open_file())
            {
                //...
            }
        }
    }
}