Gerenciamento de Memória

Listas Livres

class Foo
{
 static Foo freelist; // começo da lista livre

static Foo allocate()
 { Foo f;

	if (freelist)
	{ f = freelist;
	freelist = f.next;
	}
	else
	f = new Foo();
	return f;
 }

 static void deallocate(Foo f)
 {
	f.next = freelist;
	freelist = f;
 }

 Foo next; // para uso por FooFreeList
 ...
}

void test()
{
 Foo f = Foo.allocate();
 ...
 Foo.deallocate(f);
}

• Se usadas por múltiplos threads, as funções allocate() e deallocate() precisam ser sincronizadas.
• O construtor de Foo não é re-executado por allocate() quando alocar da lista livre, então o alocador pode precisar reinicializar alguns dos membros.
• Não é necessário praticar RAII com isso, já que se quaisquer objetos não são passados para deallocate() quando terminados, por causa de uma exceção lançada, serão eventualmente escolhidos pelo gc de qualquer modo.

Contagem de Referência

D não provê qualquer processo automática para contagem de referências, ela deve ser feita explicitamente.

Programação COM Win32 usa os membros AddRef() e Release() para manter contagem de referências.

Alocação de Instancia de Classe Explícita

import std.c.stdlib;
import std.outofmemory;
import std.gc;

class Foo
{
 new(size_t sz)
 {
	void* p;

	p = std.c.stdlib.malloc(sz);
	if (!p)
	throw new OutOfMemoryException();
	std.gc.addRange(p, p + sz);
	return p;
 }

 delete(void* p)
 {
	if (p)
	{ gc.removeRange(p);
	std.c.stdlib.free(p);
	}
 }
}

• new() não tem um tipo de retorno especificado, mas é definido para ser void*. new() deve retornar um void*.
• Se new() não pode alocar memória, ela não deve retornar nulo, mas deve disparar uma exceção.
• O ponteiro retornado por new() deve ser para memória alinhada pelo alinhamento padrão. Isso é 8 em sistemas win32.
• O parâmetro tamanho é necessário no caso de o alocador ser chamado de uma classe derivada de Foo e for de um tamanho maior que Foo.
• Um null não é retornado se armazenamento não pode ser alocado. Ao invés disso, uma exceção é disparada. Que exceção será disparada é dada pelo programador, nesse caso, é OutOfMemory().
• Quando varrer a memória por ponteiros raíz na pilha do coletor de lixo, o segmento de dados estático e a pilha são varridas automaticamente. A pilha de C não é. Conseqüentemente, se Foo ou qualquer classe derivada de Foo o alocador contem qualquer referência para dados alocados pelo coletor de lixo, o gc deve ser notificado. Isso é feito com o método gc.addRange().
• Nenuma inicialização de memória é necessária, como o código é automaticamente inserido após a chamada à new() para ajustar os membros da instancia da classe para seus padrões e então o construtor (se algum) ser executado.

• O destrutor (se algum) já foi chamado no argumento p, então os dados que ele aponta deveriam ser assumidos como sendo lixo.
• O ponteiro p pode ser nulo.
• Se o gc foi notificado com gc.addRange(), uma chamada correspondente à gc.removeRange() deve ocorrer no desalocador.
• Se há um delete(), deveria haver um new() correspondente.

Marque/Solte

import std.c.stdlib;
import std.outofmemory;

class Foo
{
 static void[] buffer;
 static int bufindex;
 static const int bufsize = 100;

 static this()
 { void *p;

	p = malloc(bufsize);
	if (!p)
	throw new OutOfMemory;
	gc.addRange(p, p + bufsize);
	buffer = p[0 .. bufsize];
 }

 static ~this()
 {
	if (buffer.length)
	{
	gc.removeRange(buffer);
	free(buffer);
	buffer = null;
	}
 }

 new(size_t sz)
 { void *p;

	p = &buffer[bufindex];
	bufindex += sz;
	if (bufindex > buffer.length)
	throw new OutOfMemory;
	return p;
 }

 delete(void* p)
 {
	assert(0);
 }

 static int mark()
 {
	return bufindex;
 }

 static void release(int i)
 {
	bufindex = i;
 }
}

void test()
{
 int m = Foo.mark();
 Foo f1 = new Foo; // alocado
 Foo f2 = new Foo; // alocado
 ...
 Foo.release(m); // desaloca f1 e f2
}

RAII (Resource Acquisition Is Initialization)

Alocar Instâncias de Classe na Pilha

Para ter uma classe alocada na pilha que tenha um destrutor, é o mesmo que uma declaração com o atributo auto. Embora a implementação atual não ponha tais objetos na pilha, futuramente poderá.

import std.c.stdlib;

class Foo
{
 new(size_t sz, void *p)
 {
	return p;
 }

 delete(void* p)
 {
	assert(0);
 }
}

void test()
{
 Foo f = new(std.c.stdlib.alloca(Foo.classinfo.init.length)) Foo;
 ...
}

• Não há necessidade de chacar por uma falha de alloca() e lançar uma exceção, já que por definição alloca() irá gerar uma exceção de transbordamento de pilha se ela transbordar.
• Não há necessidadede uma chamada a gc.addRange() ou gc.removeRange() já que gc varre a pilha de qualquer forma.
• A boba função delete() é para assegurar que nenhuma tentativa de deletar um objeto baseado na pilha será feita.

Alocar Arrays Não-Inicializados na Pilha

void foo()
{ byte[1024] buffer;

 fillBuffer(buffer);
 ...
}

void foo()
{ byte[1024] buffer = void;

 fillBuffer(buffer);
 ...
}

• Os dados não-inicializados que estão na pilha serão varridos pelo coletor de lixo procurando por quaisquer referências para memória alocada. Já que dados não-inicializados consistem de antigos quadros da pilha de D, é altamente provável que algo daquele lixo irá parecer com referências na pilha do gc, e a memória do gc não será liberada. Esse problema realmente acontece, e pode ser bem frustrante consertar.
• É possível para uma função passar uma referência para dados naquele quadro de pilha da função. Mas então alocar um novo quadro de pilha sobre os dados antigos, e não inicializar, a referência para os dados antigos pode parecer ser válida. O programa irá então se comportar incorretamente. Inicializando todos os dados no quadro da pilha irá aumentar a probabilidade de forçar esse bug de forma repetível.
• Dados não inicializados podem ser uma fonte de bugs e problemas, mesmo quando usado corretamente. Uma meta do projeto de D é melhorar confiança e portabilidade eliminando fontes de comportamento indefinido, e dados não inicializados são uma enorme fonte de comportamentos indefinidos, importáveis, irrados e imprevisíveis. Conseqüentemente esse idioma deveria ser usado somente após outras oportunidades por otimização de velocidade serem exaustas e comparações mostram que realmente aceleram a execução global.