# Gerenciamento de memória

Gerenciamento (ou gestão) de memória é um complexo campo da ciência da computação e são constantemente desenvolvidas várias técnicas para torná-la mais eficiente. Em sua forma mais simples, está relacionado em duas tarefas essenciais:
* Alocação: Quando o programa requisita um bloco de memória, o gerenciador o disponibiliza para a alocação;
* Reciclagem: Quando um bloco de memória foi alocado, mas os dados não foram requisitados por um determinado número de ciclos ou não há nenhum tipo de referência a este bloco pelo programa, esse bloco é liberado e pode ser reutilizado para outra requisição.

## Gerência de Memória

A cada dia que passa os programadores necessitam de mais memória e mais programas rodando simultaneamente para poderem tratar cada vez mais informações. O tratamento necessário da memória utilizada não é uma tarefa fácil de ser implementada. Existem vários requisitos que devem ser observados para o correto funcionamento, tais como, segurança, isolamento, performance, entre outros. Para isto a função de gerenciar a memória passa a ser do sistema operacional e não mais do aplicativo.
Para que uma memória funcione de maneira correta, é necessário que se tome cuidado com vários elementos como segurança e isolamento, e para isso é utilizado o gerenciamento de memória. Este desenvolve sua função a partir de duas tarefas, a Alocação de Memória e a Fragmentação:
* A Alocação pode ser tanto estática, feita quando o programa é compilado, e a dinâmica, adiada até a execução.
* A Fragmentação, desperdício de memória, por sua vez pode ser interna, sobra na memória reservada ao programa, e externa que acontece quando após o termino dos programas são deixadas pequenas lacunas entre as páginas.
Para que a utilização da memória seja mais vantajosa, é utilizada a Paginação, processos virtuais da memória, aplicados na divisão da memória física em partições menores, chamadas de frames. O conjunto de registradores especiais rápidos chama-se Translation Lookaside Buffer, estes são subdivididos em chave valor que lhe é dado em todos os registradores ao mesmo tempo, e valor.
Existe uma técnica de gerencia de memória chamada memória virtual, que é onde memórias principais e secundárias juntas criam a ilusão de que há muito mais memória.
O conceito desta técnica fundamenta-se em não vincular o endereçamento feito pelo programa aos endereços físicos da memória principal, com isso os programas e suas estruturas de dados não se limitam ao tamanho da memória física, e assumem endereços na memória secundária.
O gerenciamento de memória virtual pode ocasionar vazamento de memória, ou seja, quando determinada quantia de memória é alocada e não é liberada mesmo que não sendo utilizada, assim dados perdem a referencia sem ao menos terem usado memória.
O gerenciamento automático chama-se Garbage collector. Ele retira os blocos de memória automaticamente. Seus algoritmos são divididos em duas famílias: a Identificação direta, por contagem de referência, e a Identificação indireta, por varrimento.

### Alocação de Memória

