Arquivo

Posts Tagged ‘computação científica’

Executando Mathematica remotamente

terça-feira, 12 abr 2011; \15\UTC\UTC\k 15 Deixe um comentário

O Mathematica tem uma função muito interessante de execução remota que poucas pessoas fazem uso já que a implementação original é péssima.

Se você tem a sua disposição um cluster ou grid de computação de alta performance onde o Mathematica está instalado, você pode carregar a interface gráfica do Mathematica no seu computador mas executar todos os comandos na outra máquina de melhor performance. Não é necessário usar nenhum terminal bash; o Mathematica entre os dois computadores conversam sozinhos. Pelo menos para mim essa conexão é bem mais rápida do que carregar a GUI do Mathematica inteira remotamente, i.e. usando algo como o X11 forwarding.

Primeiro, você tem que ter o Mathematica instalado nas duas máquinas. Não é necessário que sejam a mesma versão, mas observe que o núcleo do Mathematica que será executado é o do computador remoto. Qualquer pacote a ser usado deve estar instalado lá. Note também que a versão do Mathematica que será executada é a do computador remoto; então se você tiver Mathematica 8 instalado no seu computador mas o núcleo instalado no computador remoto for Mathematica 7, você não vai poder usar nada específico do Mathematica 8.

O Mathematica possui dois elementos: o núcleo (Kernel) e a interface gráfica. Os Notebooks são uma espécie de script para o kernel. Você pode ter mais de um kernel funcionando ao mesmo tempo. Por padrão, o Mathematica vem configurado para executar um único kernel. Com o tutorial que se segue, você vai adicionar mais kernels ao Mathematica que serão executados em outro computador.

Mais de um Kernel não deve ser confundido com computação em paralelo, que o Mathematica implementa com subkernels. Hoje em dia com clusters e processadores multi-core, cada Kernel do Mathematica admite subkernels, um para cada processador. Em uma máquina Dual Core por exemplo, você pode configurar dois subkernels de um dado kernel. Em uma máquina com 12 processadores, você pode ter até 12 subkernels. O Mathematica não invoca subkernels automaticamente, ele por padrão usará um único core do seu computador. Ou seja, se você tem um Intel Quad Core 2.0 GHz, o Mathematica usa apenas um dos quatro processadores 2.0GHz. Para executar mais de um subkernel você deve prefixar os seus comandos com algo como o Parallelize:

primes = Table[Prime[10^i], {i, 11}]; IntegerLength /@ primes // Parallelize // AbsoluteTiming

Por padrão, ao usar esse comando o Mathematica invocará o número máximo de subkernels possíveis. Em um Quad Core, são 4. Ele então vai dividir a tarefa entre os 4 processadores. Nem todos os processos podem ser divididos em subkernels, no entanto. Após iniciar uma execução remota do Mathematica para um cluster de alta performance, se você quiser usar todo o potencial do cluster, terá que executar comandos como o Parallelize. Em uma computação longa com muita paralelização, é recomendável inicializar os subkernels com o comando LaunchKernels[].

O Mathematica não tem uma implementação satisfatória de execução remota. Os problemas são vários, e.g. portas aleatórias de conexão, que quase sempre serão bloqueadas por Firewall. A alternativa abaixo usa uma conexão ssh do computador local para o remoto e transfere toda a comunicação do kernel remoto por ssh.

 

Passo 1: Instalar scripts

Devido a limitação do WordPress.com, eu renomeei os arquivos para .doc. Primeiro, você precisa baixar os seguintes arquivos dependendo da sua plataforma e salvá-los no seu computador. Importante: eu só testei para o MacOSX.

  • Mac OS X: tunnel e ssh-askpass para ~/Library/Mathematica/FrontEnd (sua home, não o diretório raiz), como tunnel.sh e ssh-askpass (o último sem extensão).
  • Linux: tunnel para ~/.Mathematica/FrontEnd como tunnel.sh.
  • Windows: tunnel.bat, para algo como
    \Documents and Settings\seu_usuario_windows\Application Data\Mathematica\FrontEnd, salve-o como tunnel.bat.

