Sto cercando di capire l'assegnazione parallela per cercare di velocizzare alcune piccole operazioni.Eseguo il seguente script (avvertendo che ha esaurito la memoria per me e mi ha bloccato) e lo vedo diventare esponenzialmente più lento con il numero di righe in un vettore.
for(i=1, i<=5, i++,
t = [59760, 71220, 79380, 83820, 3300, 11400, 27900, 39060, 43500, 51300,56220, 60];
t = repeat(t, 10^i);
n = nitems(t);
diff = t[2::n]-t[1::(n-1)];
day_v = diff < 0;
st = HPTime();
day_cum = cumulative Sum([0]|/day_v);
tot_cum = HPTIme() - st;
st= HPTime();
day_break = loc(day_v); // this will give you last row of the day
// make a matrix n x number of day breaks
m = J(n, nitems(day_break), -1);
parallel assign({db = day_break},
// make the item a 1 if it's row is higher than the corresponding row
m[a, b] = a > db[b];
);
m;
// now just sum the matrix
day = VSum(m`); // +1; // if you want the day to start at 1
tot_pa = HPTime() - st;
show(n, tot_pa, tot_cum);
);
Non mi aspetto che sia più veloce eseguire l'assegnazione parallela rispetto a cumulativesum(), ma sono curioso di sapere come funziona l'assegnazione parallela.
ho letto Questo e immagino sia perché sta creando copie di matrici molto grandi per ogni thread?
Qualcuno ha altre intuizioni su come potrebbe funzionare e forse alcune cose da fare e da non fare di base per l'assegnazione parallela?
Buon punto, non pensavo che il mio esempio non fosse un confronto tra mele e mele.Grazie @Craige_Hales , questo è davvero utile.
Parallel Assign sta facendo un ottimo lavoro! Penso che la dimensione dell'array m sia il vero problema: sta crescendo a passi da gigante, o 100 volte a ogni iterazione.
| io | articoli(m) | Seconds_in_Parallel_Assign | Seconds_in_Nested_Loops |
| 1 | 2.400 | troppo piccolo per tickseconds() | .18 |
| 2 | 240.000 | .033 | 19 |
| 3 | 24.000.000 | 3.3 | 1951 |
| 4 | 2.400.000.000 | 338 | rinunciato ad aspettare |
Quella sceneggiatura,
m[a, b] = a > db[b];
viene eseguito circa 7 milioni di volte al secondo (4-CPU 17.5G VirtualBox). Ho anche esaurito la memoria, e questo significa paginazione . Il paging causerà un drammatico rallentamento, forse a i==5.
La colonna 4, il confronto del ciclo nidificato, è stata realizzata in questo modo (cattura dello schermo...computer impegnato a cercare di arrivare a 1900 secondi sulla riga 3):
Questo È il tipo di problema per il quale è stata progettata l'assegnazione parallela. Parte della velocità deriva dai loop C++ piuttosto che dai loop JSL e parte dal threading.