Todo programa precisa utilizar memória para ser executado. Quando um programa inicia sua execução, ele começa a solicitar memória ao sistema operacional, ou seja, faz a alocação de memória necessária para a sua execução. A alocação de memória está dividida em 3(três) partes:
* Alocação Estática: Decisão tomada quando o programa é compilado. Quando o programa é executado o Sistema operacional o lê e cria um processo, sendo o programa uma noção estática e o processo o programa em execução, que é criado em armazenamento primário e após isso recebe um espaço na memória. O espaço de memória é dividido em varias partes, uma das partes se chama segmentos de memória, que armazena dados estáticos, e outro se chama segmento de código que guarda instruções do programa. Quando o programa é executado o registrador PC apontará para determinado endereço do segmento de código do processo, que se chama TEXT. Para que se realize a alocação estática o compilador deve saber o total de memória que está livre, mandar esta informação para o S.O para que este crie um segmento de dados.
* Alocação Dinâmica: Decisão é adiada até a execução. (Permite Swapping) Os objetos alocados dinamicamente podem ser criados e liberados a qualquer momento, em qualquer ordem, o que difere dos objetos locais das funções, que são criados e destruídos em uma ordem específica. Dado isto, é preciso organizar a memória para objetos dinâmicos de uma forma que possibilite a gestão do tempo de vida dos objetos por parte do programador. A memória reservada para objetos dinâmica costuma ser chamada de heap, existem várias formas de organizar um heap. Em linguagens sem a gestão automático (linguagem C), da memória dinâmica, uma organização usual do heap é uma lista encadeada de blocos livres, porém este tipo de organização pode ter problemas devido à fragmentação dos blocos. Já em linguagens com gerenciamento automático de memória dinâmica (Java), a organização do heap depende da parte do sistema de tempo de execução encarregada desta gestão. Este componente é normalmente chamado de coletor de lixo. Alguns tópicos para podermos entender melhor: • Carrega vários processos na memória ao mesmo tempo; • Quando chega um novo processo, e a memória principal está toda ocupada, escolhe um processo, grava-o no disco, e libera memória para o próximo.
* Alocação Local: Este processo de alocação é usado para variáveis que são locais a funções e sub-rotinas. Isso significa que o processo em execução deve manter acessível as variáveis locais da função ou procedimento que está executando no momento. Além disso, pelas propriedades do escopo em blocos, também devem estar acessíveis as variáveis de blocos mais externos. Em linguagens que permitem a definição de funções aninhadas, ter acesso a variáveis de quaisquer funções definidas externamente à função atualmente em execução. Como uma função pode chamar outras funções, um número arbitrário de funções pode estar no meio de sua execução em um determinado momento, mesmo que apenas uma esteja realmente sendo executada, isso indica que o contexto de várias funções deve ser mantido enquanto as mesmas não concluíram sua execução.

### Fragmentação

Em computação, significa o desperdício de espaço disponível em memória.
Pode ser de dois tipos:
* Interna: Ocorre quando o processo não ocupa inteiramente os blocos de memória (páginas) reservados para ele. Geralmente acontece pois o tamanho do processo não é um múltiplo do tamanho da página de memória, o que acarreta sobra de espaço na última página alocada. (dentro de um processo)
* Externa: Ocorre à medida que os programas vão terminando e deixando lacunas cada vez menores de espaços entre as páginas. Dependendo do tamanho que precisa ser escrito em memória, estes espaços podem ser pequenos demais para serem úteis, e assim ficam inutilizados. (entre processos)
Estratégias para "atacar" o problema com o algoritmos First-fit, Best-fit, Worst-fit e Next-fit.

### Paginação

No contexto dos sistemas operacionais, a paginação da memória do computador é um processo de virtualização da memória que consiste na subdivisão da memória física em pequenas partições (frames), para permitir uma utilização mais eficiente da mesma. A alocação de memória é requisitada por páginas, a menor unidade deste método. Cada página é mapeada num frame de memória através de um processo chamado de paginação. O sistema operacional pode estar em base do espaço de endereçamento, em RAM, ou estar no topo do espaço de endereçamento, em ROM, e o restante do sistema mais embaixo, em RAM. O primeiro modelo foi inicialmente empregado em computadores de grande porte e mini-computadores (mas não é muito usado). O segundo modelo é utilizado em alguns computadores de mão e em sistemas embarcados. O terceiro modelo fez parte dos primeiros computadores pessoais, nos quais a parte do sistema contida em ROM é denominada BIOS. Quando o sistema é organizado dessa maneira, somente um processo pode ser executado a cada instante. Tão logo um usuário tecle um comando, o sistema operacional carrega o programa solicitado, do disco, para a memória e o executa. Quando o processo finaliza, o SO coloca na tela um caractere de prompt e espera por um novo comando. Ao receber um novo comando, carregará o novo programa na memória, no espaço de endereçamento ocupado pelo programa anterior.

### Translation Lookaside Buffer

A Translation Lookaside Buffer (TLB) é um conjunto de registradores especiais que são bastante rápidos. Ela está presente na Unidade de Gerenciamento de Memória de uma processador. Cada registrador tem duas partes: chave e valor. Dada uma chave, busca-se o valor correspondente. Geralmente o número de entradas não passa de 256 e a busca é feita em todos os registradores simultaneamente.

### Algoritmos de Substituição de Página