No Mac OS X e no Linux, após transferir e renomear os arquivos, execute o Terminal e aplique os comandos chmod +x tunnel.sh e chmod +x ssh-askpass no diretório onde os scripts foram salvos.

Passo 2: Configurar o Mathematica

No Mathematica no seu computador, siga estes passos:

  1. Acesse o menu Evaluation > Kernel Configuration Options.
  2. Clique em “Add”.
  3. Escolha um nome para o núcleo, e.g. “Cluster remoto”.
  4. Marque a opção “Append name to…” se quiser que os comandos executados no computador remoto e os resultados do computador remoto sejam explicitamente identificados no Notebook do Mathematica. Por exemplo, cada resultado será prefixado como Out [Cluster remoto]: =.
  5. No Mac, por uma questão de compatibilidade com o Linux, marque “Translate Return into New Line”.
  6. Marque “Advanced Options”

Os próximos passos requerem mais explicação:

Arguments to MLOpen deve conter verbatim, uma única linha:

-LinkMode Listen -LinkProtocol TCPIP -LinkOptions MLDontInteract -LinkHost 127.0.0.1

Launch Command para Mac ou Linux

"`userbaseDirectory`/FrontEnd/tunnel.sh" user@remote_machine
"/mathematica/default/Executables/math" "`linkname`"

e para Windows:

"`userbaseDirectory`\FrontEnd\tunnel.bat" user@remote_machine
"/mathematica/default/Executables/math" "`linkname`"

onde /mathematica ... /math deve ser substituído pelo caminho completo do executável de linha de comando do Mathematica no computador remoto. Esse arquivo estará no diretório do executável do Mathematica com nome math. Substitua também user@remote_machine pelo seu login (user) seguido do endereço IP ou hostname do computador remoto.

No Windows, você ainda precisará do PuTTY.

Pronto. Ao abrir um Notebook, o Kernel remoto pode ser escolhido no menu Evaluation > Notebook’s Kernel. Você pode forçar a inicialização do Kernel em Evaluation > Start Kernel. No Mac, uma janela aparecerá perguntando sua senha; no Linux o Terminal fará isso. Se tudo der certo, o Mathematica local irá inicializar o kernel remoto. O bash script tunnel.sh e o tunnel.bat salvam no diretório onde eles estão um arquivo .log, útil para debug.

Sobre esse tutorial: Essa estratégia foi desenvolvida por Sascha Kratky. O ssh-askpass para Mac foi escrito por Richard Brittain, especialista em computação aqui em Dartmouth College.

Anúncios

Relatividade Geral no Mathematica

sábado, 5 mar 2011; \09\UTC\UTC\k 09 4 comentários

Esse post é diferente do que eu escrevo usualmente, será um tutorial de um programa em desenvolvimento para fazer contas simbólicas em gravitação no Mathematica. Isso pode ser muito últil em um curso de Relatividade Geral da pós-graduação e teoria quântica de campos em espaço-tempos curvos, além de pesquisa.

Primeiro, você vai precisar do pacote xAct:

http://www.xact.es/

O xAct é dividido em vários subpacotes, eu vou me concentrar nos dois primeiros destes aqui:

  1. xTensor: permite usar a mesma notação de tensores usada na física, dentro do Mathematica. É a função principal do xAct.
  2. xCoba: permite definir sistemas de coordenadas.
  3. xPert: teoria de perturbação em gravitação.

Eu coloquei o terceiro acima para chamar a sua atenção. O objetivo do xAct é permitir escrever contas complicadas usando tensores, o que se tornou necessário com o avanço da cosmologia que hoje já requer perturbação em segunda ordem em Relatividade Geral.

Leia mais…

A semana nos arXivs…

quarta-feira, 1 jul 2009; \27\UTC\UTC\k 27 2 comentários


