![Fechar [x]](http://dw1.s81c.com/i/c.gif){kind=small}
Supercomputadores são um exemplo clássico de uma corrida armamentista. Embora o desempenho crescente dos supercomputadores modernos se expanda em domínios de problemas novos, esses grandes sistemas estão fornecendo plataformas para resolver novos problemas. Supercomputadores são uma fonte de orgulho nacional e corporativo, já que as empresas e nações trabalham para melhorar a pontuação do LINPACK. A Figura 1 ilustra os últimos cinco anos da corrida armamentista da supercomputação, com o supercomputador IBM Sequoia, o atual líder projetado em 2012. Conforme mostrado, o IBM Roadrunner foi o primeiro supercomputador a quebrar a barreira sustentada do petaflop (e o IBM Blue Gene®/L se manteve no topo entre 2004 e 2008).
Figura 1. Desempenho dos supercomputadores: 2008 a 2012
Os primeiros supercomputadores foram desenvolvidos para modelar armas nucleares. Hoje, sua aplicação é muito mais diversificada, abordando grandes problemas computacionais nas áreas de pesquisa de clima, modelagem molecular, simulações físicas em grande escala e até quebra de código de força bruta.
O primeiro supercomputador é geralmente considerado como sendo o Control Data Corporation (CDC) 6600, lançado em 1964 (desenvolvido por Seymour Cray). O 6600 preenchia quatro gabinetes com hardware, um sistema de resfriamento Freon e uma única CPU com capacidade de 3 milhões de operações de vírgula flutuante por segundo (FLOPS). Embora não sejam desprovidos de estética, seus gabinetes eram visivelmente repletos de fios coloridos amarrando seus processadores de unidade periférica à única CPU para mantê-la o mais ocupada possível.
Avançando rapidamente para hoje, o atual supercomputador líder é o computador japonês Kei (desenvolvido pela Fujitsu). Esse sistema se concentra na capacidade de computação de força bruta, com mais de 88.000 processadores SPARC64 espalhados em 864 gabinetes. O supercomputador Kei se diferencia por quebrar a barreira de 10 petaflops. Semelhante ao CDC 6600, o Kei utiliza o resfriamento por água, além do resfriamento por ar.
Um supercomputador não é qualquer arquitetura particular, mas é simplesmente um design que está às margens do desempenho computacional. Hoje, isso significa um sistema que opera na faixa de desempenho de petaflops (ou quatrilhões de FLOPS), conforme medido pela referência LINPACK.
Independentemente de como o supercomputador atinge esses FLOPS, um objetivo de baixo nível de qualquer arquitetura de supercomputador é manter de forma ideal os recursos de computação ocupados quando há trabalho a fazer. Semelhante aos processadores periféricos CDC 6600, que existiam para manter sua única CPU ocupada, os supercomputadores modernos precisam da mesma capacidade fundamental. Vamos olhar para uma implementação de gerenciamento de recursos de nó de computação, chamada de Simple Linux® Utility for Resource Management (SLURM).
O SLURM é um gerenciador de clusters altamente escalável e tolerante a falhas e um sistema de planejamento de tarefas para grandes clusters de nós de computação. Ele mantém uma fila de trabalhos pendentes e gerencia a utilização global de recursos por esse trabalho. Também administra os nós de computação disponíveis de uma forma exclusiva ou não exclusiva (como uma função da necessidade de recurso). Finalmente, ele distribui tarefas para um conjunto de nós atribuídos para realizar o trabalho, além de monitorar as tarefas paralelas à sua conclusão.
Nos bastidores, o SLURM é um gerenciador de cluster robusto (com foco nas principais necessidades de recursos) que é altamente portátil e escalável para grandes clusters de nós, tolerante a falhas e, o mais importante, é um software livre. Ele começou como gerenciador de recursos de software livre, desenvolvido por várias empresas (incluindo a Lawrence Livermore National Laboratory) em um esforço colaborativo. Hoje, é um gerenciador de recursos líder em muitos dos supercomputadores mais eficientes.
O SLURM implementa uma arquitetura de gerenciamento de cluster bastante tradicional (consulte
a Figura 2). No topo, está um par redundante de
controladores de cluster (embora a redundância seja opcional). Esses controladores
de cluster funcionam como gerenciadores do cluster de computação e implementam um
daemon de gerenciamento chamado de slurmctld. O daemon slurmctld fornece monitoramento de recursos de
computação, mas, o mais importante, ele mapeia as tarefas (trabalho) recebidas para os recursos
subjacentes de computação.
Cada nó computacional implementa um daemon chamado
slurmd. O daemon
slurmd
gerencia o nó em que é executado, incluindo o monitoramento das tarefas que estão
sendo executadas no nó, aceitando o trabalho do controlador e mapeando esse
trabalho para tarefas nos núcleos dentro do nó. O daemon slurmd também pode interromper a execução de tarefas, caso seja solicitado pelo controlador.
Figura 2. Visualização de alto nível da arquitetura do SLURM
Existem outros daemons dentro da arquitetura—por exemplo, para implementar a autenticação segura. Porém, um cluster é mais do que apenas uma coleção aleatória de nós, já que alguns desses nós podem ser relacionados de forma lógica a pontos no tempo para computação paralela.
Um conjunto de nós pode ser coletado em um grupo lógico chamado de partição, que normalmente inclui uma fila de trabalho recebido. As partições podem ser configuradas com restrições quanto a quais usuários podem usá-las ou o tamanho do limite de tempo que a partição suporta. Um refinamento adicional de uma partição é o mapeamento de um conjunto de nós dentro de uma partição para um usuário por um período para o trabalho, que é chamado de uma tarefa. Dentro de uma tarefa há uma ou mais etapas de tarefas, que são conjuntos de tarefas em execução nesse subconjunto de nós.
A Figura 3 mostra essa hierarquia, que ilustra o particionamento de recursos do SLURM. Observe que esse particionamento inclui a consciência da proximidade de recursos para assegurar comunicação de baixa latência entre os nós de cooperação.
Figura 3. Particionamento de recursos no SLURM
Como instalar o SLURM depende, finalmente, do seu ambiente Linux em particular, mas o processo pode ser tão simples quanto usar um gerenciador de pacotes. O SLURM foi totalmente embalado, facilitando sua instalação e configuração. Para a minha distribuição favorita, Ubuntu, utilizo o Advanced Packaging Tool (APT) para instalar o pacote SLURM e todas as suas dependências:
$ sudo apt-get install slurm-llnl |
Essa operação consome menos de 40 MB de espaço e inclui não apenas o SLURM, mas todas as dependências, plug-ins básicos e outros pacotes necessários.
Antes de iniciar o SLURM, é preciso configurá-lo para seu ambiente específico. Para criar o meu arquivo de configuração, utilizei o configurador online do SLURM, que gera o arquivo de configuração com base em dados do formulário. Observe que o arquivo precisa ser repaginado ao final para remover opções que não eram mais suportadas. A Listagem 1 mostra o meu arquivo de configuração resultante (armazenado em /etc/slurm-llnl/slurm.conf).
Listagem 1. Arquivo de configuração do SLURM para um cluster de nó único
# arquivo slurm.conf gerado pelo configurator.html. # Coloque esse arquivo em todos os nós do seu cluster. # Consulte a man page slurm.conf para obter mais informações. # ControlMachine=mtj-VirtualBox # AuthType=auth/none CacheGroups=0 CryptoType=crypto/openssl MpiDefault=none ProctrackType=proctrack/pgid ReturnToService=1 SlurmctldPidFile=/var/run/slurmctld.pid SlurmctldPort=6817 SlurmdPidFile=/var/run/slurmd.pid SlurmdPort=6818 SlurmdSpoolDir=/tmp/slurmd SlurmUser=slurm StateSaveLocation=/tmp SwitchType=switch/none TaskPlugin=task/none # # TIMERS InactiveLimit=0 KillWait=30 MinJobAge=300 SlurmctldTimeout=120 SlurmdTimeout=300 Waittime=0 # # PLANEJAMENTO FastSchedule=1 SchedulerType=sched/backfill SchedulerPort=7321 SelectType=select/linear # # CRIAÇÃO DE LOG E CONTABILIDADE AccountingStorageType=accounting_storage/none ClusterName=cluster JobCompType=jobcomp/none JobCredentialPrivateKey = /usr/local/etc/slurm.key JobCredentialPublicCertificate = /usr/local/etc/slurm.cert JobAcctGatherFrequency=30 JobAcctGatherType=jobacct_gather/none SlurmctldDebug=3 SlurmdDebug=3 # # NÓS DE COMPUTAÇÃO NodeName=mtj-VirtualBox State=UNKNOWN PartitionName=debug Nodes=mtj-VirtualBox Default=YES MaxTime=INFINITE State=UP |
Observe que, em um cluster real, NodeName faria
referência a uma variedade de nós, como
snode[0-8191], para indicar 8192 nós exclusivos
(chamados de snode0 a snode8191) no cluster.
A etapa final é criar um conjunto de chaves credenciais de tarefa para o meu site. Escolho
usar o openssl para as minhas chaves credenciais
(que são referenciadas no arquivo de configuração na Listagem 1, como JobCredential*. Simplesmente, uso
openssl para gerar essas credenciais, como
na Listagem 2.
Listagem 2. Criando credenciais para o SLURM
$ sudo openssl genrsa -out /usr/local/etc/slurm.key 1024 Gerando a chave privada RSA, módulo de 1024 bits .................++++++ ............................................++++++ e é 65537 (0x10001) $ sudo openssl rsa -in /usr/local/etc/slurm.key -pubout -out /usr/local/etc/slurm.cert gravando a chave RSA |
Com a conclusão dessas etapas, tenho tudo que preciso dizer ao SLURM sobre a minha configuração. Agora, posso dar início ao SLURM e interagir com ele.
Para iniciar o SLURM, basta usar o script de gerenciamento definido em
/etc/init.d/slurm. Este script aceita iniciar,
stop, restartestartclean (para ignorar todos os estados salvos
anteriormente). Iniciar o SLURM com este método faz com que o daemon
slurmctld se inicie (bem como o daemon
slurmd em seu nó, nessa configuração
simples):
$ sudo /etc/init.d/slurm-llnl start |
Para validar que o SLURM esteja funcionando agora, use o
sinfo . O comando sinfo retorna informações sobre os nós e as partições do SLURM (neste caso, um único nó faz o seu cluster), como na Listagem 3.
Listagem 3. Usando o comando sinfo para visualizar o cluster
$ sinfo PARTITION AVAIL TIMELIMIT NODES STATE NODELIST debug* up infinite 1 idle mtj-VirtualBox $ |
É possível obter mais informações sobre o cluster do SLURM a partir da variedade
de comandos disponíveis no SLURM. Na transformação Iniciando o SLURM, vemos o comando
sinfo usado para saber mais sobre seu cluster.
É possível obter mais informações com o comando scontrol,
que permite visualizar informações detalhadas sobre os vários
aspectos do cluster (como na Listagem 4, a
partição e o nó).
Listagem 4. Obtendo informações mais detalhadas sobre um cluster com scontrol
$ scontrol show partição PartitionName=debug AllocNodes=ALL AllowGroups=ALL Default=YES DefaultTime=NONE DisableRootJobs=NO Hidden=NO MaxNodes=UNLIMITED MaxTime=UNLIMITED MinNodes=1 Nodes=mtj-VirtualBox Priority=1 RootOnly=NO Shared=NO PreemptMode=OFF State=UP TotalCPUs=1 TotalNodes=1 $ scontrol show node mtj-VirtualBox NodeName=mtj-VirtualBox Arch=i686 CoresPerSocket=1 CPUAlloc=0 CPUErr=0 CPUTot=1 Features=(null) Gres=(null) OS=Linux RealMemory=1 Sockets=1 State=IDLE ThreadsPerCore=1 TmpDisk=0 Weight=1 BootTime=2012-03-07T14:59:01 SlurmdStartTime=2012-04-17T11:10:43 Reason=(null) |
Para testar seu cluster do SLURM simples, é possível usar o
srun . O comando
srun aloca um recurso de computação e
lança uma tarefa para o seu trabalho. Observe que também é possível fazer isso separadamente (por meio de
salloc e sbatch). Como mostra a Listagem 5, você envia um
comando shell simples como a sua tarefa para demonstrar srun,
e, em seguida, envia um comando sleep (com um
argumento) e demonstra o uso do comando squeue
para mostrar as tarefas existentes no cluster.
Listagem 5. Enviando tarefas ao cluster e verificando o status da fila
$ srun -l hostname
0: mtj-VirtualBox
$ srun -l sleep 5 &
[1] 24127
$ squeue
JOBID PARTITION NAME USER ST TIME NODES NODELIST(REASON)
15 debug sleep mtj R 0:03 1 mtj-VirtualBox
$
[1]+ Done srun -l sleep 5
$
|
Observe que na Listagem 5 a tarefa enviada ao cluster pode ser um simples comando Linux, um arquivo de shell script ou um executável adequado.
Como exemplo final, veja como interromper uma tarefa. Neste caso, você inicia
uma tarefa de execução mais longa e usa squeue para identificar seu
ID. Em seguida, usa o ID da tarefa com o comando
scancel para finalizar essa etapa da tarefa (consulte a
Listagem 6).
Listagem 6. Finalizando uma etapa da tarefa
$ srun -l sleep 60 &
[1] 24262
$ squeue
JOBID PARTITION NAME USER ST TIME NODES NODELIST(REASON)
16 debug sleep mtj R 0:03 1 mtj-VirtualBox
$ scancel 16
srun: Force Terminated 16
$ srun: Job step aborted: Waiting up to 2 seconds for job step to finish.
0: slurmd[mtj-VirtualBox]: error: *** STEP 16.0 CANCELLED AT 2012-04-17T12:08:08 ***
srun: error: mtj-VirtualBox: task 0: Terminated
[1]+ Exit 15 srun -l sleep 60
$
|
Por fim, é possível interromper o cluster usando o mesmo script
slurm-llnl , como na Listagem 7.
Listagem 7. Interrompendo o cluster do SLURM
$ sudo /etc/init.d/slurm-llnl stop
* Stopping slurm central management daemon slurmctld [ OK ]
* Stopping slurm compute node daemon slurmd [ OK ]
slurmd is stopped
$
|
Ao contrário do Apache Hadoop, o SLURM não possui conceitos de um sistema de arquivos distribuído. Como tal,
requer um pouco mais de processamento para distribuir dados para os nós
para um dado cálculo. O SLURM inclui um comando chamado de
sbcast, que é usado para transferir um arquivo para todos os nós
alocados para uma tarefa do SLURM. É possível—e possivelmente
mais eficiente—usar um sistema de arquivos paralelo ou distribuído entre os nós de um
cluster do SLURM, não requerendo, assim,
sbcast para distribuir dados ao processo.
Nessa simples demonstração do SLURM, você usou um subconjunto dos comandos disponíveis e
um subconjunto ainda menor das opções disponíveis para esses comandos (por exemplo,
veja as opções disponíveis no
srun do UNIX). Mesmo com o número mínimo de comandos disponíveis, o
SLURM implementa um gerenciador de cluster capaz
e eficiente.
O SLURM não é um gerenciador de recursos estático, mas sim altamente dinâmico, que pode incorporar novos comportamentos. Ele implementa uma interface de programação de aplicativo (API) de plug-in que permite que bibliotecas de tempo de execução sejam carregadas de forma dinâmica no tempo de execução. Essa API tem sido usada para desenvolver uma variedade de novos comportamentos, incluindo uma malha de interconexão, autenticação e planejamento. As interfaces de plug-in suportam diversos outros recursos, como a contabilização da tarefa, funções criptográficas, Message Passing Interface (MPI), rastreamento de processos e seleção de recursos. Tudo isso permite que o SLURM suporte facilmente arquiteturas e implementações de cluster diferentes. Verifique o Guia do Programador do SLURM em Recursos) para obter detalhes.
O que está por vir para o SLURM?
Em 2011, o SLURM foi atualizado com diversas funcionalidades novas, incluindo o suporte parcial ao supercomputador IBM Blue Gene/Q e aos computadores Cray XT e XE. O suporte para grupos de controle do Linux (cgroups) também foi incluído, o que proporciona maior controle sobre os contêineres de processo do Linux.
Em 2012, o suporte ao Blue Gene/Q será totalmente implementado, juntamente com a seleção de recursos melhorada em função da necessidade da tarefa e das capacidades de recursos (por exemplo, o recurso de nó AMD). Uma nova ferramenta está prevista para relatar estatísticas de planejamento e, em um futuro próximo, uma ferramenta de administração baseada na web. Outro plano futuro para o SLURM está no contexto do bursting de nuvem, que envolve a alocação de recursos em um provedor de nuvem e a migração de trabalho de estouro de um cluster local para a nuvem (também executando daemons do SLURM). Esse modelo pode ser bastante útil e apoia a ideia de elasticidade dentro das cargas de trabalho de determinados supercomputadores.
Finalmente, os desenvolvedores do SLURM estão considerando o uso de energia e dados térmicos para distribuir de forma mais eficaz o trabalho em um cluster—por exemplo, a colocação de tarefas que consumirão alta potência (e, portanto, irão gerar mais calor) em áreas do cluster que são mais propensas a dispersar calor.
Esta breve introdução ao SLURM ilustra a simplicidade desse gerenciador de recursos de software livre. Embora os supercomputadores modernos estejam além da faixa de preço acessível para a maioria das pessoas, o SLURM fornece a base para um gerenciador de cluster escalável que pode transformar servidores de mercadoria em um cluster de alto desempenho. Além disso, a arquitetura do SLURM facilita a customização do gerenciador de recursos para qualquer arquitetura de supercomputador (ou cluster de mercadoria). Provavelmente, é por isso que o gerenciador de clusters é líder no espaço de supercomputadores.
Aprender
- SLURM: A Highly Scalable Resource Manager tem um website útil administrado no Lawrence Livermore National Laboratory. Este site fornece uma visão geral do SLURM, uma grande lista de publicações e apresentações, documentação e seção de Perguntas Mais Frequentes útil. Também é possível encontrar apoio profissional concedido pelos desenvolvedores do SLURM em SchedMD.
- A Brief History of Supercomputing, de Gordon Bell, da Microsoft, apresenta uma história interessante (embora um pouco antiquada) de supercomputação, desde o CDC 6600 até os clusters Beowulf.
- The LINPACK Benchmark: Past, Present, and Future (Jack Dongarra, Piotr Luszczek e Anttoine Petitet) fornece uma introdução útil à história do LINPACK e internos. Ele também demonstra o LINPACK ao longo de um conjunto de hardware comum (AMD Athlon, Intel® Pentium®, e assim por diante).
- SLURM Elastic Computing implementa o recurso chamado de bursting na nuvem, que permite que um cluster cresça e diminua conforme a função das necessidades incumbidas a ele. Em particular, o crescimento do cluster usa os recursos de nuvem pública para aumentar de forma rentável a capacidade do cluster.
- The Top500 project mantém uma classificação dos supercomputadores mais rápidos do mundo, juntamente com detalhes sobre os sistemas atuais e históricos. O Top500 lança a sua lista atualizada duas vezes por ano. Não surpreendentemente, todas as últimas dez posições no Top500 foram executadas em Linux.
- Os supercomputadores da IBM têm uma história longa e distinta. Confira esta referência da Wikipédia para obter uma lista e os detalhes de alguns dos supercomputadores desenvolvidos pela IBM.
- O Guia do Programador do SLURM fornece uma introdução legível para desenvolver plug-ins e, em geral, para conhecer o layout da fonte e documentação do SLURM.
- A Ferramenta de Configuração do SLURM fornece uma maneira simples de gerar um arquivo slurm.conf a partir de um simples formulário de entrada. Depois de inserir o conjunto necessário de informações, o website emite um slurm.conf que está pronto para ser inserido em seu cluster.
- Na rotina zona Linux do developerWorks, encontre vários artigos de instruções e tutoriais, bem como downloads, fóruns de discussão e muitos outros recursos para desenvolvedores e administradores Linux.
- O zona de software livre do developerWorks fornece muitas informações sobre ferramentas de software livre e de como utilizar tecnologias de software livre.
- especializadas em artigos que cobrem diversas soluções baseada na web.
- Fique por dentro dos eventos técnicos e webcasts do developerWorks com ênfase em uma série de produtos IBM e assuntos relacionados ao segmento de mercado de TI.
- Participe de um briefing gratuito
do developerWorks para se atualizar rapidamente sobre produtos e ferramentas IBM e tendências do segmento de mercado de TI.
- Acompanhe as demos on demand do developerWorks , que abrangem desde demos de instalação e configuração de produtos para iniciantes até funcionalidades avançadas para desenvolvedores experientes.
- Siga os tweets do Tim no Twitter. Também é possível seguir o DeveloperWorks no Twitter, ou inscreva-se em um feed de tweets sobre o Linux no developerWorks.
Obter produtos e tecnologias
- Avalie produtos IBM da maneira que for melhor para você: faça download da versão de testes de um produto, avalie um produto online, use-o em um ambiente de nuvem ou passe algumas horas na SOA Sandbox para saber como implementar arquitetura orientada a serviço (SOA) de maneira eficiente.
Discutir
- Confira os blogs do developerWorks e participe da
comunidade do developerWorks.
- Participe dos comunidade do developerWorks. Entre em contato com outros usuários do developerWorks e explore os blogs, fóruns, grupos e wikis voltados para desenvolvedores.
M. Tim Jones é arquiteto de firmware embarcado e autor de Artificial Intelligence: A Systems Approach, GNU/Linux Application Programming (agora em sua segunda edição), AI Application Programming (em sua segunda edição) e BSD Sockets Programming from a Multilanguage Perspective. Seu conhecimento em engenharia varia do desenvolvimento de kernels para naves espaciais geossíncronas até a arquitetura de sistemas embarcados e o desenvolvimento de protocolos de rede. Tim é arquiteto de plataforma da Intel e autor em Longmont, Colorado.
