[R-br] Lentidão do mclapply() em alguns casos, mas não em outros

[Adriano S. Melo]

Colegas,
Estou com um problema de lentidão no uso do mclapply do pacote
multicore. Uso Ubuntu 12.04 em Dell Latitude E6500, 4Gb Ram e
processador Centrino2. Trabalho com R no gedit (repeti algumas coisas
diretamente no R executado no terminal mas não mudou nada). Já
brinquei bastante com o comando, mas ainda não consegui entender
exatamente o que está acontecendo (veja que fiz vários testes abaixo).

Seguindo uma mensagem anterior desta lista (18out12), executei o
codigo do Fernando H. Toledo em:
http://ridiculas.wordpress.com/2011/10/23/paralelizacao-de-processos/
O tempo de processammento SEM mcapply foi de:
1> tempoA[3]
elapsed
  2.065

Com o mcapply foi de:
1> tempoB[3]
elapsed
  2.135

Visto que o tempo do mclapply foi até maior, tentei descobrir o que
estava acontecendo.
Achei isto (https://github.com/markmfredrickson/RItools/issues/2):
"My understanding is that multicore first checks to see if the
mc.cores argument is set. If so, it uses that value. Next, it checks
options("cores"), if this is set, it will use that value. If neither
condition is true, it runs detectCores() itself. So in general, we do
not need to manually detect cores. The multicore help page has more
details on this.

If you want to override in RItools, you have two options. 1)
options("cores" = 2)  -- multicore will respect this. 2)
options("RItools-apply" = function(lst, f) { mclapply(lst, f,
mc.cores= 2) }). You can also use the second strategy to set other
mclapply options.

No meu computador:
getOption("cores")
NULL

Usei a sugestão 1) acima:
options("cores" = 2)
getOption("cores")
[1] 2

Executei o código novamente, mas não adiantou:
1> tempoA[3]
elapsed
  2.197
1> tempoB[3]
elapsed
  2.302


Usei a sugestão 2) acima, mas também não adiantou:
1> tempoA[3]
elapsed
  2.172
1> tempoB[3]
elapsed
  2.249

Fechei tudo e repeti os comandos usando o mclapply do pacote parallel.
Ele não reconheceu o número de CPUs e portanto coloquei como
argumento: mc.cores = 2
Melhorou apenas um pouquinho:
1> tempoA[3]
elapsed
   2.22
1> tempoB[3]
elapsed
  2.205

===>> Continuei brincando com o mclapply e vi que as coisas podem ser
diferentes:
system.time({
 a<-mclapply(1:1000, function(numero) sd(rnorm(100000)))
})
  usuário   sistema decorrido
  528.277     4.544    92.195

system.time({
a<-vector('list', 1000)
for (i in 1:1000){a[[i]]<-sd(rnorm(100000))}
})
  usuário   sistema decorrido
   16.301     0.520    16.835
#### Notem que aqui o mclapply foi BEM lento.


#### Mas neste exemplo abaixo ele reduziu o tempo pela metade (como
esperado, visto que tenho 2 CPUs):
library(vegan)
data(BCI)
system.time({
a<-mclapply(1:100,   function(numero) nestednodf(BCI))
})
 usuário   sistema decorrido
  127.996     2.520    47.902


system.time({
a<-vector('list', 100)
for (i in 1:100){a[[i]]<-nestednodf(BCI)}
})
  usuário   sistema decorrido
   82.765     0.352    83.204
####


Eu tenho 2 CPUs:
1> detectCores() # função do pacote parallel
[1] 2
No Monitor do Sistema pude observar que de fato o mclapply está usando
as duas CPUs para processamento (tanto com multicore quanto com
parallel).

Sugestões do que pode estar acontecendo?
Em que situação vale a pena usar o mclapply?

Abraços,
Adriano S. Melo
Ecologia - UFG