Alocao Dinmica de Variveis

Quem programa em linguagens de alto nvel apenas, ou em linguagens scriptadas fracamente

tipadas pouco se preocupa com a forma que as variveis esto sendo alocadas. Utilizam logo de um
new e j possuem pronta sua varivel. Todavia, para quem desenvolve em linguagens com espectro
mais amplo de abordagem, como C-ANSI e C++ ou Pascal (sim, ainda tem gente que desenvolve para
Pascal!), precisam se preocupar com como suas variveis so alocadas e como elas deixam a
memria.

Existe duas formas de alocar uma varivel na memria: alocao esttica (onde eu j defino o
espao de memria que minha varivel ser alocada - como um vetor), e alocao dinmica, quando
o tamanho ocupado na memria por minha varivel ser definido em tempo de compilao.

bvio que, se eu sei o tamanho da minha varivel no ser problema algum para mim desalocar a
memria que eu mesmo aloquei. Posso inclusive ir diretamente naquela posio de memria e
escrever algo por cima exatamente do mesmo tamanho, como se faz comumente no Assembly
escrevendo 0 ou 1 (depende do padro definido pela arquitetura do processador ou pelo
programador) quando se quer apagar a memria.

Todavia, e quando eu no sei o tamanho da minha varivel ou quando esse tamanho varia ao longo
do programa. Por exemplo, se minha varivel uma lista encadeada ou um grafo complexo onde os
ns so estruturas (structs) ou objetos inseridos dinamicamente ao longo da execuo? Nestes casos
temos duas escolhas: a primeira uma boa prtica de programao nestas linguagens e tambm
uma mxima: SE VOC QUER PROGRAMAR EM C, ENTO SAIBA LIMPAR SUA SUJEIRA. Em outras
palavras, o programador responsvel por tirar da memria toda varivel ou objeto que tenha
instanciado. Mas isso claramente uma das principais fontes da lentido no desenvolvimento em
C/C++ assim como a principal fonte de erros em programao. Principalmente porque muitos
desenvolvedores destas linguagens no adotam boas prticas de programao e deixam para limpar
sua sujeira depois e no o fazem, transformando seu cdigo num campo minado onde hora ou outra
tanto ele quanto qualquer um que venha a mexer no seu cdigo ir produzir um famoso e elegante
segmentation fault. Desta forma, no seria interessante que, assim como nas linguagens de mais
alto nvel como Java, no fosse o programador, mas o computador o responsvel por saber quando
uma varivel ou objeto no esto mais sendo usados e liberar a memria ocupada por eles?

Estas liguagens utilizam de uma abordagem chamada "lixeiro", mas comumente referenciada pelo
nome em ingls, Garbage Collector.

Esta postagem pretende debater a possibilidade de um garbage collector em C++, implementar um

garbage collector bsico, mas mais que isso, pretende ser uma forma de incentivar nas pessoas o
desejo de programar em C++. O garbage collector foi escolhido porque ele claramente mostra o
enorme poder da linguagem C++. Atravs do uso de template de classes, overload de operadores,
herana e a habilidade nata do C++ operar elementos baixo-nvel tal qual endereos de memria,
pretendemos incentivar o fortalecimento de comunidades C++ que passem a desenvolver para esta
linguagens APIs to poderosas que facilitem tanto a vida do desenvolvedor C++ quanto linguagens
de mais alto nvel.
Comparando duas abordagens do gerenciamento de memria

Antes de desenvolver um garbage collector para C++, considero til comparar a abordagem do
garbage collector com o convencional mtodo manual de gerenciamento de memria em C++.

Prs Contras
Manual Eficincia Suceptvel a
Memory Leak
Controle Liberao
prematura da
memria

Garbage Simplicidade Um pouco ou

Collector muito menos
eficiente.
Segurana Overhead
implcito ao
mecanismo
Perda de
controle de
quando o objeto
ser destrudo.

Irei agora fazer o papel de advogado do diabo e dizer o porque as linguagens como C++ no
implementam nativamente um garbage collector no compilador. Em alguns casos, a impossibilidade
de saber precisamente quando um objeto destrudo pode causar srios problemas porque isso
tambm significa que seu programa no pode saber precisamente quando o destrutor de um objeto
dinamicamente alocado ser chamado. Por exemplo, para sistemas com garbage colletor que rodam
como uma tarefa em background, esta perda de controle pode escalar em problemas
potencialmente mais srios para os progrmas dado que inserem no sistema uma varivel que o
levam essencialmente para uma complexidade no-determinstica. Um garbage collector que
executa em background reclama memria no usada em tempos desconhecidos. Por exemplo, o
garbage collector usualmente rodar apenas quando a CPU tiver tempo livre. Acontece que isso
definido pelo scheduler do Sistema Operacional e no-determinstico. Assim quando a prxima
linha de cdigo ser executada tambm no-determinstico. Na maioria das aplicaes isso no
um problema, todavia em aplicaes em tempo real isso pode causar simplesmente sua destruio
dado que geralmente estes so monitorados e tomam atitudes drsticas aps alguns CPU cycles sem
a resposta esperada.

