tempo e não as deixar confusas? Você pode fazer isso da maneira mais difícil, ou pode fazer da forma mais fácil com Módulos de Ambiente.

Transcrição

1 REDES Módulos de ambiente em clusters REDES Módulos de ambiente em clusters Compartimentado Cedo ou tarde, cada cluster desenvolve uma infi nidade de ferramentas e bibliotecas para criar ou gerenciar aplicativos. Então, como você lida com situações em que precisa mudar o conjunto de ferramentas ou aplicativos? Tente os módulos de ambiente. por Jeff Layton Quando as pessoas começam a usar clusters, tendem a ficar com qualquer compilador e a biblioteca MPI ( Message Passing Interface ) que veio com o cluster quando ele foi instalado. Conforme os usuários ficam mais à vontade com o cluster, utilizando os compiladores e usando as bibliotecas MPI, eles podem começar a olhar ao redor em busca de outras opções: poderiam outros compiladores melhorar o desempenho da máquina? Da mesma forma, essas pessoas podem começar a olhar para outras bibliotecas MPI: será que elas podem ajudar a melhorar este desempenho? Há as outras bibliotecas MPI, ferramentas que podem tornar as coisas mais fáceis? Talvez ainda mais importante, essas pessoas gostariam de instalar a próxima versão dos compiladores ou bibliotecas MPI para que possam testá-las com o seu código. Então, essas questões forçam outra pergunta: como você pode ter múltiplos compiladores e múltiplas bibliotecas MPI no cluster ao mesmo tempo e não as deixar confusas? Você pode fazer isso da maneira mais difícil, ou pode fazer da forma mais fácil com Módulos de Ambiente. A maneira difícil Se você quer mudar seu compilador ou bibliotecas ou basicamente qualquer coisa relacionada com seu ambiente pode ser tentado a mudar seu $PATH no arquivo.bashrc (se você estiver usando o Bash) e, então, fazer logout e login novamente sempre que precisar mudar o seu compilador/combinação MPI. Inicialmente, isso parece um sofrimento, e é, mas funciona até certo ponto. No entanto, ele não opera na situação em que você deseja executar vários trabalhos, cada um com um diferente compilador/combinação MPI. Por exemplo, suponha que eu tenha um trabalho utilizando compiladores GCC [1] com Open MPI [2], então eu tenho um GCC e MPICH2 [3]. Se eu tenho dois trabalhos na fila ao mesmo tempo, como posso controlar o meu arquivo.bashrc para assegurar que cada trabalho tem o $PATH correto? A única maneira de fazer isso é limitar a um trabalho na fila de cada vez. Quando o trabalho for concluído, eu posso mudar o meu.bashrc e começar um novo trabalho. Como você está usando um compilador/combinação MPI diferente do outro em uma fila, até mesmo para algo tão simples como o desenvolvimento de código, é preciso prestar atenção quando o trabalho for executado para garantir que o seu.bashrc corresponderá ao seu job. A maneira mais fácil Uma maneira muito melhor de lidar com compilador/combinações MPI é a utilização de Módulos de Ambiente [4]. (Tenha cuidado para não confundir módulos de ambiente com módulos do kernel. ) Segundo o site, O pacote de módulos de ambiente provê a alteração dinâmica do ambiente de um usuário via modulefiles. Embora isso possa não fazer a terra tremer, na verda- 52

