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.
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). –
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
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