245

Конечно, на этот раз потребуется более хитроумный код, чем в варианте с виртуальными функциями из последнего раздела. Тем не менее, методика «итераторы всюду» обладает одним громадным преимуществом: она позволяет выполнять действия последовательно. Вариант с рекурсивными функциями не позволяет каждую миллисекунду или около того делать передышку и давать поработать другому коду. При использовании итераторов, если соблюдать осторожность, это не проблема. Далее мы будем использовать именно этот вариант.

Сборка мусора по алгоритму Бейкера

Наверное, вам хочется знать, зачем нужен алгоритм Бейкера, не правда ли? В предыдущей главе я выдал его за алгоритм уплотнения, но что толку уплотнять память, если для этого приходится жертвовать 50 процентами ее общего объема? Теперь мы узнаем настоящую прелесть алгоритма Бейкера — его применение в архитектурах сборки мусора.

На данный момент мы не будем беспокоиться об объектах, доступных извне, и сосредоточим внимание на периметре стековых переменных.

Поскольку на этот раз мы занимаемся сборкой мусора, нет причин полагаться во всем на подсчет ссылок. Тем не менее, подсчет ссылок продолжает играть важную роль: он применяется для подсчета дескрипторов в стеке, ссылающихся на конкретный ведущий указатель. Ведущий указатель, у которого счетчик ссылок больше 0, непосредственно доступен из стека, а следовательно, входит в периметр. Мы воспользуемся сильными дескрипторами для стековых переменных и слабыми дескрипторами для ссылок из одного объекта на другой через переменные класса. VoidPtr и другие структуры данных из предыдущей главы остаются без изменений, за одним исключением: VoidPtr::Release() не удаляет ведущий указатель при обнулении счетчика. Запомните: нулевой счетчик ссылок означает не то, что объект вообще недоступен, а лишь то, что он недоступен непосредственно из стека.

Шаблон слабого дескриптора

Слабый дескриптор устроен просто.

template <class Type> class WH {

friend class Handle<Type>; private:

BMP<Type>* pointer;

WH() : pointer(new BMP<Type> (new(object_space) Type)) {}; BMP<Type>& operator->() { return *pointer; }

};

Он используется в переменных классов, которые ссылаются на другие объекты.

class Foo { private:

WH<Bar> bar; // При конструировании создает Bar + MP<Bar>

};

Шаблон сильного дескриптора

Шаблон сильного дескриптора идентичен шаблону слабого, за исключением того, что он поддерживает счетчик ссылок для указателя.

template <class Type> class SH {

private:

BMP<Type>* pointer; public:

SH() : pointer(new BMP<Type>(new Type)) { pointer->Grab(); } SH(const SH<Type>& h) : pointer(h.pointer) { pointer->Grab(); }

246

SH(const WH<Type>& h) : pointer(h.pointer) { pointer->Grab(); } operator WH<Type>() { return WH<Type>(pointer); }

SH<Type>& operator=(const SH<Type>& h)

{

if (this == &h) return *this;

if (pointer == h.pointer) return *this; pointer->Release();

h.pointer->Grab(); return *this;

}

BMP<Type>& operator->() { return *pointer; }

};

Шаблон используется для обычных переменных (а не для переменных класса), ссылающихся на объекты. Благодаря конструктору, принимающему H<Type>, и операторной функции operator H<Type>() он также может использоваться в операциях присваивания с участием переменных классов, то есть слабых дескрипторов.

class Bar {
private:
WH<Foo> foo;
public:
void f();
};
void Bar::f()
{
SH<Foo> f;	// Эквивалентно Foo* f = new Foo;
f = foo;	// Использует operator=(SH<Type>(foo));
foo = f;	// Использует operator WH<Type>(f);
}

Итераторы ведущих указателей

Помните VoidPtrIterator? VoidPtrPool возвращает один итератор для перебора всех указателей с ненулевыми счетчиками ссылок. Все остается без изменений, однако счетчик ссылок теперь интерпретируется по-другому. Раньше ненулевой счетчик ссылок означал, что объект не следует уничтожать. Теперь он имеет более узкое значение: объект доступен непосредственно из стека. Все эти объекты сохраняются, поскольку они находятся на периметре, но мы также сохраним объекты с нулевыми счетчиками ссылок, если они доступны косвенно.