2 Módulos de ambiente em clusters REDES de é um salto quântico para a utilização de múltiplos compiladores/ bibliotecas MPI. Mas, você pode usá-lo para mais do que isso, o que vou falar mais adiante. Os módulos de ambiente podem ser utilizados para alterar ou modificar as variáveis de ambiente como $PATH, $MANPATH, $LD_LIBRARY_LOAD e outras. Por conta da maioria dos scripts de trabalho para gestão de recursos, tais como LSF [5], PBS-Pro [6], e MOAB [7], serem realmente scripts em Shell, você pode incorporar módulos de ambiente nos roteiros para definir o $PATH apropriado para o seu compilador/combinação MPI, ou quaisquer outras variáveis de ambiente que um aplicativo exija para trabalhar. O modo de instalar módulos de ambiente depende de como o cluster foi feito. Você pode compilar a partir da fonte ( quadro 1 ), ou você pode instalá-lo a partir do seu gerenciador de pacotes. Apenas certifique-se de procurar por Módulos de Ambiente (module files). Usando módulos de ambiente Para começar, vou assumir que os Módulos de Ambiente estão instalados e funcionando corretamente, assim você pode testar algumas das opções normalmente usadas. Neste artigo, vou usar alguns exemplos do TACC [8]. A primeira coisa a verificar é se os módulos estão disponíveis para você usando o comando module avail Este comando ( listagem 1 ) lista os módulos de ambiente disponíveis. Você notará que o TACC tem um número muito grande de possíveis módulos que oferecem uma gama de compiladores, bibliotecas MPI e combinações. Um número de aplicativos também aparece na lista. Você pode verificar quais módulos estão carregados em seu ambiente usando a opção list com o comando module : $ module list Currently Loaded Modulefiles: 1) Linux2) intel/11.1 3) mvapich2/1.4 4) sge/6.2u3 5) cluster 6) TACC Isso indica que quando logar, vou ter seis módulos já carregados para mim. No entanto, se eu quiser usar quaisquer módulos adicionais, tenho que carregá-los manualmente ( listagem 2 ). Para carregar aqueles que você quer, é possível, simplesmente, copiar e colar a partir da lista de módulos disponíveis. (É isso que eu faço, o que torna as coisas mais fáceis) Ao carregar um módulo, você apenas mudará as variáveis de ambiente definidas para esse módulo. Normalmente, são elas $PATH, $MANPATH, e $LD_LIBRARY_LOAD. Para descarregar ou remover um módulo, use a opção unload com o comando module, mas você deve especificar o nome completo do módulo de ambiente: $ module unload gotoblas2/1.08 $ module list Currently Loaded Modulefiles: 1) Linux 2) intel/11.1 3) mvapich2/1.44) sge/6.2u3 5) cluster 6) TACC Observe que o módulo gotoblas2/1.08 não é listado. Alternativamente, você pode descarregar todos os módulos carregados no ambiente com module purge : $ module purge $ module list No Modulefiles Currently Loaded. Você pode ver aqui que, após o comando module purge, os módulos de ambiente não estão mais carregados. Listagem 1: Comando module avail 01 $ module avail /opt/apps/intel11_1/modulefiles - 04 fftw3/3.2.2 gotoblas2/1.08 hdf5/1.8.4 mkl/ mvapich2/1.4 netcdf/4.0.1 openmpi/ /opt/apps/modulefiles 07 gnuplot/4.2.6 intel/11.1(default) papi/ intel/10.1 lua/5.1.4 pgi/ /opt/modulefiles 11 Linux TACC TACC-paths cluster /cm/shared/modulefiles 13 acml/gcc/64/4.3.0 fftw3/gcc/64/3.2.2 mpich2/smpd/ge/open64/64/1.1.1p1 14 acml/gcc/mp/64/4.3.0 fftw3/open64/64/3.2.2 mpiexec/0.84_ acml/gcc-int64/64/4.3.0 gcc/4.3.4 mvapich/gcc/64/ acml/gcc-int64/mp/64/4.3.0 globalarrays/gcc/openmpi/64/4.2 mvapich/open64/64/ acml/open64/64/4.3.0 globalarrays/open64/openmpi/64/4.2 mvapich2/gcc/64/ acml/open64-int64/64/4.3.0 hdf5/1.6.9 mvapich2/open64/64/ blacs/openmpi/gcc/64/1.1patch03 hpl/2.0 netcdf/gcc/64/ blacs/openmpi/open64/64/1.1patch03 intel-cluster-checker/1.3 netcdf/open64/64/ blas/gcc/64/1 intel-cluster-runtime/2.1 netperf/ blas/open64/64/1 intel-tbb/ia32/22_ oss open64/ bonnie++/1.96 intel-tbb/intel64/22_ oss openmpi/gcc/64/ cmgui/5.0 iozone/3_326 openmpi/open64/64/ default-environment lapack/gcc/64/3.2.1 scalapack/gcc/64/ fftw2/gcc/64/double/2.1.5 lapack/open64/64/3.2.1 scalapack/open64/64/ fftw2/gcc/64/float/2.1.5 mpich/ge/gcc/64/1.2.7 sge/6.2u3 28 fftw2/open64/64/double/2.1.5 mpich/ge/open64/64/1.2.7 torque/ fftw2/open64/64/float/2.1.5 mpich2/smpd/ge/gcc/64/1.1.1p1 Linux Magazine #90 Maio de

