Quem gosta de CUDA e Linux, sabe que não existe (a não ser que você procure na internet) suporte para CUDA nas autotools. Bom, eu procurei a um bom tempo atrás e criei um template para iniciar todos os meus projetos de CUDA e agora, não apenas estou liberando ele como um template, mas também estou criando um repositório completo sobre CUDA no meu SVN onde obviamente esse é o primeiro projeto.
Sem demoras, é possível efetuar o download e entender um pouco mais do projeto na página do projeto.
PS: Saiu a versão 3.1 com suporte a printf() em interfaces Fermin

Para quem não sabe, eu sou apaixonado por Autômatos Celulares (AC) e um AC famoso é o chamado Jogo da Vida (Game of Life, GOL) que apresenta computação universal de acordo com a configuração incial do seu reticulado (sei que parece “meio” sci-fi, mas ainda vou preparar um tutorialzinho em ACs, BEM básico). Enfim, qual a sacada do que vou falar, uma das coisas de ACs é a idéia principal que Von Neumann teve, de criar máquinas que se auto-replicam, pois bem, nunca haviam conseguindo, agora conseguiram Ainda não tive tempo de estudar como ele funciona, mas está na task list

Bom, todos nós sabemos que rand() nos retorna uma distribuição uniforme de números aleatórios, na realidade praticamente todos os geradores de números aleatórios nos retorna uma distribuição uniforme, o problema é como utilizamos. Procurando sobre isso, encontrei esse artigo que explica o motivo do “erro” de utilização e como corrigir o mesmo.
Enquanto ele não resolve o problema para geração de números aleatórios em paralelo (minha mais nova paixão), ele dá boas dicas de como solucionar isso, e provavelmente como solucionar também em paralelismo (já que o problema está na utilização e não no algorítmo).
Vale a pena dar uma lida, esse é um assunto muito importante para todos, principalmente para quem ainda gera os números dessa forma:

srand(time(NULL));
int num = rand()%max;

Quem já programou em clusters (ou até mesmo utilizando paralelismo) sabe das enormes vantagens que o paralelismo pode trazer. O que poucas pessoas sabem é que você pode ter tudo isso na sua casa, programando em sua placa de vídeo nVidia utilizando CUDA, uma arquitetura de programação paralela genérica, disponibilizada Free pela nVidia.
Diferente de várias formas de programação paralela, as placas da nVidia utilizam muito mais transistores para para processamento de dados no lugar de memória, dessa forma temos o chamado SIMT(Single Instruction Multiple Threads), não vou explicar exatamente como o CUDA faz ou até mesmo como programar para CUDA agora (mais tarde sem dúvida vou colocar algum código bem explicado, mas o tempo está cada vez mais escasso). Basta falar que em uma GeForce 8500GT temos 16 cores separados em 2 processadores, e uma GTX280 conta com 280 cores, o que a nVidia fez que é extremamente elegante, foi separar o número de threads possíves pela quantidade de memória a ser processada, e não pela quantidade de processadores, dessa forma você tem uma escalabilidade praticamente perfeita.
Explicando um pouco melhor isso, para rodar algo em uma GPU utilizando CUDA você precisa criar um Grid de execução, cada Grid possui um conjunto de Blocks (blocos de threads) e cada Block possui um número n de threads que é ditado pela quantidade de dados a ser processado. Mais interessante ainda é que cada bloco de thread possui um espaço de memória do tipo shared (compartilhada) que é extremamente rápida, porém apenas as threads daquele bloco podem acessar esse espaço de memória. Além disso existe a memória do tipo global, que fica toda na GPU e qualquer thread (ou bloco) pode acessar, e outros tipos (constant, register, local e texture).
Bom, esse não é nem o básico sobre CUDA, é apenas um texto para dar um gostinho de quero mais. Um pequeno teste que fiz foi portar o algoritmo de ordenação Bitonic Sort para CUDA (código retirado dessa thread do Forum da nVidia), e comparar a versão sem paralelismo com a versão do CUDA, pois bem, o programa faz isso:

1. Cria um array de 2^25 números = 33.554.432
2. Copia a memória para a GPU (apnas na versão CUDA)
3. Popula o array com o indíce invertido (array[0]=33554432, …, array[33554432]=0)
4. Ordena utilizando o algoritmo Bitonic Sort
5. Copia de GPU para a memória local de volta (apenas na versão CUDA)
6. Valida os dados

na versão simples (sem paralelismo) tudo isso demorou em média 4 minutos e meio para executar, na versão CUDA demorou 0.3 segundos em uma GeForce 8500GT. Isso convence do poder do CUDA?

Para saber mais:

CUDA Zone: Site oficial com uma extensa documentação sobre o CUDA
Dr.Dobbs: Tutorial fantástico sobre CUDA

De acordo com essa notícia do Slashdot, a nova especificação do C++ (C++0X) será adiada para 2010 ou depois. O motivo é a sua mudança principal chamada “concepts”, que visam deixar os templates mais robustos. Honestamente eu não vi muito de C++ ainda para discutir a fundo templates, herança, polimorfismo, ou qualquer outra coisa, mas uma nova especificação sempre é bem vinda (quando bem feita, que aparentemente é o caso), e pelo que li sobre “concepts” realmente é uma coisa bem complexa, que esta sendo desenvolvida a mais de 7 anos e ainda não está pronta. Como ela será o motivo principal do atraso, ela será retirada e a nova especificação irá se focar em outras coisas (como paralelismo por exemplo).

Pois bem, parece que um italiano sem muito o que fazer resolveu fazer um cliente/servidor entre seu Nokia N95 e o Blender (em Python) e conseguiu fazer o acelerômetro do N95 ser utilizado como joystick para jogos no Blender. Parabéns
Veja aqui.

