Perólas - Opiniões politicas nem tão respeitaveis

Acho que a campanha 2010 já começou, então vamos a diversão.
Hoje eu vou iniciar uma compilação dos comentários hilários sobre política que encontramos por aí.

Cover muito animado de Cecilia - Simon e Garfunkel !

O monstro da pía

Levantei durante a madrugada e me deparei com essa criatura assustadora !

Shell x Listas x Monte Carlo

Muitas vezes é interessante guardas listas de sítios e sortear somente dentro desta lista para evitar gerar números aleatórios que não serão usados. É fácil usar listas em uma dimensão: quando um sítio sai da lista ele pode ser substituído pelo ultimo da fila e esta perde um elemento.

Tudo muito bom, tudo muito legal, mas há um preço a pagar se estamos interessados no comportamento dinâmico... um não, dois !

Jogos remotos com o StreamMyGame

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.

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):

1. implementação do Numerical Recipes do ran2                  ->  25 segundos
2. implementação da biblioteca GSL do Mersenne Twister  ->  15 segundos
3. implementação da biblioteca MKL do Mersenne Twister ->  5  segundos
   

 Este é o fonte do teste

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.

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


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 !

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 é.      

Paisagem de Cientista

A estrutura exótica aparece no tratamento da sequência de Rudin-Shapiro em um contexto muito rebuscado para explicar aqui.

Comportamentos repugnantes

As vezes vemos comportamentos tão repugnantes que fica difícil se pronunciar sobre tamanha maldade.
Como ? Como alguém pode matar um animal a pedradas ?
Sinceramente, eu não sei o que faria com os indivíduos que fizeram isto.

http://terratv.terra.com.br/Noticias/Ciencia/4195-248517/Criatura-bizarra-e-morta-em-cidade-no-Panama.htm

Manuais de Recarga de toner

Consegui alguns manuais sobre recarga de impressoras.
Sirvam-se !

Novidades no Cluster Abax (Mecânica Estátistica - IFUSP)

Depois de algumas quedas de energia e da perda de trabalhos dos usuários resolvemos colocar em prática o plano de implementar a suspensão para memória (suspend).
Esse trabalho foi iniciado a algum tempo, na época da atualização do kernel dos nós para a versão 2.6.30, nesta compilação do kernel incluímos o suporte a funcionalidade "suspend".

Agora usamos o daemon apcupsd para executar os scripts de suspensão e religamento dos nós nos eventos de queda e retorno da energia.

Graças a esses aprimoramentos o cluster ficará "adormecido" quando houver falta de luz no IF, este estado dormente pode ser mantido por algumas horas. Logo após o reestabelecimento do fornecimento de energia o Abax voltará ao seu funcionamento normal e os trabalhos voltaram a ser executados a partir do ponto em que foram interrompidos.

Informações técnicas: http://abax.if.usp.br/drupal5/?q=node/45

A história do vencedor

Publicado na Folha de São Paulo Campanha dá rostos de Saddam, Hitler e Stalin ao vírus da Aids
Comentário: tudo muito legal, tudo muito bonito: essa alegoria foi muito boa, entretanto seria historicamente honesto incluir o presidente Truman responsável pela morte covarde de quase 250000 http://en.wikipedia.org/wiki/Atomic_bombings_of_Hiroshima_and_Nagasaki

Eu pensei em colocar algum vídeo sobre o bombardeio nuclear, mas é tão horroroso que eu desisti.

Outro ponto: relendo o artigo da wikipédia recém citado achei um outro sobre o "debate"

Debate ! Como debate ?

http://en.wikipedia.org/wiki/Debate_over_the_atomic_bombings_of_Hiroshima_and_Nagasaki

Há "Supporters"?

Sim há, olhem os pontos justificantes:

* 1.1 Preferable to invasion
* 1.2 Speedy end of war saved lives
* 1.3 Part of "total war"
* 1.4 Japan's leaders refused to surrender

Eu fiquei espantado com o pluralismo extremo da wikipédia, seletivo, pois não existe tal respeito a opinião sobre ataques aos norte americanos ou aliados.

