2015-01-11 5 views
5

Non capisco perché il tempo dei miei calcoli è più lungo mentre utilizzo 28-30 core rispetto a quando utilizzo 12-16 core su AWS EC2 c3. 8xlarge. Ho fatto qualche prova e risultati sono in tabella:Il codice Python con multiprocessing è più lento con 32 core rispetto a 16 core su AWS EC2

https://www.dropbox.com/s/8u32jttxmkvnacd/Slika%20zaslona%202015-01-11%20u%2018.33.20.png?dl=0

Il calcolo veloce è quando uso 13 core. Quindi, se io uso core massimali, è nello stesso tempo, come io sto usando 8 core di c3.8xlarge: codice

https://www.dropbox.com/s/gf3bevbi8dwk5vh/Slika%20zaslona%202015-01-11%20u%2018.32.53.png?dl=0

Questa è semplificata del codice che uso.

import random 
import multiprocessing as mp 
import threading as th 
import numpy as np 

x=mp.Value('f',0) 
y=mp.Value('f',0) 
arr=[] 
tasks=[] 
nesto=[] 

def calculation2(some_array): 
    global x, y, arr 
    p=False 
    a = np.sum(some_array)*random.random() 
    b = a **(random.random()) 
    if a > x.value: 
     x.value=a 
     y.value=b 
     arr=some_array 
     p=True 
    if p: 
     return x.value, y.value, arr 

def calculation1(number_of_pool): 
    global tasks 
    pool=mp.Pool(number_of_pool) 
    for i in range(1,500): 
     some_array=np.random.randint(100, size=(1, 4)) 
     tasks+=[pool.apply_async(calculation2,args=(some_array,))] 

def exec_activator(): 
    global x, y, arr 
    while tasks_gen.is_alive() or len(tasks)>0: 
     try: 
      task=tasks.pop(0) 
      x.value, y.value, arr = task.get() 
     except: 
      pass 

def results(task_act): 
    while task_act.is_alive(): 
     pass 
    else: 
     print x.value 
     print y.value 
     print arr 

tasks_gen=th.Thread(target=calculation1,args=(4,)) 
task_act=th.Thread(target=exec_activator) 
result_print=th.Thread(target=results,args=(task_act,)) 

tasks_gen.start() 
task_act.start() 
result_print.start() 

E 'nucleo sono 2 calcolo di:

  • calcolo 1 - calcolo array e fare i lavori per il calcolo 2 con tale matrice
  • calcolo 2 - calcolando alcuni di calcolo della matrice e confrontare i risultati

L'obiettivo del codice è di trovare array che calcolino x massimo e restituiscano il suo y. I due calcoli iniziano simultaneamente (con il threading) perché a volte ci sono troppi array che occupano troppa RAM.

Il mio obiettivo è eseguire il calcolo più veloce. Ho bisogno di consigli su come usare tutti i core, se possibile.

Siamo spiacenti in anticipo se male inglese. Se hai bisogno di maggiori informazioni si prega di chiedere.

+0

Con troppi core rispetto alla RAM disponibile, si può utilizzare la memoria virtuale (swap a/da disco, per semplificare) che possono facilmente rallentare. Solo una soluzione generale è ottenere più RAM. A seconda dei dettagli del tuo compito, in realtà lavorare dal disco in un modo sequenziale appropriato può essere più veloce del succhiare tutto in "memoria" che può essere virtuale. In alternativa, se puoi utilizzare l'SSD locale come "disco", che può offrire accesso casuale molto più rapido (non so come farlo in AWS, solo su Google Cloud Platform). –

+0

Sto usando psutil per supervisionare processori e RAM. Su dati testati ha utilizzato il 2-3% massimo di RAM. Trasmetto tutti i dati e il codice Python sul server Ubuntu (EBS). – matoliki

+0

Argomento interessante. Come si esegue il test, lo eseguo su una micro istanza e ottengo il risultato meno in 0.2 '[[86 44 89 88]] \ n real \t 0m0.175s' – BMW

risposta

2

Il c3.8xlarge è un sistema quad core Ivy Bridge. Utilizza Hyper-Threading; in realtà non ha 32 unità di elaborazione indipendenti (hardware).

C'è spesso nessun punto nel tentativo di parallelismo un compito legato CPU su più processi del sistema operativo di quello che loro sono i processori nell'hardware. Infatti, molto spesso è dannoso a causa del sovraccarico delle risorse e del cambio di contesto (che è quello che stai vedendo).

E 'probabile che dipende dalle vostre applicazioni specifiche, e la sperimentazione vi aiuterà a trovare il punto debole (che suona come hai fatto).