3 REDES Módulos de ambiente em clusters Se você estiver usando um gerenciador de recursos (agendador de tarefas), é provável que crie um script que solicita os recursos e executa o aplicativo. Neste caso, precisará carregar os Módulos de Ambiente corretos em seu script. Normalmente, após a parte do script em que você solicitar recursos (no mundo PBS, estes são chamados de comandos #PBS ), então irá carregar os módulos de ambiente que necessitar. Agora que eu mostrei alguns comandos básicos para a utilização de Módulos de Ambiente, vou um pouco mais a fundo, utilizando um módulo em um script e escrevendo o meu próprio módulo. Quadro 1: Módulos de Ambiente para Clusters Acho que a qualidade do código-fonte dos software livres melhorou durante os últimos anos para um ponto no qual a compilação e a instalação são bastante objetivas, mesmo que você nunca tenha compilado um código antes. E, caso não tenha, não sinta receio de começar com os módulos de ambiente. Para este artigo, como exemplo, vou compilar módulos de ambiente em um nó cabeça no cluster em /usr/local. Vou assumir que você tenha o NSF /usr/local exportado para os nós computacionais ou algum outro sistema de arquivos ou o diretório que está montado nos nós computacionais (talvez um sistema de arquivos global?). Se você estiver criando e testando seu código em um cluster de produção, certifi que-se de que o /usr/local está montado em todos os nós computacionais. Para começar, baixe a versão mais recente deve ser um arquivo *.tar.gz. (estou usando a v3.2.6, mas a última enquanto escrevo este artigo é a v3.2.9). Para facilitar as coisas, compile o código em /usr/local. A documentação que vem com os Módulos de Ambiente recomenda que seja compilado em /usr/local/modules/src. Como usuário root, execute os seguintes comandos: % cd /usr/local % mkdir Modules % cd Modules % mkdir src % cp modules tar.gz /usr/local/modules/src % gunzip -c modules tar.gz tar xvf - % cd modules Em seguida, recomendo que você leia atentamente o arquivo INSTALL, que irá salvar sua vida (a primeira vez que compilei Módulos de Ambiente, não o li e tive muitos problemas.) Antes de iniciar a confi guração e a compilação do código, você precisará cumprir alguns pré-requisitos. Primeiro, deve ter o Tcl instalado, bem como o Tcl Development. Por não saber qual sistema operacional ou distribuição está sendo utilizado, vou deixar para você a tarefa de instalar o Tcl e o Tcl Development no nó em que você estará compilando os Módulos de Ambiente. Agora, você deve confi gurar e compilar os Módulos de Ambiente. Como root, digite o seguinte: % cd /usr/local/modules/src/modules %./configure % make % make install O documento INSTALL recomenda criar um link simbólico em /usr/local/modules ligando a versão atual dos módulos de ambiente para um diretório chamado default : % cd /usr/local/modules % sudo ln -s default A razão pela qual recomendamos o uso do link simbólico é que quando atualizar os Módulos de Ambiente para uma nova versão, você o compila em /usr/local/modules/src e, então, cria um link simbólico de /usr/local/modules/<novo> para /usr/local/modules/default, o que torna mais fácil a atualização. A próxima coisa a fazer é copiar um (talvez mais) dos arquivos de inicialização dos Módulos de Ambiente para uma localização global para todos os usuários. Para meu cluster particular, escolhi o arquivo sh init. Este arquivo irá confi - gurar os Módulos de Ambiente para todos os usuários. Optei por usar a versão sh ao invés de csh ou bash, porque sh é o denominador comum: % sudo cp /usr/local/modules/default/init/sh /etc/profile.d/modules.sh % chmod 755 /etc/profile.d/modules.sh Agora, os usuários podem usar módulos de ambiente colocando apenas o seguinte em seu.bashrc ou.profile : %. /etc/profile.d/modules.sh Como um teste simples, você pode executar o script acima e digitar o comando module. Se você receber alguma informação sobre como usar os módulos, como o que veria se usou a opção -help, então quer dizer que você instalou os módulos de ambiente corretamente. 54

4 Módulos de ambiente em clusters REDES Módulos de ambiente nos scripts Nesta seção, vou mostrar como você pode usar módulos de ambiente em um script. Estou usando PBS para este exemplo rápido, com o seguinte trecho de código para a parte superior do script: #PBS -S /bin/bash #PBS -l nodes=8:ppn=2. /etc/profile.d/modules.sh module load compiler/pgi6.1-x86_64 module load mpi/mpich (insert mpirun command here) Na parte superior do fragmento de código estão as diretivas PBS que começam com #PBS. Após as diretivas PBS, chamo o script de inicialização dos Módulos de Ambiente ( modules.sh ). Imediatamente depois disso, você deve carregar os módulos de que precisa para seu trabalho. Para este exemplo em particular, tirado de um script escrito por mim há três anos atrás, carrego um compilador ( pgi-6.1-x86_64 ) e uma biblioteca MPI ( mpich ). Criando um arquivo de módulo Criar o seu próprio arquivo de módulo não é muito difícil. Se você conhecer um pouco de Tcl, o processo será muito fácil, no entanto, mesmo se você não sabe Tcl, é simples seguir um exemplo para criar seu próprio arquivo de módulo. Os próprios módulos definem o que você quer fazer no ambiente quando carregar o módulo. Por exemplo, você pode criar novas variáveis de ambiente que precisarão executar um aplicativo ou alterar o $PATH, $LD_LIBRARY_LOAD, ou $MANPATH para que um determinado aplicativo funcione corretamente. Acredite ou não, você ainda pode executar o código dentro do módulo ou chamar um aplicativo externo. Este recurso torna os Módulos de Ambiente muito flexíveis. Para começar, lembre-se de que todos os módulos são escritos em Tcl, o que os torna muito programáveis. Para o exemplo mostrado aqui, todos os arquivos de módulo ficam em /usr/local/modules/default/ modulefiles. Neste diretório, você pode criar subpastas para melhor rotular ou organizar seus módulos. Neste exemplo, vou criar um módulo para o gcc para criar e instalar na minha conta de usuário. Para começar, vou criar um subdiretório chamado compilers para qualquer arquivo de módulo que tem a ver com compiladores. Os módulos de ambiente têm uma espécie de modelo que você pode usar para criar o seu próprio módulo. Usei isso como ponto de partida para o meu módulo. Como root, faça o seguinte: % cd /usr/local/modules/ default/modulefiles % mkdir compilers % cp modules compilers/gcc O novo módulo vai aparecer na lista de módulos como compilers/gcc Listagem 2: Carregar módulos 01 $ module load gotoblas2/ $ module list 03 Currently Loaded Modulefiles: 04 1) Linux 3) mvapich2/1.4 5) cluster 7) gotoblas2/ ) intel/11.1 4) sge/6.2u3 6) TACC Listagem 3: Arquivo de módulo 01 #%Modu e1.0######################################################### 02 ## 03 ## modules compilers/gcc ## 05 ## modulefiles/compilers/gcc Escrito por Jeff Layton 06 ## 07 proc ModulesHelp { } { 08 global version modroot 09 puts stderr "compilers/gcc configura o Ambiente para o GCC em meu diretório pessoal" 10 } module-whatis "Configura o ambiente para usar compiladores gcc (C, Fortran)" 13 # somente para uso de script Tcl 14 set topdir /home/laytonj/bin/gcc set version set sys linux setenv CC $topdir/bin/gcc 19 setenv GCC $topdir/bin/gcc 20 setenv FC $topdir/bin/gfortran 21 setenv F77 $topdir/bin/gfortran 22 setenv F90 $topdir/bin/gfortran 23 prepend-path PATH $topdir/include 24 prepend-path PATH $topdir/bin 25 prepend-path MANPATH $topdir/man 26 prepend-path LD_LIBRARY_PATH $topdir/lib Listagem 4: Ajuda do módulo 01 home8:~> module help compilers/gcc Module Specific Help for 'compilers/gcc-4.6.2' compilers/gcc configura o Environment para o GCC em meu diretório pessoal Linux Magazine #90 Maio de

5 REDES Módulos de ambiente em clusters Recomendo que você olhe para o modelo para sentir o que a sintaxe e o que as várias partes dos arquivos de módulo estão fazendo. Novamente, lembre-se de que os Módulos de Ambiente usam Tcl como linguagem, mas você não tem que saber muito sobre Tcl para criar um arquivo de módulo. O que criei é mostrado na listagem 3. O arquivo pode parecer um pouco longo, mas na verdade é bastante compacto. A primeira seção fornece ajuda para este módulo em particular se um usuário solicitar (a linha que começa com puts stderr ) por exemplo a listagem 4. Você pode ter várias strings usando várias linhas puts stderr no módulo Listagem 5: which gcc 01 home8:~> which gcc 02 /usr/bin/gcc 03 home8:~> gcc -v 04 Reading specs from /usr/lib/gcc/i386-redhat-linux/3.4.3/specs 05 Configured with:../configure --prefix=/usr --mandir=/usr/share/man --infodir=/usr/share/info --enable-shared --enable-threads=posix --disable-checking --with-system-zlib --enable- cxa_atexit --disable-libunwind-exceptions--enable-java-awt=gtk --host=i386-redhat-linux Thread model: posix 06 gcc version (Red Hat ) Listagem 7: Descarregando o módulo 01 home8:~> module unload compilers/gcc home8:~> module list 03 No Modulefiles Currently Loaded. 04 home8:~> which gcc 05 /usr/bin/gcc 06 home8:~> gcc -v 07 Reading specs from /usr/lib/gcc/i386-redhat-linux/3.4.3/specs 08 Configured with:../configure --prefix=/usr --mandir=/usr/share/man --infodir=/usr/share/info --enable-shared --enable-threads=posix --disable-checking --with-system-zlib --enable- cxa_atexit --disable-libunwind-exceptions--enable-java-awt=gtk --host=i386-redhat-linux 09 Thread model: posix 10 gcc version (Red Hat ) Listagem 6: module avail 01 home8:~> module avail /usr/local/modules/versions /usr/local/modules/3.2.6/modulefiles - 07 compilers/gcc dot module-info null 08 compilers/modules module-cvs modules use.own 09 home8:~> module load compilers/gcc home8:~> module list 11 Currently Loaded Modulefiles: 12 1) compilers/gcc home8:~> which gcc 14 ~/bin/gcc-4.6.2/bin/gcc 15 home8:~> gcc -v 16 Using built-in specs. 17 Target: i686-pc-linux-gnu 18 Configured with:./configure --prefix=/home/laytonj/bin/gcc enable-languages=c,fortran --enable-libgomp 19 Thread model: posix 20 gcc version (o modelo tem várias linhas). Após a seção de ajuda no procedimento Module-Help, outra linha fornece algumas informações simples, quando um usuário utiliza a opção whatis, por exemplo: home8:~> module whatis compilers/gcc compilers/gcc : Configura o ambiente para usar compiladores gcc (C, Fortran) Após as definições help e whatis há uma seção onde crio quaisquer variáveis de ambiente necessárias, bem como modifico o $PATH, $LD_LIBRARY_PATH, e $MANPATH ou outras variáveis de ambiente padrão. Para tornar a vida um pouco mais fácil para mim, defini algumas variáveis locais: topdir, version e sys. Embora eu só tenha usado a topdir, defini as outras duas variáveis no caso de eu precisar voltar e modificar o módulo (as variáveis podem me ajudar a lembrar o que o módulo foi projetado para fazer). Neste arquivo de módulo em particular, defini um conjunto de variáveis de ambiente apontando para os compiladores (CC, GCC, FC, F77 e F90). Depois de definir as variáveis de ambiente, eu modifiquei o $PATH, $PATH_LD_LIBRARY, e $MANPATH para que o compilador vá primeiro nestes locais usando a diretiva prepend-path. O módulo básico que mostrei é bastante simples, mas pode ser muito sofisticado em caso de necessidade. Por exemplo, você poderia fazer um arquivo de módulo depender de outro, de modo que tenha que carregar um módulo específico antes de carregar aquilo que você quer. Além disso, poderá chamar aplicativos externos por exemplo, se quiser ver se um aplicativo está instalado e em funcionamento. Você está limitado apenas pelas suas necessidades e pela sua imaginação. Depois de ter definido um módulo, precisará verificar para se certifi- 56

