LibNUMA

Cleverson Lopes LedurProf. Dr. Luiz Gustavo L. Fernandes Programação ParalelaPPGCC - PUCRS

Afinidade de Memória e CPU

10/2014

Resumo

● Revisão Arquiteturas○ SMP○ Arquiteturas UMA e NUMA○ Afinidade de Memória○ Afinidade de CPU

● API NUMA● LibNuma● Mai● Comparação Libnuma vs. Mai● Conclusão

Revisando Algumas Arquiteturas

SMP (Symmetric Multiprocessor)

No modelo SMP, o computador possui um único controlador de memória que é compartilhado por todos os processadores.

UMA (Unified Memory Access)

● Unified Memory Access

● Memória se torna um gargalo

● Aumento do número de processadores compromete a escalabilidade.

● Mesmo tempo de acesso à memória.

NUMA (Non Unified Memory Access)

● A memória é distribuída entre os processadores.

● A memória pode ser endereçada localmente ou remotamente.

● Tempo de acesso à memória é diferente.

Afinidade e NUMA

● Problemas com NUMA:

○ Threads das aplicações veem a memória como um espaço de memória único.

○ Acesso excessivo de memória em diferentes domínios NUMA.

Afinidade e NUMA

Em quais núcleos as threads ou processos estão rodando?

Onde a memória será alocada?

Afinidade e NUMA

Afinidade:

Em quais núcleos as threads estão rodando?

Onde a memória será alocada?

Afinidade de CPU: Vincular um processo ou thread em um núcleo. Se o sistema operacional interromper a tarefa, ela não será migrada para outro núcleo e irá esperar até que o núcleo esteja livre novamente.

Afinidade e NUMA

Afinidade:

Em quais núcleos as threads estão rodando?

Onde a memória será alocada?

Afinidade de CPU: Vincular um processo ou thread em um núcleo. Se o sistema operacional interromper a tarefa, ela não será migrada para outro núcleo e irá esperar até que o núcleo esteja livre novamente.

Afinidade de Memória: Alocação da memória o mais próximo possível do núcleo que está utilizando.

Políticas NUMA

A API NUMA possui políticas que podem ser utilizadas para áreas da memória ou para CPUs.

Cada regra tem como objetivo realizar uma acão que permita utilizar algum modelo de alocacão ou associação de CPU em uma thread.

Políticas NUMA

➔ Default◆ Alocar no nodo local.

➔ Bind◆ Alocar no conjunto de nodos.

➔ Interleave◆ Alocar de forma intercalada entre os nodos. (round-

robin)

➔ Preferred◆ Tentar alocar no nodo específico.

numactl

Ferramenta onde podemos rodar processos utilizando as políticas NUMA.

Possibilidade de uso para programas que não podem ser alterados ou recompilados.

Instalação no Ubuntu:sudo apt-get install numactl

numactl

Exemplo:

numactl --cpubind=0 --membind=0,1 nomeprograma

numactl

Exemplo:

numactl --cpubind=0 --membind=0,1 nomeprograma

Chamada numactl

Executar na CPU 0 Somente

Alocar a memória na CPU 0

e 1 somente

Nome do programa que será

executado com as políticas

Outras opções:

--preferred=<nodenum>

--interleave=nodemask

--membind=1

--localalloc

--hardware

numactl

Utilizar nodo específico preferêncialmente.Intercalar memória no conjunto de nodos (nodemask).

Aloca a memória no nodo da CPU 1.Aloca a memória somente no nodo local.Intercalar memória no conjunto de nodos (nodemask).

numactl

A numaclt permite a aplicação das políticas para programas já compilados, de uma forma geral.

É pouco eficiente quando necessitamos otimizar partes da memória ou determinadas threads dentro de um programa.

Para isso, podemos usar a biblioteca libnuma.

LibNUMA

libnuma

É uma biblioteca que faz a ligacão entre os programas e as políticas NUMA. Possui uma interface de alto nível que tem como base as chamadas da API NUMA.

