Computação nas nuvens parece ser o caminho das aplicações Desktop. Este modelo prioriza a eficiência energética e a mobilidade.
Os games dos últimos nichos que demandam grande desempenho, tanto nos PCs quanto nos Consoles. Na contramão da busca por mais desempenho e no caminho da computação nas nuvens também para os games, temos o empreendimento da Onlive... eu sei, latência, hubs, wireless etc.
De fato, as dificuldades parecem intangíveis, mas por outro lado temos menores custos de hardware em datacenters, conexões melhores e mais baratas. Somado a isso, observamos o grande progresso dos softwares de compactação e sincronização, um exemplo é o jogo Heroes of Newerth cuja espantosa sincronização torna possível uma partida competitiva entre Brasileiros, estadounidenses, o que é impensável no antigo DoTa.
Semana passada o fundador e diretor geral do Online, Steve Perlman, foi convidado a proferir uma palestra sobre o projeto na Columbia University.
Um outro projeto, não tão ousado, é o StreamMyGame eles disponibilizam um software que permite rodar aplicativos como games numa rede local. Por exemplo, você pode jogar jogos pesados na sacada, com seu netbook rodando remotamente um jogo instalado no seu desktop. Eles disponibilizam uma versão com servidor windows e cliente Linux, para PC e para PS3. Por exemplo:
Eu pessoalmente fiquei muito curioso em relação aos mecanismo de compactação e sobre a existência de aplicativos opensource que permitam o estudo e o aprimoramento.
Encontrei um projeto muito interessante da Sun, o VirtualGL aliado ao TurboVNC, em breve postarei minha experiência com ele.
1 de janeiro de 2010
Jogos remotos com o StreamMyGame
26 de dezembro de 2009
Números Aleatórios - Performance
Eu fiz um teste de performance de diferentes implementações de geradores de números aleatórios, comparando a biblioteca GSL e a MKL. O teste consistiu em calcular o tempo necessário para gera 2^30 números aleatórios (float):
- implementação do Numerical Recipes do ran2 -> 25 segundos
- implementação da biblioteca GSL do Mersenne Twister -> 15 segundos
- implementação da biblioteca MKL do Mersenne Twister -> 5 segundos
Gerando números aleatórios com a biblioteca VSL (MKL)
Exemplo simples do uso dos geradores de números aleatórios da biblioteca MKL,
#include <stdio.h> /////////////////////////////// MKL GSL Mersenne Twister #include <mkl_vsl.h> #define BRNG VSL_BRNG_MT19937 #define METHOD 0 //////////////////////////////// main () { int N = 4, sqrtN = 2 , i , j; int seed; seed = 345; float ranfloat[sqrtN]; //cada entrada corresponde a um numero aleatorio VSLStreamStatePtr stream; vslNewStream (&stream, BRNG, seed); //semeando o gerador for (i = 0; i < sqrtN; i++) { vsRngUniform (METHOD, stream, sqrtN, ranfloat, 0.0, 1.0); //carregando sqrtN numeros for (j = 0; j < sqrtN; j++) { printf ("%f\n", ranfloat[sqrtN]); } } return (0); }
Para compilar basta linkar as bibliotecas adequadas:
ia32, icc exemplo.c -lmkl_intel -lmkl_sequential -lmkl_core -o exemplo.bin
intel64, icc exemplo.c -lmkl_intel_lp64 -lmkl_sequential -lmkl_core -o exemplo.bin
Pontos importante:
os números são obtidos em stream, a idéia é carrega um vetor a cada chamada da função vsRngUniform, no exemplo carregamos sqrtN números entre 0 e 1 (float) distribuídos uniformente. O desempenho é melhor para sqrtN > 1000.
Outras funções:
vdRngUniform - double
viRngUniform - int
Outros geradores, funções e mais detalhes podem ser obtidos na documentação da biblioteca Vector Statistical Library VSL
How-To instalando o icc com MKL
Instalando a MKL
A Math Kernel Library MKL pode ser obtida em um pacote com compilador, debugger etc, ou separadamente. Você pode comprar o pacote (licenças acadêmicas têm desconto), testar ou obter uma licença para testes.
Eu optei pelo pacote completo.
Descompacte o arquivo, ex:
tar xvzf l_cproc_p_11.1.064.tgz
Instale com
cd l_cproc_p_11.1.064/
./install
O processo de instalação é muito simples, basta seguir as instruções.
Dentro do diretório de instalação temos a documentação, exemplo, bibliotecas etc. Sugiro um tour para conhecer o que a Intel oferece nesse pacote, provavelmente você vai encontrar muita coisa interessante.
Bom, aqui vão os passos (how-to) para fazer as coisas funcionarem:
- setar as variáveis de ambiente, o pacote traz um script que faz o serviço, basta executar o script iccvars.sh localizado dentro da pasta bin da instalação. No meu caso /home/maicon/opt. Precisamos indicar também a arquitetura desejada (intel64):
source ./iccvars.sh intel64
para evitar ter que fazer este procedimento para cada terminal aberto, vamos adicionar esse comando no bashrc
echo "source /home/maicon/opt/bin/iccvars.sh intel64" >> .bashrc
esse script inclui o compilador icc no PATH.
22 de dezembro de 2009
Geradores de números pseudo-aleatórios
Geradores de números pseudo-aleatórios GNPA são uma caixa preta, em geral usamos as indicações dos estudantes mais antigos e dos professores. Provavelmente, graças a esse mecanismo, os GNPA mais usados são o ran2 ou o rand, e a implementação destes é encontrada no clássico Numerical Recipes.
O cerne das simulações de Monte-Carlo são justamente os GNPA e dificilmente nossos programas passarão fazendo mais tempo algo que não seja gerar números aleatórios. Por isso é importante conhecer e se atualizar quanto este assunto.
Embora seja importante entender um pouco da minúcias dos GNPA eu não vou nem tocar nesse assunto, para mim eles permaneceram uma caixa preta por muito tempo. Bom..., as atualidades ? Ah, essas são bem mais fáceis.
O GNPA padrão nos dias de hoje o Mersenne-Twister, introduzido em 1997 http://en.wikipedia.org/wiki/Mersenne_twister (alguem tem que escrever o artigo na wikipedia portuguesa, nem que seja tradução). Este é provavelmente o algoritmo mais popular, ele possui um período de 2^19937 − 1, passou em vários testes e é superior aos ran2,3,4 .
Outro ponto de fundamental importância é a sua performance.
Como implementar o algoritmo:
Eu sugiro fortemente a utilização da biblioteca GSL ( Gnu Scientific Library ) http://www.gnu.org/software/gsl/ e o manual http://www.gnu.org/software/gsl/manual , essa biblioteca já esta instalada no abax e você pode encontra-la nos repositórias da sua distribuição Linux.
E muito fácil usar, segue um exemplo
#include < stdio.h >
#include < gsl/gsl_rng.h >
int main ()
{
int i;
unsigned long a;
/////////////////////////////////////////////////////
const gsl_rng *r;
r = gsl_rng_alloc(gsl_rng_mt19937);
////////////////////////////////////////////////////
gsl_rng_set(r, 123); // semente 123
for (i = 0; i < 100000000; i++)
{
printf ("%u\n", gsl_rng_get(r));
}
printf ("\n");
printf ("%lu %lu\n", gsl_rng_max(r), gsl_rng_min(r) );
return 0;
}
Compilar com: gcc rng.c -lgsl -lgslcblas -lm
Comentários:
"const gsl_rng *r;
r = gsl_rng_alloc(gsl_rng_mt19937); "
- Define o nome do gerador, no caso é "r", e o GNPA usado ( mt19937 = Mersenne Twisted ).
"gsl_rng_set (r, 123);" - Semente (123) do gerador r.
"gsl_rng_get (r);" - Retorna um número inteiro (unsigned long) pseudo-aleatório
"gsl_rng_max(r) e gsl_rng_min(r)" - Valor máximo e mínimo do gerador.
Outras dicas:
"gsl_rng_uniform(r);" - Retorna um real (double) pseudo-aleatório o intervalo [0,1)
"gsl_rng_uniform_int(r,j);" Retorna um número inteiro (unsigned long) pseudo-aleatório entre [0, j-1]
Existe uma lista de extensa de implementações de GNPA nesta biblioteca, inclusive o ran2, basta substituir o "mt19937" pelo algoritmo desejado.
Veja a lista de performance ( http://www.gnu.org/software/gsl/manual/html_node/Random-Number-Generator-Performance.html ):
1754 k ints/sec, 870 k doubles/sec, taus
1613 k ints/sec, 855 k doubles/sec, gfsr4
1370 k ints/sec, 769 k doubles/sec, mt19937
565 k ints/sec, 571 k doubles/sec, ranlxs0
400 k ints/sec, 405 k doubles/sec, ranlxs1
490 k ints/sec, 389 k doubles/sec, mrg
407 k ints/sec, 297 k doubles/sec, ranlux
243 k ints/sec, 254 k doubles/sec, ranlxd1
251 k ints/sec, 253 k doubles/sec, ranlxs2
238 k ints/sec, 215 k doubles/sec, cmrg
247 k ints/sec, 198 k doubles/sec, ranlux389
141 k ints/sec, 140 k doubles/sec, ranlxd2
1852 k ints/sec, 935 k doubles/sec, ran3
813 k ints/sec, 575 k doubles/sec, ran0
787 k ints/sec, 476 k doubles/sec, ran1
379 k ints/sec, 292 k doubles/sec, ran2
Uma pequena explicação sobre as características de cada algoritmo é encontrada no manual http://www.gnu.org/software/gsl/manual/html_node/Random-number-generator-algorithms.html
5 de dezembro de 2009
Impressões do Mandriva 2010.0 no EEEpc 1008HA
Depois do falecimento do meu Compaq v6210BR, decidi comprar um netbook.
Asus EEEpc 1008HA, foi a minha opção. Ele tem a maior autonomia e desempenho da categoria, é extremamente fino. Eu adquiri este com windows xp, infelizmente não encontrei nenhum a venda com linux.
A tela, teclado, acabamento, desempenho, tudo me impressionou positivamente. Boots do mandriva e do windows rapidissimos !
Contras:
-setas cima e baixo pequenas, eu também não gostei das portinhas que fecham todas as entradas(usb, fone etc). elas são bonitas, mas eu tenho um pouco de dificuldade de abrir (sem muita unha Contente).
-botões do mousepad, o botão único dificulta um pouco o duplo clique. O mousepad é bom, multitouch.
Vamos ao Mandriva.
Instalei usando o Mandriva-seed http://megaf.wordpress.com/2009/04/11/mandriva-2009-spring-da-iso-pro-pendrive/ (dica do Manuel Pinho) O tutorial serve também para o mandriva 2010.0.
Usei um pendrive bem vagabundo, mesmo assim a instalação foi rápida. Nenhuma opção especial.
Compatibilidade, bom o que dizer..., o mandriva está tirando a graça da instalação. TUDO funcionando, rede sem fio, suspender etc. Só pra ter uma idéia: não abri o terminal ainda !
-microfone, câmara, fone funcionando,
-Skype funcionando,
Para melhorar a usabilidade eu desativei a composição "efeitos do desktop", para fazê-lo vá em "Ferramentas" -> "Ferramentas do sistema" -> "configurar sua sessão" -> Área de Trabalho, retire a opção "Habilitar os efeitos da área de trabalho". Assim o sistema ficou muito mais rápido e responsivo.
Críticas: minhas únicas criticas são a respeito do Desktop Kde padrão do Mandriva, realmente ele não é muito agradável para telas menores.
Eu fiz algumas modificações como o aumento da barra de tarefas, e a ocultei. Na minha opinião fica muito melhor assim !
Vou fazer um comparativo da autonomia da bateria, mandriva x windows ! Depois posto o resultado !
4 de novembro de 2009
Boa prática na construção de um cluster Beowulf
Eu encontrei um artigo muito completo sobre a construção de um pequeno cluste microcluster
de Joel Adams e Tim Brom http://www.clustermonkey.net//content/view/211/1/
O cluster foi construído em 2007, usando 4 Athlon X2 3200, totalizando 8 núcleos, o total investido foi 2500 dólares, Um excelente custo para 26 Gflops.
No artigo os autores fazem uma análise muito interessante, o argumento é muito importante para o processo de desenvolvimento de clusters de alto desempenho para pesquisa.
Veja o trecho do artigo:
Now, let's look at the performance of Microwulf in relation to the Top500 list to see where it would have placed. Going through the archived lists, here is where Microwulf would have placed.
* Nov. 1993: #6
* Nov. 1994: #12
* Nov. 1995: #31
* Nov. 1996: #60
* Nov. 1997: #122
* Nov. 1998: #275
* June 1999: #439
* Nov. 1999: Off the list
Looking back at the lists is really a lot of fun. In November 1993 Microwulf would have been the 6th fastest machine on the planet! That's not bad considering that was only 14 years ago. As recent as 8 years ago, Microwulf would have ranked 439th on the list. That's not bad for a little 4 node, 8 core cluster measuring 11" x 12" x 17".
Vemos alguns projetos que acabam tento um custo x beneficio ruim por não levarem em conta a velocidade da evolução tecnológica. Uma boa prática na formulação de um Beowulf é procurar sempre hardware "popular". Muitas vezes pequenos ganhos de performance vem acompanhado de custos muito altos.
Uma sugestão é sempre tentar melhorar os métodos estatísticos, aprender aquele método de extrapolação super sofisticado e poderoso, otimizar, procurar melhores compiladores, ou seja tentar melhorar o seu próprio desempenho ao invés de simplesmente investir no hardware.
Afinal, embora a tecnologia seja algo passageiro, conhecimento não o é.