Для объектов внутри периметра мы должны перебрать дескрипторы каждого объекта периметра, а затем рекурсивно двигаться внутрь до тех пор, пока не будут перебраны все доступные объекты. Для этого нам придется анализировать объекты одним из описанных выше способов. В данном примере будет использовано сочетание виртуальных функций/итераторов. Для этой цели можно слегка переработать старый интерфейс VoidPtrIterator.

class VoidPtrIterator { protected:

VoidPtrIterator() {} public:

virtual bool More() = 0; virtual VoidPtr* Next() = 0;

};

Теперь пул должен поддерживать два типа итераторов. Один итератор перебирает указатели, находящиеся на периметре (то есть имеющие ненулевые счетчики ссылок). Второй — указатели на

247

объекты, находящиеся в указанной половине. Итератор VoidPtrPool::iterator() из главы 15 заменяется следующим:

// Включить в класс VoidPtrPool class VoidPtrPool {

public:

VoidPtrIterator* Reachable()

{return new ReachableIterator(this); } VoidPtrIterator* InRange(void* low, void* high)

{return new RangeIterator(this); }

};

Указатели периметра

Один из типов итераторов, возвращаемых пулом, перебирает непосредственно доступные указатели (имеющие ненулевой счетчик ссылок). В сущности, перед нами тот же VoidPtrPoolIterator с одной изменившейся строкой — теперь Advance() пропускает позиции с нулевым счетчиком ссылок. Класс реализован как производный от VoidPtrPoolIterator.

class ReachableIterator : public VoidPtrPoolIterator { protected:

virtual void Advance() // Найти следующую используемую позицию

{

do

VoidPtrPoolIterator::Advance();

while (block != NULL && block->slots[slot].refcount == 0);

}

public:

ReachableIterator(VoidPtrBlock* vpb) : VoidPtrPoolIterator(vpb) {}

};

Недоступные указатели

В конце цикла мы должны пройтись по ведущим указателям и найти все те, которые продолжают ссылаться на неактивную половину. Это и будут недоступные объекты. Задачу решает следующий итератор, в котором используется очередное тривиальное переопределение VoidPtrPoolIterator.

class InRange : public VoidPtrPoolIterator {

private:
void* low;	// Нижний адрес диапазона
void* high;	// Верхний адрес диапазона

virtual void Advance() // Найти следующую используемую позицию

{

do

VoidPtrPoolIterator::Advance(); while (block != NULL &&

(block->slots[slot].address < low || block->slots[slot].address >= high));

}

public:

InRange(VoidPtrBlock* vpb, void* low_addr, void* high_addr)

: VoidPtrPoolIterator(vpb), low(low_addr), high(high_addr) {}

};

248

Перебор указателей в объектах

Каждый объект возвращает другой итератор VoidPtrIterator, который перебирает указатели, доступные непосредственно из объекта. Для каждого класса этот итератор должен быть своим. Далее показан пример.

class MotherOfAllObject {		// Базовый класс для всех остальных
public:
virtual VoidPtrIterator* Pointers() = 0;
};
template <class Type>
class VoidPtrArrayIterator : public VoidPtrIterator {
private:
VoidPtr* ptrs[Entries];
int next;	// Следующая позиция в переборе
public:

VoidPtrArrayIterator() : next(0)

{

for (int i = 0; i < Entries; i++) ptrs[i] = NULL;

}

VoidPtr*& operator[](uint slot) { return ptrs[slot]; } virtual bool More() { return next < Entries; }

virtual VoidPtr* Next() { return ptrs[next++]; }

}; // Пример класса и итератора

class Foo { private:

WH<Bar> bar; public:

virtual VoidPtrIterator* Pointers()

{

new VoidPtrArrayIterator<1>* iterator = new VoidPtrArrayIterato<1>; iterator[0] = bar.Pointer();

return iterator;

}

};