Projeto mantido pela Silicon Graphics International Corp.Autor = Andi Kleen, SUSE LabsVersion 1.0.3-rc1 mantida por Cliff Wickman and Christoph Lameter, SGI

Instalação no Ubuntu:sudo apt-get install libnuma1 libnuma-dev

libnuma

#include <numa.h>

#include <stdio.h>

int main(){

if (numa_available() < 0) {

printf(‘‘Seu sistema não suporta a API NUMA\n’’);

}

}

libnuma: Nodemasks

Nodemasks são conjuntos de nodos.

nodemask_t mask;

nodemask_zero(&mask); //inicializo zerado

nodemask_set(&mask,maxnode); //add nodo

if (nodemask_isset(&mask,1)){ //maior = 1

…}

nodemask_clr(&mask,maxnode); //remove nodo

libnuma: Políticas

Com essas funções, todas as futuras alocações irão respeitar a política aplicada.

numa_set_preferred

numa_set_membind

numa_get_interleave_mask

numa_set_localalloc

libnuma: Políticas

Exemplo:

numamask_t oldmask = numa_get_interleave_mask();

//salva a configuração atual de política

numa_set_interleave_mask(&numa_all_nodes);

//aplica política de memória intercalada

//usando modelo round robin

… //realiza a alocação intercalada

numa_set_interleave_mask(&oldmask);

//volta a configuração antiga

libnuma: Vinculando CPUs

Funções para vincular threads em CPUs:

numa_run_on_node(1);

numa_set_prefered(1);

//Executar thread no node 1

nodemask_t mask;

nodemask_zero(&mask);

nodemask_set(&mask 1);

numa_bind(&mask);

//Também executa no node 1, mas usando numa_bind

libnuma: Vinculando CPUs

Liberar a thread para executar em qualquer nodo.

numa_run_on_node_mask(&numa_all_nodes);

//numa_all_nodes é uma mask com todos os nodos //disponíveis.

libnuma: Outras funções

numa_node_size

//retorna tamanho da memória do nodo.

numa_node_to_cpus

//retorna os números de todas as CPUs do nodo.

numa_exit_on_error

//finaliza o programa quando ocorrer algum erro.

Código Exemplo

Programa recebe [N0] [N1] [N2]

Bind processo para N0Bind memória para N1Escrever na memória alocada na N1Imprimir tempoBind na memória para N2memcpy do N1 para N2Imprimir tempo

Mai (Memory Affinity Interface)

Mai é uma interface de alto nível que disponibiliza funções para utilizar afinidade de memória em aplicações científicas executadas em arquiteturas ccNUMA.

Mai (Memory Affinity Interface)● Simples de utilizar (menos

complexo que a API NUMA, numactl, etc) e controle de memória mais sofisticado (diversas políticas de memória baseadas em vetores),

● Portabilidade (abstração do Hardware)

● Desempenho (desempenho melhor que outras soluções tradicionais).

Mai (Memory Affinity Interface)

Mai (Memory Affinity Interface)

Comparação Libnuma vs Mai

Item LibNUMA MaiComplexidade de

UtilizaçãoMédio Fácil

Alto Nível Sim Sim

CPU Affinity Sim Não

Memory Affinity Sim Sim

É necessário se preocupar com ponteiros e endereço de memória

Sim Não

Portabilidade Não Sim

ConclusãoApresentamos aqui uma biblioteca que permite a utilização de técnicas para ganho de desempenho em arquiteturas NUMA. Podemos verificar que com ela, podemos utilizar as políticas em partes da alocação da memória em forma particular, tendo um nível de detalhamento muito maior. Também foi verificada uma outra opção de biblioteca chamada Mai, que fornece uma interface de alto nível para a aplicação das políticas, abstraindo algumas configurações necessárias quando utilizando libnuma ou numaclt.

Embora a biblioteca libnuma ofereça a opção de utilização das políticas de uma forma bastante dinâmica, a biblioteca Mai se mostrou mais fácil de utilizar e mais completa uma vez que oferece mecanismos mais sofisticados para o tratamento da afinidade de memória. No entanto, não apresenta opções para utilizar Afinidade de CPU, presente na libnuma.

Referências