Costi delle ricerche rispetto ai calcoli

Sono interessato a impostare i calcoli per verificare se un criterio di distanza è soddisfatto: vale a dire, la distanza tra un vettore e un altro vettore dovrebbe essere inferiore a un valore . I miei dati sono partizionati secondo una griglia di coordinate ortogonale. Poiché il mio taglio è inferiore alla distanza tra i punti finali delle coordinate del vicino più vicino, vorrei aggiungere una variabile "ottante" per verificare se le cose sono impostate correttamente: ${\bf x}_i$ ${\bf x}_j$ $r_{\rm max}$

if octant[j] in allowed_list continue

come "cortocircuito" verso

if dist(x[i], x[j]) < r_max

La mia domanda è: quanto sono computazionalmente efficienti le ricerche e i confronti booleani rispetto alle operazioni in virgola mobile? Vale la pena farlo su architetture moderne?

efficiency

— aeismail
fonte

Saresti disposto a ramificare il tuo codice e testarlo? Mi sento come la risposta standard alla maggior parte di questi "È meglio codificarlo (in un modo) o (in un altro modo)?" tipi di domande è "Provalo e confrontalo".

— Geoff Oxberry,

Solo i miei 2 centesimi. Come scrisse Geoff, questo tipo di consiglio è quello che ho sempre ricevuto quando ho posto domande simili su StackOverflow, per quanto riguarda il codice C ++: codifica tutto prima, organizza il codice in modo che rimanga modulare e riutilizzabile, e solo dopo inizi il refactoring. Esiste una regola dell'80-20: il software impiega l'80% del tempo sul 20% del codice. Attendi fino a quando la struttura non è stata installata, quindi modifica, verifica, modifica, verifica ..

— tmaric

@GeoffOxberry: La mia domanda non è così specifica: voglio solo sapere se c'è un vantaggio hardware o compilatore dato a fare un controllo booleano rispetto a fare un'operazione in virgola mobile.

— aeismail

Ma la tua domanda è troppo generica. Nessuno può dirlo senza vedere un codice concreto. C'è una regola empirica che dice che anche i migliori programmatori non possono dire dove si trovano i colli di bottiglia del loro codice senza profilazione. Ho trascorso i miei ultimi 25 anni a programmare e so che è vero per me.

— Wolfgang Bangerth,

La mia regola empirica è che se è possibile calcolare una certa quantità in modo efficiente (buon utilizzo della FPU) in meno di 50 flop per doppio valore di precisione, è meglio ricalcolare piuttosto che archiviare. La tendenza, che è stata costante per decenni, è per la capacità in virgola mobile di migliorare più velocemente delle prestazioni della memoria e non è probabile che ceda a causa di vincoli fisici e requisiti energetici della memoria veloce. Il valore di 50 è della giusta grandezza per tutte le piattaforme di elaborazione più diffuse (Intel / AMD, Blue Gene e GPU).

Stime approssimative dei costi per core

[linee guida per macchine basate su Intel e AMD 2011/2012]

$0.05$
$0.2$
$0.4$
$0.4$ $0.8$
$2$
$3$ $5$
$3$ $5$
$5$
$4$ $8$
$12$
$12$
$30$ $50$
$100$
$10^3$ $1$ $\mu$
$10^4$ $10$ $\mu$
$10^6$
$2\cdot 10^6$ MPI_Allreduce
$10^7$
$5\cdot 10^8$
$1.8\cdot 10^{12}$

Ulteriori letture

— Jed Brown
fonte

Ho trovato queste informazioni davvero utili. A proposito, dove hai preso questi dati? Sto cercando riferimenti da citare.

— Eldila,