* Algoritmo Ótimo
* Algoritmo Não Usada Recentemente
* Algoritmo FIFO
* Algoritmo Segunda Chance
* Algoritmo do relógio
* Menos Recentemente Usada
* WSClock
Em modelos de gerenciamento manual, podem ocorrer os problemas conhecidos como vazamento de memória, que acontece quando uma quantidade de memória é alocada e não é liberada ainda que nunca seja utilizada. Isto ocorre quando objetos perdem a referência sem terem sido liberados, mantendo o uso do espaço de memória.

## Garbage Collector

É o gerenciamento automático de memória, também conhecido como coletores, sendo conhecido em Portugal como reciclagem automática de memória. Este serviço libera os blocos de memória que não sejam mais usados por um programa automaticamente. É oposto ao gerenciamento de memória manual, a alocação explicita e a desalocação dos recursos de memória do computador.
As vantagens desse tipo de gerenciamento são:
* Liberdade do programador: Não é obrigado ficar atento aos detalhes da memória;
* Menos bugs de gerenciamento de memória: Por se tratar de uma técnica mais confiável;
* Gerenciamento automático: Mais eficiente que o manual.
E entre as desvantagens, podemos citar:
* O desenvolvedor tende a estar mais desatento em relação a detalhes de memória;
* O gerenciador automático ainda apresenta limitações.
Quando deixam de existir referências a um objeto, este passa a ser considerado apto a ser "coletado" pelo garbage collector, que significa dizer que será removido da memória, deixando-a livre para uso por outros objetos.
Os algoritmos de garbage collection operam de um modo que permite classificá-los em duas grandes famílias:
* Identificação Direta: por contagem de referências (reference counting);
* Identificação Indireta: por varrimento (tracing), que pode incluir também compactação da memória livre; cópia; ou geracional (utilizado nas máquinas virtuais Java e .NET).

## Gerenciamento de memória no DOS

O IBM PC original foi projetado com uma memória RAM de 1024KB
* 640KB
** Para o sistema operacional e programas
* 384KB - área de memória superior (Upper Memory Area) ou UMA
** Para os adaptadores diversos como EGA & VGA, MDA, adaptadores CGA, e de redes.
** ROM BIOS e Shadow RAM.
** E mais tarde, área de paginação de expansão de memória (EMS) vista mais adiante.
Logo depois, foi provado que esta quantidade de memória se tornaria insuficiente para as necessidades futuras.
Entretanto, os sistemas operacionais e aplicativos desenvolvidos até então não seriam capazes de reconhecer um endereço de memória superior aos 640KB originais, o que levou os projetistas a desenvolverem ferramentas que executariam esta tarefa.

### Emm386.exe

É o dispositivo de instalação da memória expandida (Expanded Memory) ou EMS. A EMS consistia em toda a memória acima dos 1024KB (1MB) original, em computadores baseados nas tecnologias dos processadores 80286, 80386, i486 ou Pentium. A capacidade máxima de endereçamento fica limitada a 32MB e seu acesso é através de uma paginação de 64KB na área UMA. Os programas deveriam ser escritos de forma a poderem reconhecer a área EMS.
O nome "EMM" vem do inglês Extended Memory Manager.

### Himem.sys

É o dispositivo de instalação da área de memória alta (High Memory Area), conhecida também como HMA. Sua principal função é controlar o uso da memória estendida do computador, de modo que dois ou mais aplicativos ou dispositivos não utilizem o mesmo endereço de memória ao mesmo tempo. Para as primeiras versões do Windows, o Himem.sys fornecia suporte para que este fosse executado em modo protegido.
O nome Himem vem do inglês High Memory.

### Smartdrv.exe

É o gerenciador de memória cache de disco (no Novell DOS 7, é chamado de Nwcache.exe). Ambos possuem a mesma função que é a de minimizar o acesso ao disco, carregando um bloco de informações na memória para processamento, ao invés de ir buscar aos poucos no disco. Existiram também placas de expansão chamadas de Disk Accelerator, que possuem um hardware próprio para esta tarefa, como por exemplo o 'Disk Accelerator PROMISE DC4030VL. Atualmente, esta técnica é desempenhada por memórias localizadas na placa principal do sistema (cache on-board) resultando, portanto, dois modos de gerenciamento de memória cache de disco: por software e por hardware.
O nome Smartdrv é uma abreviação do inglês Smart Drive.

## Multiprogramação com Partições Fixas