VoidPtrArrayIterator сделан на скорую руку и в реальном проекте его использовать не стоит, но по крайней мере он демонстрирует общий принцип. Конечно, его следует дополнить проверками диапазонов и инициированием исключений, если будет затребован VoidPtr* для NULL. Foo::Pointers() показывает общий принцип использования VoidPtrArrayIterator. Для каждого класса мы изменяем размер массива, чтобы он совпадал с количеством WH<Widget> и добавляем для каждого дескриптора по одной строке вида iterator(index++) = widget.Pointer(). Этот шаблон справляется со всеми простыми случаями, в которых нам не приходится беспокоиться о базовых классах. Если Foo имеет базовые классы, придется организовать вложение итераторов для его собственных указателей и указателей базовых классов.

Перебор указателей

Настал момент собрать все воедино в алгоритме перебора всех доступных объектов. Встречая объект, который в данный момент находится в неактивной половине, мы копируем его в активную половину и изменяем адрес в ведущем указателе на новую копию. Если найденный объект уже находится в активной половине, предполагается, что он уже был скопирован, поэтому мы не тратим время на

249

дальнейшие манипуляции с ним. Объекты, не принадлежащие ни одной из половин, мы пока игнорируем.

Интерфейс Space слегка отличается от того, который использовался для уплотнения. Вместо одного итератора приходится поддерживать стек итераторов, поскольку мы перемещаемся по графу объектов. Кроме того, появилась новая функция Scavenge(), которая вызывается в конце каждого прохода по половине. Предполагается, что у нас уже имеется готовый шаблон стека Stack.

template <class Type> class Stack {

public:

Push(Type*);

Type* Pop(); // Возвращает NULL для пустого стека

};
class Space {
private:
VoidPtrIterator* iterator;		// Итератор верхнего уровня
Stack<VoidPtrIterator> iterator_stack;
HalfSpace A, B;
HalfSpace* active;
HalfSpace* inactive;
void Scavenge();	// Уничтожить недоступные объекты
void Swap();	// Переключить активную половину
public:

Space() : active(&a), inactive(&B), iterator(NULL) { Swap(); } void* Allocate(size_t size)

{

void* space = active->Allocate(size); if (space == NULL) throw(OutOfMemory()); return space;

}

void Copy1();

};

Три ключевые функции — Scavenge(), Swap() и Copy1() — ниже рассматриваются более подробно.

Scavenge

Функция Scavenge() вызывается после одного полного цикла. Она перебирает все ведущие указатели и ищет объекты, оставшиеся в неактивной половине. Эти объекты недоступны. Для каждого объекта она удаляет указатель, который, в свою очередь, вызывает деструктор объекта.

void Space::Scanvege()

{

VoidPtrIterator* vpi =

VoidPtr::pool->InRange(inactive, inactive + sizeof(*inactive)); while (vpi->More()) {

VoidPtr* vp = vpi->Next();

delete vp;	// Вызывает деструктор указываемого объекта
}
delete vpi;
}

250

Swap

Функция Swap() переключает активную половину. Сначала она вызывает Scavenge() в завершение предыдущего цикла, а потом сбрасывает все в исходное состояние, чтобы при следующем вызове функции Copy1() копирование пошло в обратную сторону.

void Space::Swap()

{

Scavenge(); // Уничтожить объекты в неактивной половине if (active == &A)

{

active = &B; inactive = &A;

}

else

{

active = &A; inactive = &B;

}

active->Reinitialize();

iterator = VoidPtr::pool->iterator();

}

Copy1

Функция Copy1() рассматривает один объект. Если объект находится в неактивной половине, он копируется в активную. Если объекта нет, то в рамках текущей задачи мы предполагаем, что он находится в активной половине, а следовательно, был перемещен ранее.

void Space::Copy1()

{

if (!iterator->More())

{

// Перебор	закончен, удалить итератор и вытолкнуть из стека
delete iterator;
iterator =	iterator_stack.Pop();
if (iterator == NULL)		// Готово!

Swap(); // Начинаем двигаться в другую сторону

}

else

{

VoidPtr* vp = iterator->Next(); if (vp->address >= &inactive &&

vp->address < &inactive + sizeof(*insactive))

{

// Объект доступен и его нужно переместить void* new_space = active->Allocate(vp->size); if (new_space == NULL)

// Исключение – нехватка памяти memcpy(new_space, vp->address, vp->size); vp->address = new_space; iterator_stack.Push(iterator);

iterator = vp->address->Pointers();