6 Módulos de ambiente em clusters REDES O autor Jeff Layton é um especialista corporativo para HPC ( High Performance Computing ) na Dell. Além de computadores é um admirador de café. Gostou do artigo? Queremos ouvir sua opinião. o Fale conosco em cartas@linuxmagazine.com.brcom.b Este artigo no nosso so site: car de que funciona. Antes de carregar o módulo, verifique se o gcc está sendo usado ( listagem 5 ). Isto significa que o gcc está atualmente apontando para o gcc do sistema. (Sim, este é um GCC muito antigo; preciso atualizar meu computador de testes em casa). Em seguida, carregue o módulo e verifique qual GCC está sendo utilizado ( listagem 6 ). Isso significa que se você usa o gcc, acaba usando a versão criada em seu diretório pessoal. Como uma verificação final, descarregue o módulo (com o comando unload ) e verifique novamente quais são os locais padrão do gcc ( listagem 7 ). Observe que depois de descarregar o módulo, o gcc padrão remonta à versão original, o que significa que as variáveis de ambiente estão, provavelmente, corretas. Se você quiser ser mais radical, deve verificar todas as variáveis de ambiente antes de carregar o módulo, depois de carregar o módulo, e depois de descarregá-lo. Mas, neste momento, eu estou pronto para declarar: sucesso! Conclusão Para clusters, os módulos de ambiente são a melhor solução para lidar com múltiplos compiladores e bibliotecas, ou até mesmo aplicativos. Eles são fáceis de usar mesmo para iniciantes na linha de comando. Apenas alguns poucos comandos permitem adicionar e remover módulos de seu ambiente facilmente. Você pode até usá-los em scripts. Como foi visto, não é muito difícil escrever o seu próprio módulo e usá-lo. Os módulos de ambiente são verdadeiramente uma ferramenta indispensável para clusters. Mais informações [1] GCC 4.6.2: gcc.gnu.org/ [2] Open MPI 1.5.2: [3] MPICH2: [4] Módulos de Ambiente: [5] LSF: high-performance-computing/add-on-products/platform-lsf-family [6] PBS-Pro: [7] MOAB: [8] TACC: Tem novidade na Coleção Academy! Instalação e congifuração de servidores VoIP com Asterisk. Configuração de ramais, extensões, secretária eletrônica, monitoramento e espionagem de chamadas, planos de discagem, URA e muitos outros aspectos que abordam o uso de centrais telefônicas IP PBX. Disponível no site Linux Magazine #90 Maio de