É usada em sistemas embarcados simples. Muitos dos programas modernos permitem que múltiplos processos executem simultaneamente, ou seja, quando um processo for bloqueado, outro poderá usar a CPU aumentando a sua utilização. O melhor jeito de realizar a multiprogramação consiste em dividir a memória em n partições de tamanhos diferentes que podem ser criadas manualmente ao iniciar o sistema. Ao chegar no sistema, um job é colocado em uma fila de entrada juntamente associada à menor partição existente, porém que seja grande o suficiente para armazená-lo e, como o tamanho dessas devidas partições são fixas, todo espaço que não é usado pelo job na partição será perdido. Quando jobs estão chegando torna-se evidente quando a fila para uma grande partição está vazia, mas a fila para uma pequena partição está cheia, nesse caso os jobs pequenos terão que esperar para que a memória seja liberada, mesmo que exista memória disponível. O modo correto é manter uma fila única, sempre que a partição se torna disponível, o job que se encontra mais próximo do início da fila e que caiba na partição pode ser nela executado. Para que não haja um total desperdício de grandes partições com jobs pequenos, o ideal seria pesquisar em toda a fila de entrada e alocar a partição disponível ao maior job que nela possa ser carregado. Para que os jobs pequenos possam também serem executados sem desperdiçar partições maiores, seria necessária a criação de ao menos uma partição pequena.

## Modelagem de Multiprogramação

Tem o objetivo de melhorar o desempenho da CPU, se um processo permanecer em execução apenas 20% do tempo em que ocupa a memória, com cinco processos simultaneamente na memória a CPU deveria permanecer ocupada nesse intervalo de tempo, esse modelo não é realista porque os cinco processos nunca poderão esperar E/S ao mesmo tempo. Outro modelo é supor que um processo gaste uma fração p de seu tempo esperando pela finalização de sua solicitação de E/S, e com os n processos executando ao mesmo tempo em memória, a probabilidade dos processos estarem aguardando E/S é p^n. A probabilidade presume como independentes todos os n processos, que sendo assim é aceitável existirem 5 processos em memória, sendo que três deles executando simultaneamente e dois em estado de espera, mas, como se tem uma única CPU, não pode haver três processos executando ao mesmo tempo, de modo que se um processo estiver pronto para a execução, terá de esperar enquanto a CPU estiver ocupada com outro processo, portanto observa-se que os processos não são independentes. Suponha que um computador tenha 32MB de memória, e um SO que use 16 MB e cada programa empregando 4MB. Com esses tamanhos possibilitam que os programas estejam simultaneamente na memória, considerando que um processo passa 80% de seu tempo em espera por E/S, o cálculo de utilização da CPU se dá por 1-(p^n), sendo, nesse caso, n=4 (pois a memória restante para os programas é de 16MB e cada programa tem 4MB, então 16/4) e o p=0,80, portanto tem-se uma utilização da CPU de 1-0,8^4 (1-p^n), aproximadamente 60%. Se houver a adição de mais 16MB permite que aumente seu grau de multiprogramação, aumentara a utilização da CPU para aproximadamente 83%. Ainda adicionando mais 16 MB, de 83% a utilização da CPU vai para aproximadamente 93%. O modelo permite que o dono do computador decida que a primeira adição de memória é um bom investimento, mas não a segunda que só aumentou 12% de sua utilização. Um modelo mais realístico pode ser baseado na teoria das filas.

## Análise de Desempenho de Sistemas de Multiprogramação

