Dados Aleatórios: Uma primeira experiência com a linguagem Julia
Sobre a implementação em si não teria muito o que mudar, afinal o código já não tinha nenhum for ou while, todas as operações ou eram vetoriais ou estavam sendo feitas com a utilização de funções de alta ordem (os famosos applys). Então tive a ideia de executar o código em paralelo, utilizando os muitos núcleos de um HPC (High Performance Computer) que tenho acesso. A adaptação foi relativamente simples, dado que o código já estava utilizando os applys. Tudo que tinha que ser feito era trocar o lapply por um mclapply (que faz parte do pacote multicore). Adaptações feitas. No meu modesto computador utilizando 4 cores, o código passou a demorar 17 minutos ! Bela melhora, pensei. O próximo passo foi executar o código diretamente no HPC, afinal lá teria acesso a 12 cores. O novo tempo? 5 minutos ! Surpreendente, pensei. Estava simulando 100.000 vezes o grilo pulando 1.000 vezes. Isto dá um total de 100 milhões de operações pelo menos. Então novamente veio a pergunta a cabeça: Dá para fazer melhor? Inicialmente pensei em implementar o problema utilizando Python, mas foi neste momento que lembrei da linguagem Julia, que era tão comentada por sua incrível performance em computação científica.
Postado por Evandro Lopes às 14:32
Anônimo 6 de dezembro de 2013 02:18
Muito bom, gostei da forma que escreveu!
Margeo 12 de janeiro de 2014 01:37
Que tal Assembly?
Evandro Lopes 14 de janeiro de 2014 10:10
Tem ideia do quanto o desempenho poderia melhorar?
Bruno Bini 12 de janeiro de 2014 22:27
Acho que o topo seria programar em Assembly utilizando os registradores do processador.
Evandro Lopes 14 de janeiro de 2014 10:07
Mas será que o ganho de performance compensaria o trabalho total?
Carlos 31 de janeiro de 2014 11:52
Extamente! Esse trade-off tem que ser pensando antes sempre.
Carlos 31 de janeiro de 2014 11:50
Bem legal o seu post, Evandro. Uma coisa que todo mundo tem que ter em mente é que o tempo total que a pessoa quer minimizar não é só o tempo de execução. Tempo total = (tempo pensando em como escrever) + (tempo escrevendo) + (tempo arrumando os dados) + (tempo debugando) + (tempo de execução) + (tempo de manutenção do código). Então às vezes uma linguagem pode ser muito rápida em um desses componentes, mas extramemente lenta em outros (você gasta o dobro do tempo escrevendo, elaborando o código e debugando e pena para fazer manutenção. Abs
Evandro Lopes 31 de janeiro de 2014 13:10
Sem dúvidas, Carlos. Estas linguagens de alto nível possuem a vantagem de ter uma sintaxe bem simples de entender. E acho que isto pesa um pouco em relação ao R, pelo fato de que para escrever uma função otimizada tem que usar uma série de artifíios, como operações vetorias e substituir loops convencionais pelos famosos applys, enquanto que em Julia e Python dá pra operar naturalmente dentro dos loops.
Ricardo Bittencourt 31 de janeiro de 2014 12:39
Dá pra fazer melhor ainda, você pode criar um modelo matemático que retorna a distribuição sem precisar de simulação! A minha intuição é que se o número de pulos for para infinito, então o resultado é uma gaussiana centrada na posição inicial. Mas é chute meu, teria que fazer as contas.
Evandro Lopes 31 de janeiro de 2014 12:54
O resultado é uma gaussiana, de fato. Porém a grande vantagem de fazer isto via simulação é que esta é uma tarefa trivial, enquanto que resolver analiticamente pode ser complicado.
Ricardo Bittencourt 31 de janeiro de 2014 15:36
Pensando melhor eu acho que no infinito não é uma gaussiana não, é uniforme no espaço inteiro. Começa como uma gaussiana, mas aí vai abrindo, abrindo, até que a variância é infinita.
JoãoDamasceno 3 de novembro de 2016 16:33
Assim como sugerido, eu também pensei: e Assembly.?! rs... Fica a dica (ou seria o desafio?!). rsrsrs...