Se você tem a opção de um software free, ou pago, o que você pega? E se os softwares forem o mesmo, porém com outro nome?
Pois é isso que a 3DMagix fez, pegou o Blender, mudou de nome, e vende por 47$. Isso pode não ser ilegal já que o Blender está na GPL, mas ela deve falar de onde tirou e dar os crédito corretos. Eu não paguei 47$ para ver isso. E honestamente, entre pagar uma empresa e doar, eu prefiro doar à fundação Blender.
Fonte.

Observers são um patrão de design muito utilizado, principalmente quando você quer que camadas superiores do seu software saibam o que aconteceu nas camadas inferiores. O Ogre usa isso para renderizar Frames por exemplo, utilizando FrameListener. Pois bem, curioso como sou resolvi ir um pouco mais a fundo e ver como se faz isso na unha em C++, descobrindo o quão simples isso é, os passos são esses:

1. Criar uma simples interface com um método que será chamado a toda atualização
2. Criar um objeto singleton que pode ser observado, adicionando as interfaces em uma lista (ou pilha, whatever), que irá chamar o método de atualização de todos as interface quando obtiver uma mudança
3. Criar um objeto que implementa sua interface.
4. A cada atualização, notificar todas as interfaces.

O código mostrado aqui (apenas trechos) está disponível via svn em:

http://svn.geekvault.org/cpp/ObserverExample

Parece mais complexo do que realmente é, a mágica toda está em básicamente dois métodos (e obviamente na organização de listener mostrada):

• InputListener::notify()
• Listener::notify()

O nome dos métodos pode variar, mas a idéia básica é que cada objeto que implementar a interface Listener, será obrigado a implementar o método notify(), que será chamado pelo Singleton InputListener.
Vamos ao código:

InputListener::notify(void)

std::set<Listener*>::iterator itr;
for( itr = listeners.begin(); itr != listeners.end(); ++itr)
(*itr)->notify();

InputFilter::notify()

unsigned int qtdChars = 0;
if(&m_sInput!=NULL)
{
std::cout << "We have the string: " << m_sInput->c_str() << std::endl;
std::cout << "That is " << m_sInput->size() << " chars wide\n";
for(unsigned int i = 0; i < m_sInput->size(); i++)
{
if((*m_sInput)[i]=='a') qtdChars++;
}
std::cout << "And we found " << qtdChars << " of the 'a' character\n";
}

InputFilter é uma classe que implementa a “complexa” interface Listener:

class Listener
{
public:
virtual void notify() = 0;
};

Onde InputFilter será definida como (no nosso caso):
class InputFilter : public Listener
{
public:
InputFilter();
~InputFilter();
void addString(std::string& str);
private:
void notify();
InputListener* input;
std::string *m_sInput;
};

E sua utilização (também chamada como main())

int main(void)
{
string str;
InputFilter* filter = new InputFilter();
do
{
cout << "Please type something:";
getline(cin,str);filter->addString(str);
InputListener::getInstance()->notify();
}while(str.compare("quit")!=0);
return 0;
}

Acreditem, não fica mais complexo do que isso. A grande sacada de Listener (ou Observers, é a mesma coisa) é que você pode criar um Singleton e não se preocupar em avisar várias classes sobre sua atualização, faça-as implementares a interface Listener, e apenas as adicione no Listener criado, quando você quiser atualizar todos, chame o método de atualização do Listener, simples assim.

Have fun.

Zarnick

Bom, eu sei que faz tempo que não aparecem trechos de códigos por aqui, culpe a falta de tempo.
Mas nada são más notícias, eu tenho um trecho aqui de um Menu 3D, com alfabeto e tudo mais Ainda estou trabalhando na documentação, mas se você possui Linux e OGRE, pode brincar um pouco já, a idéia é bem básica, existem um Zip com os .mesh representando o alfabeto (por falta de vocação em 3D e vontade, temos apenas de A-Z e 0-9), criei (estou aperfeiçoando) uma classe para cuidar de mostrar o alfabeto em um ambiente 3D e, uma classe de Menu, que utiliza esse alfabeto e umas animações bem básicas mesmo.
Esse projeto eu vou fazer um pouco diferente, vou trabalhar no mesmo até conseguir entregar um binário de exemplo para Linux e Windows e, fazer com que esse binário rode em qualquer um desses SOs, com ou sem Ogre instalado.
Para ver como está indo, o link do SVN é:

http://svn.geekvault.org/ogre/MenuFramework

Abraços, e até a próxima.
Zarnick

É incrível o que a falta de tempo causa em projetos com “deadline”, acredito que deve fazer mais ou menos 1 mês que não consigo dormir direito por causa de um projeto no trabalho que está me obrigando a estudar J2ME, dai vem a constante falta de posts. Sim, eu sei que prometi Agentes Autônomos, mas tive que parar o desenvolvimento dos mesmos para estudar essa <sarcasmo on>”maravilha”</sarcasmo on> chamada J2ME.
Obviamente não escrevi isso apenas para me desculpar, vou deixar algumas dicas sobre J2ME:

1. Lembre-se, cada celular implementa o J2ME como ele quiser, mas se você ficar nas coisas básicas (Forms, Canvas, etc), existe uma grande chance de ele se comportar corretamente
2. O livro Beginning J2ME, é extremamente bom e didático
3. Se você tiver um OS 64Bits, não adianta chorar, não existe emulador de celular no computador, dura realidade.
4. O site da Sun ainda é uma das melhores referências sobre J2ME, para quem tem tempo de ler.

Fica ai as dicas, conforme eu vou estudando vou (com um pouco de tempo) postando alguns códigos aqui.

Aquele []