O ultimo modelo usado em modelagem de multiprogramação pode ser usado para analisar sistemas em lote, por exemplo, digamos que um centro onde jobs gastariam 80% do seu tempo com espera de E/S, em um certo dia quatro desses jobs são submetidos, o primeiro chega às dez horas, requer quatro minutos de tempo da CPU, considerando que os 80% do tempo é gasto com espera de E/S, o job usará apenas 12 segundos de tempo da CPU para cada minuto que estiver rodando na memória, mesmo que não haja outros jobs competindo com ele pela CPU. Os demais 48 segundos serão gastos esperando pela conclusão de E/S, então o job terá de ficar na memória no mínimo 20 segundos para que possa obter quatro minutos de trabalho da CPU, mesmo sem competição de processos. Desde 10h às 10h10, o primeiro job consegue 2 minutos de trabalho da CPU. Quando o segundo job chega às 10h10, a utilização da CPU aumenta de 0,20 para 0,36. No entanto, com o escalonamento round-robin (alternância circular), cada job consegue metade do tempo da CPU, obtendo 18 minutos de trabalho da CPU realizado para cada minuto de permanência na memória, a entrada do segundo job custa ao primeiro job somente 10% de perda em seu desempenho. Ele passa de 0,20 minutos de CPU para 0,18 para cada minuto de permanência em memória. Às 10h15 chega o terceiro job, até esse momento o job 1 tinha recebido 2,9 minutos de CPU e o segundo job 0,9 minutos de CPU. Com uma multiprogramação de grau três, cada job consegue 0,16 minuto de CPU por minuto de permanência na memória. Das 10h15 às 10h20, cada um dos três jobs consegue 0,8 minuto de tempo de CPU. Às 10h20 chega um quarto job e completa a sequência dos eventos.

## Troca de Processos

Em sistemas em lote, a memória é organizada em partições fixas. Em cada partição cada job ou processo é carregado ao alcançar o inicio da fila permanecendo até a conclusão de sua execução. Para garantir que a CPU esteja ocupada todo tempo é executado um determinado número de jobs, assim não necessitando utilizar uma outra técnica mais complicada. Há uma diferença em sistemas com compartilhamento de tempo ou computadores gráficos pessoais, pois nesses casos pode ocorrer é insuficiente a quantidade memória principal para todos os processos ativos, sendo necessário armazenar o excedente em discos e trazidos dinamicamente para a memória quando precisarem ser executados.

### Troca de Processos e Memória Virtual

São dois métodos usados para gerenciamento de memória utilizados conforme os recursos de hardware disponíveis:

#### Troca de Processos (também chamado swapping)

Esse método trabalha trazendo cada processo para memória, e executa durante um tempo determinado e então devolve ao disco.
* Alocação de espaço para uma área de dados em expansão.
* Alocação de espaço para uma pilha e uma área de dados, ambos em expansão.
Transferir e remover processos da memória RAM constantemente irá inevitavelmente causar múltiplos espaços vazios ao longo do tempo. É possível combinar todos esses espaços em um espaço único, ao custo de muito tempo de processamento. Essa técnica é conhecida como compactação de memória.
Swapping tem uma grande desvantagem, a velocidade de transferência do disco é lenta. Por exemplo, aplicações pesadas como Photoshop demorariam vários segundos para serem carregados e removidos da memória RAM, pois a operação é limitada pelo dispositivo mais lento.

#### Memória Virtual

Já esse método permite que programas sejam executados mesmo que estejam apenas parcialmente carregados na memória principal.
Partições fixas e Partições variáveis: As principais diferenças são o tamanho e a localização das partições que variam conforme os processos entram e saem da memória nas partições variáveis, enquanto que nas partições fixas os parâmetros são fixos. Nas trocas de processos quando deixam muitos espaços vazios na memória, há a possibilidade aglutiná-los em único espaço contíguo de memória, movendo-os o máximo possível para os endereços mais baixos. Técnica denominada compactação de memória. No entanto não é muito utilizada pelo tempo de processamento necessário considerado alto. Algo que deve ser dado uma devida importância é a quantidade de memória que deve ser alocada a um processo, quando for criado ou trazido do disco para memória. Se o processo possuir tamanho fixo, inalterável, então o processo de alocação torna-se simples: o sistema operacional alocará o espaço necessário. No entanto, na área de dados que o processo puder crescer, é alocado uma área temporária denominada (heap). Se houver espaço disponível ao processo, ele poderá ser alocado a esse determinado processo. Quando os processos puderem ter duas área de expansão, a área de dados sendo usada como área temporária (heap) para variáveis dinamicamente alocadas e liberadas, e uma área de pilha para variáveis locais e para endereços de retorno.

### Multiprogramação com partições variáveis