PCI Wireless Card Realtek 8185 weak signal

The default module to PCI Wireless Card Realtek 8185 has weak signal, something between 5% to 15%, on Ubuntu 9.04 kernel 2.6.28 .

On Mandriva this network device work very well, don't need to worry !

Nevertheless we can solve this problem installing the modeule from Realtek to this device.

The steps are easy:

1. Download driver from Realtek .
2. Unzip the file .
3. Inside the file do make and make install, then reboot
4. This is a very dirt step, you must install libssl-dev. Try a cable connection to Internet.
5. unzip wpa_supplicant-0.5.5.zip
6. cp defconfig .config
7. make and cp wpa_cli wpa_supplicant /usr/local/bin
8. reboot and let the job for the networkmanager

Benchmark - cpus

Simple benchmark, just floating point calculations.
This can be use to evaluate the performance on Monte Carlo application and numerical recursions without memory use.
We calculate the time for 10^9 m=tanh(ran2(&seed)*m), m=sin(ran2(&seed)*m) and if(ran2(&seed)). (seed=234)
Used cpus in decreasing performance order :

Intel(R) Core(TM) i5 CPU 750 @ 2.67GHz
AMD Phenom(tm) II X4 945 Processor @ 3GHz
Intel(R) Xeon(R) CPU X5550 @ 2.67GHz
AMD Athlon(tm) 64 X2 Dual Core Processor 4000+ @ 2.1GHz
Intel(R) Core(TM)2 Quad CPU Q6600 @ 2.40GHz - Chipset ICH10
Intel(R) Core(TM)2 Quad CPU Q6600 @ 2.40GHz - Chipset ICH7

Intel(R) Core(TM)2 Quad CPU Q9300 @ 2.50GHz - Chipset ICH9
Mobile AMD Sempron(tm) Processor 3500+ @1.8 GHz
Intel(R) Core 2(TM) CPU T7200@ 2.0Ghz



Below graph (incomplete) shows time versus cpu for the if(ran2(&seed)) routine
Also the complete spreadsheet

The fast, the random

The fast and the random

Posted using ShareThis

This is very cool, look at how many bit per second they can resolve !
Put on a USB device and sell it!

Matrices Direct Product C GSL routine

This is my amateur routine of Matrices Direct Product or Kronecker Product using GSL. There is no advantage in doing this with GSL library, this is just a exercise.

#include <stdio.h>
#include <gsl/gsl_matrix.h>
#include <gsl/gsl_math.h>

double *produtodireto (int a,int b, double A[a*a],double B[b*b])
     {
 double *AxB;
 AxB = malloc(a*a*b*b*(sizeof *AxB));
 int i, j, k,l;
 gsl_matrix *M = gsl_matrix_alloc (a,a);
 gsl_matrix *L = gsl_matrix_alloc (b,b);
 for (i = 0; i < a; i++)
  {
  for (j = 0; j < a; j++)
   {
             gsl_matrix_set (M, i, j, A[i+a*j]);
   }
  }
 for (i = 0; i < b; i++)
  {
  for (j = 0; j < b; j++)
   {
      gsl_matrix_set (L, i, j, B[i+b*j]);
   }
  }
 gsl_matrix *R = gsl_matrix_alloc (a*b,a*b);
 for (i = 0; i < a; i++)
  {
  for (j = 0; j < a; j++)
   { 
   for (k = 0; k < b; k++)
    {
    for (l = 0; l < b; l++)
     {
     gsl_matrix_set (R, b*i+k-b+2,b*j+l-b+2, gsl_matrix_get (M, i, j)*gsl_matrix_get (L, k, l));
     }
    }
   }
  }
for (i = 0; i < a*b; i++)  
 {/* OUT OF RANGE ERRORRRRR */
 for (j = 0; j < a*b; j++)
  {
  AxB[i+a*b*j]=gsl_matrix_get (R, i, j);
  }
 }

gsl_matrix_free (M);
gsl_matrix_free (L);
gsl_matrix_free (R);
       return AxB;
     }