Глава 10. Управление памятью
…
10.4. Размещение объекта в памяти
…
Для конкретной арены operator new() можно определить так:

void* operator new(size_t s, fast_arena& a)
{
  return a.alloc(s);
}

а использовать следующим образом:

void f(fast_arena& arena)
{
  X* p = new(arena) X; // распределить X на арене
  // ...
}

Здесь предполагается, что fast_arena — это класс, который имеет функцию-член alloc(), применяющуюся для выделения памяти. Например:

class fast_arena {
  // ...
  char* maxp;
  char* freep;
  char* expand(size_t s); // получить дополнительную память от
                          // распределителя общего назначения
public:
  void* alloc(size_t s) {
    char* p = freep;
    return ((freep += s) < maxp) ? p : expand(s);
  }
  void free(void*) { } // ничего не делает
  clear();             // освободить всю выделенную память
};

Такая арена специально предназначена для быстрого выделения памяти и почти мгновенного её освобождения. Важной областью применения арен является предоставление специальной семантики управления памятью.

10.5. Проблемы освобождения памяти
…
Идеальный вариант — тот, при котором пользователю вообще не нужно освобождать память, занятую объектом. Для этого, в частности, применяются специальные арены. Арену можно определить так, что в некоторой известной точке программы будет освобождаться вся память, занятая этой программой. Можно также написать для неё сборщик мусора. Первый подход очень распространён, второй — нет. Специальный сборщик мусора должен быть написан удачно, иначе проще встроить в программу стандартный [Boehm, 1993].

*** Memory manager services ***
…
In all cases, allocated objects are tied to a particular compression or decompression master record, and they will be released when that master record is destroyed.

The memory manager does not provide explicit deallocation of objects. Instead, objects are created in "pools" of free storage, and a whole pool can be freed at once. This approach helps prevent storage-leak bugs, and it speeds up operations whenever malloc/free are slow (as they often are). The pools can be regarded as lifetime identifiers for objects. Two pools/lifetimes are defined:
* JPOOL_PERMANENT lasts until master record is destroyed
* JPOOL_IMAGE lasts until done with image (JPEG datastream)

Когда-то, во времена зарождения языка C, его распределитель памяти был самым слабым из существующих. Это был алгоритм «первый попавшийся», то есть он работал следующим образом: распределитель просматривал все узлы в списке блоков памяти, и первый же попавшийся свободный блок, который был не меньше нужного размера, разбивался на две части — одна возвращалась по запросу, вторая (общий размер блока минус запрошенный размер) возвращалась в список свободных узлов. «Преимущества» этого очевидны — очень низкая скорость работы и дикая фрагментация памяти. В действительности это хуже, чем вы можете себе представить. При выделении памяти приходилось пробегать весь список блоков, игнорируя уже выделенные. Поэтому при увеличении числа блоков производительность падала, а блоки становились всё меньше и были непригодны к использованию. Они отнимали время без всякой реальной пользы.
…
Я сходил в свой кабинет, где лежала копия книги IDL, принёс её с собой назад, и открыл главу «Распределение памяти».
…
«Я написал эту главу, в которой рассказывается о разработке высокопроизводительного, минимально фрагментирующего распределителя памяти.»
…
Распределитель памяти в NT работает весьма схожим образом с тем, что я описал в книге IDL, и основан на алгоритме «быстрого совпадения», разработанном Чаком Вейнстоком для его докторской в CMU около 1974 года.

#define Z_MAGIC 0x1d1d


typedef struct zhead_s
{
  struct zhead_s *prev, *next;
  short magic;
  short tag; // for group free
  int size;
} zhead_t;