O espaço de endereçamento de cada processo precisa ser contíguo (i.e. contínuo) para que se possa implementar o mecanismo de proteção descrito acima usando os registradores base e limite.
A tendência é de que a memória apresente vários espaços vazios (buracos) ao longo do tempo. Compactação de memória: lento (ainda que em memória RAM). A quantidade de memória exigida por um processo pode crescer durante a sua execução:
* Malloc = memória "heap".
* Pilha do programa = ao executar funções, os endereços de retorno e as variáveis locais são armazenadas na pilha do programa.
O SO reserva espaço extra para expansão a cada processo ao seu carregado na memória. Se o espaço previsto for insuficiente:
* O processo é abortado;
* O processo é deslocado para outro espaço livre maior;
* Outro processo é enviado ao disco para liberar a memória para o processo originário da demanda.

## Gerenciamento de memória com Mapa de bits

O SO mantém 1 bit para indicar se cada bloco da memória (ou unidade de alocação) está ocupado (1) ou livre (0). A memória é dividida em unidades de alocação.
Considerações sobre o tamanho do bloco de memória:
* Quanto menor a unidade de alocação, maior será o mapa de bits.
* Pequeno: necessidade de muitos bits ⇒ uso ineficiente da memória. Exemplo: se tamanho do bloco = 1 byte, 1/9 da memória será utilizado para o mapa de bits.
* Grande: memória sub-utilizada, pois se o tamanho do processo não for múltiplo do tamanho da unidade de alocação, uma quantidade de memória considerável será desperdiçada no último bloco.
Vantagens do uso de mapa de bits:
* simplicidade: o tamanho do mapa depende apenas do tamanho da memória e das unidades de alocação.
Desvantagens:
* Quando um processo necessita de k unidades de alocação, o gerenciador de memória deve encontrar uma sequência de k bits 0, o que se constitui um processo lento.

## Gerenciamento com Listas Encadeadas

É mantida uma lista encadeada de segmentos alocados e vazios, sendo que cada segmento é um processo ou um buraco entre dois processos. A lista apresenta-se em ordem de endereços, e quando um processo termina ou é enviado para o disco, e a atualização da lista ocorre da seguinte maneira: cada processo, desde que não seja nem o primeiro nem o último da lista, apresenta-se cercado por dois segmentos, que podem ser buracos ou outros processos, o que nos dá as quatro possibilidades . O SO mantém uma lista ligada para indicar os segmentos de memória (sequência de blocos) livres (L) ou ocupados (P).
Cada nó contém os seguintes campos:
* Segmento de memória livre (L) ou ocupado (P);
* Início do segmento;
* Tamanho do segmento (em número de blocos);
* Próximo segmento.
A lista ligada pode estar ordenada pelo campo início do segmento (vantagem da atualização rápida da lista quando um processo termina):
* AXB ⇒ A_B
* AX_ ⇒ A__
* _XB ⇒ __B
* _X_ ⇒ ___
Os buracos adjacentes devem ser combinados num único. Para escolher o ponto em que deve ser carregado um processo recém criado ou que veio do disco por uma troca, vamos utilizar alguns algoritmos assumindo que o gerenciador de memória sabe quanto espaço alocar no processo:
* First Fit (primeiro encaixe): percorrer a fila até encontrar o primeiro espaço em que caiba o processo. É um algoritmo rápido.
* Next Fit (próximo encaixe): o mesmo que o algoritmo anterior, só que ao invés de procurar sempre a partir do início da lista, procura a partir do último ponto em que encontrou. Desempenho próximo ao anterior.
* Best Fit (melhor encaixe): consiste em verificar toda a lista e procurar o buraco que tiver espaço mais próximo das necessidades do processo. É mais lento, e desempenho pior que o First Fit.
* Worst Fit (pior ajuste): pega sempre o maior buraco disponível. Desempenho ruim.
Esses algoritmos podem ter sua velocidade aumentada pela manutenção de duas listas separadas, uma para processos e outra para buracos. Quando temos duas listas separadas, outro algoritmo é possível. É o Quick Fit (ajuste rápido), que consiste em manter listas separadas para alguns dos tamanhos mais comuns especificados (ex. uma fila para 2k, outra para 4k, outra para 8k etc). Neste caso, a busca de um buraco com o tamanho requerido, é extremamente rápido, entretanto, quando um processo termina, a liberação de seu espaço é complicada, devido à necessidade de reagrupar os buracos e modificá-los de fila.