Comment puis-je effectuer une opération parallèle plus rapidement que la version série?

Question

Je tente de "mapper" une fonction sur un tableau. Cependant, lorsque vous essayez des fonctions simples et complexes, la version parallèle est toujours plus lente que la version sérielle. Comment puis-je améliorer les performances d'un calcul parallèle dans R?

Exemple simple parallèle:

library(parallel) 

# Number of elements 
arrayLength = 100 
# Create data 
input = 1:arrayLength 

# A simple computation 
foo = function(x, y) x^y - x^(y-1) 

# Add complexity 
iterations = 5 * 1000 * 1000 

# Perform complex computation on each element 
compute = function (x) { 
    y = x 
    for (i in 1:iterations) { 
    x = foo(x, y) 
    } 
    return(x) 
} 

# Parallelized compute 
computeParallel = function(x) { 
    # Create a cluster with 1 fewer cores than are available. 
    cl <- makeCluster(detectCores() - 1) # 8-1 cores 
    # Send static vars & funcs to all cores 
    clusterExport(cl, c('foo', 'iterations')) 
    # Map 
    out = parSapply(cl, x, compute) 
    # Clean up 
    stopCluster(cl) 
    return(out) 
} 

system.time(out <- compute(input)) # 12 seconds using 25% of cpu 
system.time(out <- computeParallel(input)) # 160 seconds using 100% of cpu 

Answer 1

Le problème est que vous troqués tous de la vectorisation pour la parallélisation, et qui est un mauvais métier. Vous devez garder autant de vectorisation que possible pour avoir l'espoir d'obtenir une amélioration avec la parallélisation pour ce genre de problème.

La fonction pvec dans le paquet parallèle peut être une bonne solution à ce genre de problème, mais elle n'est pas supportée en parallèle sur Windows. Une solution plus générale qui fonctionne sous Windows consiste à utiliser foreach avec le paquetage itertools qui contient des fonctions utiles pour parcourir plusieurs objets. Voici un exemple qui utilise la fonction « isplitVector » pour créer un sous-vecteur pour chaque travailleur:

library(doParallel) 
library(itertools) 
cl <- makeCluster(detectCores() - 1) 
registerDoParallel(cl) 
computeChunk <- function(x) { 
    foreach(xc=isplitVector(x, chunks=getDoParWorkers()), 
      .export=c('foo', 'iterations', 'compute'), 
      .combine='c') %dopar% { 
    compute(xc) 
    } 
} 

Cela peut toujours pas comparer très bien à la version pure vecteur, mais il devrait mieux que la valeur des « itérations » augmente. Cela peut en fait aider à diminuer le nombre de travailleurs à moins que la valeur des «itérations» soit très grande.

Answer 2

parSapply se déroulera la fonction de chaque élément de input séparément, ce qui signifie que vous renoncez à la vitesse que vous avez gagné de l'écriture foo et compute de façon vectorisé.

pvec exécutera une fonction vectorisée sur plusieurs cœurs par morceaux. Essayez ceci:

system.time(out <- pvec(input, compute, mc.cores=4))