zhead_t z_chain;
int z_count, z_bytes;
...
void Z_Free (void *ptr)
{
  zhead_t *z;

  z = ((zhead_t *)ptr) - 1;

  if (z->magic != Z_MAGIC)
    Com_Error (ERR_FATAL, "Z_Free: bad magic");

  z->prev->next = z->next;
  z->next->prev = z->prev;

  z_count--;
  z_bytes -= z->size;
  free (z);
}
...
void Z_FreeTags (int tag)
{
  zhead_t *z, *next;

  for (z=z_chain.next ; z != &z_chain ; z=next)
  {
    next = z->next;
    if (z->tag == tag)
      Z_Free ((void *)(z+1));
  }
}
...
void *Z_TagMalloc (int size, int tag)
{
  zhead_t *z;

  size = size + sizeof(zhead_t);
  z = malloc(size);
  if (!z)
    Com_Error (ERR_FATAL, "Z_Malloc: failed on allocation of %i bytes",size);
  memset (z, 0, size);
  z_count++;
  z_bytes += size;
  z->magic = Z_MAGIC;
  z->tag = tag;
  z->size = size;

  z->next = z_chain.next;
  z->prev = &z_chain;
  z_chain.next->prev = z;
  z_chain.next = z;

  return (void *)(z+1);
}
...
void *Z_Malloc (int size)
{
  return Z_TagMalloc (size, 0);
}
...
void Qcommon_Init (int argc, char **argv)
{
  ...
  z_chain.next = z_chain.prev = &z_chain;
  ...
}

// memory tags to allow dynamic memory to be cleaned up
#define TAG_GAME 765 // clear when unloading the dll
#define TAG_LEVEL 766 // clear when loading a new level

type T1 = int;
T1 a = 1;
int b = a; // Ошибка времени компиляции!

R>Какие мысли?

filter_t *
channel_filters_t::switch_to_delayed_filter(
  const client_id_t & id )
  {
    // Ищем отложенный фильтр в map-е еще не подтвержденных.
    filter_map_t::iterator it = m_delayed.find( id );
    if( it != m_delayed.end() )
      {
        // Перемещаем из одного map-а в другой.
        filter_t * result = it->second.get();
        m_actual.insert( *it );
        m_delayed.erase( it );
        return result;
      }
    else
      // Ну нет такого фильра, пускай наверху разбираются.
      return 0;
  }

public class Formatter
{
    public string Format
    {
        set { _format = value; }
         }
    }
    private string _format;
    public string DoFormat(object a, object b)
    {
      return string.Format(_format, a, b);
    }
public static Formatter F = new Formatter();
}

public string AundB(int a, int b)
{
  Formatter.F.Format = "{0} + {1}";
  return Formatter.F.DoFormat(a, b);
}

int* f ()
{
    int x;
    return &x;
}

PD>Равно как и в куче решительно не рекомендуется возвращать указатели на удаленные уже объекты

PD>int* f ()
PD>{
PD>    int x;
PD>    return &x;
PD>}
PD>

int* f ()
{
    int x;
    return crashHelper(&x);
}
int* crashHelper(int* pX)
{
  return pX;
}

..
Другая важная часть RTSJ—это введение новых областей памяти, отличных от обычной кучи (heap), используемой в Java. Работа с этими областями памяти осуществляется с помощью класса ScopedMemory. Объекты ScopedMemory должны создаваться непосредственно программистом, например:

// создать область памяти размером 1MB (LTMemory — стандартный подкласс ScopedMemory)
ScopedMemory scopedMemory = new LTMemory(1024 * 1024);

Создаваемая таким образом память не управляется сборщиком мусора. Очищаются эти области памяти в тот момент, когда не остаётся работающих в них потоков. Рамки использования памяти задаются синтаксически: поток использует ScopedMemory, пока он выполняет метод ScopedMemory.enter. Также надо отметить, что области ScopedMemory доступны только для потоков реального времени.
..

filter_tptr filter = filters[ id ];

или

filter_tptr const& filter = filters[ id ];

if( !m_actual.insert( *it ) )
  abort(); /* больше уже все равно ничего не сделать */

КЛ>Да и вообще — обычный bl баг

E>if( !m_actual.insert( *it ) )
E>  abort(); /* больше уже все равно ничего не сделать */
E>

template<typename container_t>
void ensure_insert(container_t& c, typename container_t::const_reference v)
{
  if (!c.insert(v).second)
  {
    assert(false);
    throw std::logic_error("element doubling");
    // or just abort()
  }
}

ensure_insert(m, *it);

template<class Container, class Type>
bool exists
(
    const Container& container,
    const Type& value
)
{
    return std::find(container.begin(), container.end(), value) != container.end();
}

template<class Container, class Type>
void erase
(
    Container& container,
    const Type& value
)
{
    __if_exists (Container::remove)
    {
        container.remove(value);
    }
    __if_not_exists (Container::remove)
    {
        Container::iterator iter = se::remove(container, value);
        container.erase(iter, container.end());
    }
}