P.S.: No Brasil, eu sempre soube que “cappuccino” era café com leite e chocolate. Infelizmente, o resto do mundo todo chama esse danado de “caffé mocha” — enquanto que cappuccino é o nome dado pra café com leite e espuma [de leite]. Vai saber… mas, pelo menos, agora eu tenho uma tabelinha pra me lembrar, Coffee Drinks Recipes (Graphic). 😎

Computação Científica e de Alta Performance…

terça-feira, 25 nov 2008; \48\UTC\UTC\k 48 8 comentários

O termo Computação de Alta Performance (HPC na sigla em Inglês) é usado para designar um determinado tipo particular de hardware, usado para atacar problemas que demandam o máximo da máquina, como “Teorias Quânticas de Campos na Rede“, “Enovelamento de Proteínas“, “Paleoclimatologia“, etc.

Um dos primeiros “galhos” dessa árvore da HPC foi a chamada “computação voluntária“, onde um usuário comum pode doar os ciclos inativos do seu computador para cálculos científicos, e.g.:

Tecnicamente falando, o nome dessa técnica é Computação em Gride — e, atualmente, no melhor espírito da Web2.0, fala-se também em termos de Computação na Nuvem.

O resumão dessa história começa há tempos atrás, enquanto as CPUs ainda eram oficialmente divididas em 2 tipos:

E, dentre esses 2 tipos, há mais algumas subdivisões:

Isso determina, essencialmente, o tipo de CPU que vc tem… aí é hora de falar em paralelização… 😉

Ou seja, a coisa fica bem complicada bem rápido… e, como se pode esperar, navegar nessas águas não é fácil… (Apesar de que o Sam Fulcomer ganhou o prêmio de ‘Ultimate HPC Geek’ desse ano!)

Historicamente falando, os problemas mais complicados sempre eram atacados com hardware que, essencialmente, era construído para o problema em questão (vários dos Cray foram construídos para o cálculo de Campos Quânticos na Rede, ditto para os BlueGene da IBM, etc)… porém, com a descoberta dos Clusters Beowulf, essa arte de se construir “supercomputadores” acabou sendo posta de lado, em favor da massificação desse tipo de clusters — aliás, numa palestra na Brown, ParalleX: A New Execution Model for Sustainable HPC Design, o Thomas Sterling (um dos inventores dos Beowulf) disse claramente que se arrependia de tê-lo feito, uma vez que aquilo que era pra ser apenas uma alternativa barata, passou a virar o foco central e, essencialmente, acabou com o desenvolvimento e pesquisa na área de supercomputação!

Um dos últimos CPUs a serem desnvolvidos ainda nesse aspecto, foi o MULTIFLOW, do qual participaram ativamente Gerry Guralnik e Jim O’Dell — o Jim, aliás, foi um dos primeiros desenvolvedores do Macsyma, no Project MAC do MIT, o precurssor dos CAS modernos.

Por isso, foi muito bom ter visto as notícia abaixo:

O primeiro deles fala do Jaguar, o primeiro computador a quebrar a barreira dos PetaFLOPS! Enquanto que o segundo artigo fala do NVIDIA Tesla, que é um supercomputador pessoal, com até 960 cores!

É inacreditável, mas depois que os clusters tomaram conta do mercado de HPC (como bem disse o Thomas, acima), a única atividade que ainda demandava uma quantidade de processamento tamanha que necessitava de processadores vetoriais era a dos gráficos dos jogos de vídeo-game! E, como era de se esperar, o crescimento e avanço desse setor impulsionou o desenvolvimento de HPC que já estava estagnado em clusters há anos. Então, do mesmo modo que a indústria pornográfica impulsionou a demanda por banda-larga e possibilitou que a Internet chegasse até cada um de nós, em nossas casas; a indústria de vídeo-games propulsionou o desenvolvimento de HPC dum modo completamente inesperado. 🙂

A lição a ser aprendida é que não adianta, alguns problemas só podem ser atacados com investimento em pesquisa básica e fundamental… não dá pra querer baratear tudo, sucateando tecnologia de ponta no processo. 😉

É isso aí: diversão garantida para o feriado! 😈

[]’s.

%d blogueiros gostam disto: