Memórias Database Oracle (SGA x PGA) - Entenda a diferença e como calcular a HugePages

Este artigo tem a pretensão de explicar a diferença da SGA para PGA e como calcular a HugePages para melhor performance e gerenciamento da paginação/memória em seu ambiente.

[ Hits: 1.065 ]

Por: Carolina Robles das Neves em 28/10/2020 | Blog: https://www.linkedin.com/in/carolina-robles-das-neves-933289100/


Introdução



SGA - System Global Área

A SGA (System Global Área) é uma área de memória compartilhada disponibilizada pelo Oracle Database.

Esta memória, pode ser utilizada por todos os processos derivados do Oracle e tem como objetivo prover:
  • Cache de buffer do banco de dados;
  • Buffer de RedoLog;
  • Shared Pool;
  • LargePool;
  • Java Pool;
  • Streams Pool;

Geralmente, a SGA é calculada da seguinte forma:

Total da memória física do sistema Operacional / 2 = Valor SGA do seu database (isso irá depende da aplicação e arquitetura que irá utilizar o Banco de dados).

A Oracle recomenda que uma SGA de 10g, ou acima, seja configurado o HugePages no S.O (explicarei no final do artigo).

A SGA é dinâmica e alocada quando se inicia a instância.

PGA - Program Global Área

O PGA (Program Global Área) é uma área da memória dedicada exclusivamente para cada processo Oracle (entenda que o processo pode ser uma conexão ao banco de dados).

Normalmente, nesta sessão de memória encontramos:
  • Área de SQL: área onde os queries, as binds e demais atributos de queries executadas permanecem;
  • Memória de Sessão: onde os valores das variáveis (deste processo) permanecem.

Simplificando, cada vez que você se conecta ao banco de dados Oracle, uma área de memória no servidor (PGA) será dada exclusivamente para sua conexão. Porém, tudo que sua sessão executar no servidor usará a memória dedicada à instancia (SGA).

Resumo:
  • SGA - Memória dedicada à instancia.
  • PGA - Memória dedicada aos processos da instancia.

HugePages

HugePages é uma funcionalidade presente no kernel 2.6 que permite que o sistema operacional trabalhe com páginas de até 2MB (x86-64), ao invés do tamanho default de 4KB. Esta funcionalidade é útil quando trabalhamos com servidores com grande quantidade de memória.

Os Sistemas Operacionais Linux possuem uma característica muito interessante chamada de HugePages, que quando usada por um banco Oracle oferece grandes ganhos de performance.

HugePages consiste em tornar os blocos de alocação de memória muito maiores do que os 4KB padrão. No Linux, os HugePages possuem 2MB. Outra vantagem é que os HugePages são sempre alocados na memória física e nunca vão para a área de SWAP. Na verdade, esses blocos de memória sequer são considerados como candidatos a ir para SWAP.

Benefícios:
  • Não utiliza SWAP, portanto, evita-se o overhead existente no mecanismo de page-in/page-out;
  • Elimina a busca por páginas em SWAP;
  • O processo KSWAPD será muito requisitado caso tenha que gerenciar uma grande quantidade de páginas de memória e certamente utilizará uma grande quantidade de processamento da máquina. Quando HugePages é implementado, este processo não é envolvido no gerenciamento.

Para implementar HugePages em Oracle 11g, é necessário desabilitar a funcionalidade de gerenciamento automático de memória, que torna a alocação de memória SGA dinâmica.

Além disso, os seguintes passos abaixo, já conhecidos de versões anteriores, são necessários na implementação.

Passos

1. Verificar a compatibilidade:

cat /proc/meminfo | grep -i huge
HugePages_Total: 0 #Está zerado o total de paginação, ou seja, a hugepage não está funcionando ou configurada.
HugePages_Free: 0
HugePages_Rsvd: 0
Hugepagesize: 2048 kB


2. Verificar se o gerenciamento automático de memória do Oracle está desabilitado:

SQL> show parameter memory_target
NAME TYPE VALUE

memory_target big integer 0


Para implementar HugePages no Linux x86-64, a Oracle recomenda que o valor de memlock seja maior que o tamanho da SGA.

3. Calcular "nr_hugepages" utilizando o script "hugepages_settings.sh" oferecido pela Oracle no seguinte nota: Oracle Linux: Shell Script to Calculate Values Recommended Linux HugePages / HugeTLB Configuration (Doc ID 401749.1)

Irei disponibilizar o script na minha conta com o nome: "hugepages_settings.sh"

Esse script lhe permite achar o valor exato para o parâmetro: nr_hugepages

Execute o script com o "user owner" do seu banco de dados, no meu caso, é oracle "./hugepages_settings.sh" e ele apresentará a saída com o valor do vm.nr_hugepages = "<Valor_recomendado>"

Como é feito essa conta

Para você saber como calcular o valor correto para seu ambiente, segue abaixo script para te ajudar no calculo.

Lembrando que você precisa setar as variáveis antes de executar o comando manualmente.

Exemplo:

free -m
total       used       free     shared    buffers     cached
Mem:        129013     126167       2845          0        521       5976
-/+ buffers/cache:     119669       9344
Swap:       129151       1100     128051


export MEMTOTAL=129013
#kernel.shmmax
MEMTOTAL=$(cat /proc/meminfo | grep -i MemTotal | sed -n "s/://p" | awk {' print $2 '})
SHMMAX=$(echo| awk -v memtotal="$MEMTOTAL"  'BEGIN{ printf("%.f ",(memtotal*1024)*0.5) }')


Para saber o valor, faça um "echo" na variável após rodar o comando;

echo $MEMTOTAL
echo $SHMMAX


# kernel.shmall
SOMA_SGA=26843545600(VALOR EM BYTES)
OSPAGESIZE=$(getconf PAGESIZE)
SHMALL=$(echo| awk -v sga="$SOMA_SGA" -v ospagesize="$OSPAGESIZE" 'BEGIN{ printf("%.f ",(sga+(sga*0.02))/(ospagesize)) }')


# vm.nr_hugepages
SOMA_SGA=26843545600
HPSIZE=$(cat /proc/meminfo | grep -i Hugepagesize | sed -n "s/://p" | awk {' print $2 '})
HUGEPAGES=$(echo| awk -v sga="$SOMA_SGA" -v hpsize="$HPSIZE" 'BEGIN{ printf("%.f ",(sga+(sga*0.02))/(hpsize*1024)) }')


# memlock
MEMTOTAL=$(cat /proc/meminfo | grep -i MemTotal | sed -n "s/://p" | awk {' print $2 '})
MEMLOCK=$(awk -v MEMTOTAL="${MEMTOTAL}" 'BEGIN{ printf ("%.f ",((MEMTOTAL)*0.9) )}')


Eu utilizo uma planilha que eu insiro a quantidade dos processos abaixo do meu database e o Excel faz todo o cálculo da minha HugePages e arquivos de parâmetros do sistema Operacional para os processos do Oracle:
  • memtotal (kb) servidor
  • processes (oracle)
  • Tamanho SGA RDBMS (Mb)
  • Tamanho SGA ASM (Mb)

Publiquei hoje, junto com esse artigo em scripts, nome: Cálculo de HugePages - Excel - Porém, está com o status construção. Caso não fique disponível, me enviem mensagem que encaminho a planilha.

O que essa planilha faz e como é feito o cálculo

Com os valores informados dos processos do oracle (citado acima), o Excel te informa o valor exato com a soma para os seguintes parâmetros;

>> /etc/sysctl.conf
kernel.shmmax=<VALOR_EXATO>
kernel.shmmni=<VALOR_EXATO>
kernel.shmall=<VALOR_EXATO>
kernel.sem=<VALOR_EXATO>

vm.nr_hugepages=<VALOR_EXATO>

>> /etc/security/limits.conf
oracle soft memlock <VALOR_EXATO>
oracle hard memlock <VALOR_EXATO>

A fórmula de como é feito o calculo está disponível no Excel.

Abaixo, descrevo como configurar a HugePages no Sistema Operacional.

Configurando HugePages no Sistema Operacional

Explicação e calculo de paginação da HugePages:

1. 512 Páginas = 2048 kB (default, com o comando cat /proc/meminfo | grep -i huge, você pode verificar o valor na linha "Hugepagesize").

No nosso exemplo, queremos aumentar para 12G, então quantas páginas precisamos?

(12 x 1024 x 1024) / 2048 = 6144 páginas

2. Como calcular a hugepages por paginação em GigaBytes?

[Server]/home/oracle> cat /proc/meminfo | grep -i huge
HugePages_Total: 40320   <--- x2 / 1024 = Valor da sua SGA em GB
HugePages_Free:  14031
HugePages_Rsvd:   1041
Hugepagesize:     2048 kB


O valor: HugePages_Total x 2 = 80.440 / 1024 = 78 - neste caso acima, poderia ter uma SGA de 78GB.

Obs.: se o HugePages estiver maior que a SGA, o banco vai subir normalmente. Quando a gente tenta minimizar o espaço a mais no HugePages, é porque esse valor fica reservado no sistema operacional, ou seja, é um pedaço de memória que poderia estar sendo usado para outras coisas.

3. Passo a passo para configurar a Hugepages;

A. Crie um mount point do tipo hugetlbfs:

mkdir /mnt/hugepages
chmod -R 777 /mnt/hugepages
mount -t hugetlbfs nodev /mnt/hugepages

B. Adicione a seguinte linha no arquivo dos pontos de montagem do S.O: /etc/fstab:

hugetlbfs /mnt/hugepages hugetlbfs rw,mode=0777 0 0

4. Adicione a linha no seguinte arquivo: /etc/sysctl.conf

echo "vm.nr_hugepages = 60211" >> /etc/sysctl.conf

5. Execute o seguinte comando para efetivar a mudança:

# sysctl -p

6. Verifique se alterou a hugepages:

cat /proc/meminfo | grep Huge
HugePages_Total: 60211  <--- Valor da paginação setado acima
HugePages_Free: 60211
HugePages_Rsvd: 0
Hugepagesize: 60211kB


Pronto, sua HugePages já foi configurada e está em uso!

   

Páginas do artigo
   1. Introdução
Outros artigos deste autor

Expandindo partição em LVM

Criação de usuário, grupo e permissão

Principais Processos em Background do Banco de Dados Oracle

Rsyslog - Configurando o Centralizador de Logs

Configurando hostname, rotas, gateway e IP em Red Hat 6

Leitura recomendada

Oracle 10g: Startup automático

Configurando o SuSE Linux para o Oracle 10g

Processo de replicação de SCHEMA no Oracle

Configurando um servidor PHP5 com suporte ao Oracle no Ubuntu 9.10

Configurando uma instância do Oracle para acesso via Python

  
Comentários
[1] Comentário enviado por valter.vieira em 29/10/2020 - 20:16h

Parabens, gostei do artigo aprendi mais uma como otimizar a utilizacao do Oracle, ja favoritei.

[2] Comentário enviado por removido em 02/11/2020 - 18:28h

Muito Bom Zé Cabeça Carolzita -)

[3] Comentário enviado por mauricio123 em 10/11/2020 - 12:29h


Bem interessante.

___________________________________________________________
[code]Conhecimento não se Leva para o Túmulo.
https://github.com/MauricioFerrari-NovaTrento [/code]


Contribuir com comentário




Patrocínio

Site hospedado pelo provedor RedeHost.
Linux banner
Linux banner
Linux banner

Artigos

Dicas

Tópicos

Top 10 do mês

Scripts