Portanto, a possiblidade de se utilizar um garbage collector no dispensa a necessidade de se saber

alocar e desalocar variveis na mo em C++.

Ento a regra continua: quer programar C++, seja violento!!!

Consideraes iniciais para um Garbage Collector em C++

Vamos levantar algumas premissas necessrias para que nosso garbage collector seja uma aplicao
funcional:

1. Deve coexistir no mesmo cdigo com o mtodo manual de desalocar memria em C++.
2. No pode quebrar o cdigo pr-existente nem impactar no mesmo de forma alguma.
3. Deve trabalhar de forma transparente de forma que as aplicaes que usam garbage
collector sejam operadas da mesma forma que as que no usam.
4. Devem ser alocadas usando new porque no quero ter que aprender uma nova palavra-
chave.
5. Deve trabalhar com todos os tipos de dados, incluindo os tipos nativos como int e double.
6. Deve ser simples de usar.

Existem algumas formas de se implementar um garbage collector. A dizer trs algortimos:

1. Reference Counting Algorithm

2. Mark and Sweep Algorrithm
3. Copying Algorithm

Voc pode ver as vantagens e desvantagens de cada um e aprofundar neles nas referncias
apresentadas abaixo. Mas para este artigo irei mostrar uma implementao com o Reference
Counting Algorithm. Olhando as vantagens e desvantagens de cada um, creio que a escolha deste ou
daquele mtodo seja mais uma coisa de gosto e de otimizao especfica para sua aplicao. Para a
maioria das aplicaes tanto faz qual abordagem ir implementar.

Outra coisa importante a se perguntar quando estamos desenvolvendo (ou usando) um garbage
collector em C++ se ele precisa ser single-threaded ou multi-threaded. Isto , o garbage collector
precisa ser desenvolvido como um processo em background, rodando sua prpria thread e
coletando o lixo sempre que o tempo da CPU permitir ou ele executar na mesma thread do
processo que o usa coletando o lixo certamente quando ocorrer uma condio programada?

A principal vantagem em criar um coletor multi-threaded a eficincia. O lixo poder ser coletado
quando a CPU estiver em idle. A principal desvantagem (chorem) simplesmente que a linguagem
C++ simplesmente no oferece nenhum suporte nativo a multithread!

Por outro lado, a principal vantagem em usar uma implementao single-threaded do garbage
collector a portabilidade. Ele poder ser utilizado em situaes que no suportam multithreading
or em casos em que o preo de se fazer uma implementao multithreading muito alto. J a
principal desvantagem reside no fato de que o resto do programa pra quando o garbage collector
exerce sua funo.

Apesar disso, escolhemos a abordagem single-threaded porque ela funciona em todos os ambientes
C++. Numa outra oportunidade podemos falar de uma abordagem multithread para o garbage-
collector.

Uma ltima coisa a ser avaliada, dado que implementaremos uma soluo single-threaded quando
o lixeiro sair para recolher o lixo? Isso importante porque lembremos: assim que nosso lixeiro sair
para recolher o lixo o programa todo fica parado. Logo, ele no pode estar executando nenhuma
funo primordial ou dependente de tempo neste instante.

No mundo real, o garbage collector usualmente desempenha sua funo apenas quando h uma
razo muito forte para faz-lo, ou seja, quando a memria estiver lenta!

Mas existe uma implementao funcional de garbage collector em

C++?

Apresento-vos o "Boehm-Demers-Weiser Conservative Garbage Collector", de Hans-J.Boehm da HP

Labs. No site do desenvolvedor ele se isenta de qualquer responsabilidade mas os projetos que
fazem uso deste collector garantem de certa forma sua confiabilidade. Citarei alguns aqui: GNU
Objective C runtime, Mono project, Mozzilla project, algumas verses da Xerox DocuPrint, o GCJ
(compilador java), Eclipse, implementao Cecil da Universidade de Washington, dentre outros
tantos e o prprio autor cita tambm artigos cientficos que publicou em diversas revistas e eventos.

Para comearmos a utilizar um garbage collector em C++ precisamos fazer download