Scala LMS per scrivere algebra lineare Lib

Question

Sono abbastanza impressionato dalla libreria C++ Eigen che utilizza modelli di espressioni per ottenere un'enorme velocità nel calcolo di matrice/vettore.

Vorrei clonare questa libreria in scala. Per quanto ne so, il sistema di tipo scalas non è abbastanza potente per fare qualcosa del genere, ma dovrebbe essere possibile la LMS modulare leggera. Sembra che ci siano diversi progetti là fuori (Delight, virtualizzazione-lms, ecc.). Quale sarebbe il diritto di utilizzare per questo tipo di progetto in termini di affidabilità e prestazioni?

Grazie

Edit: Ho appena incontrato macro in scala 2.10. Forse questo è quello che voglio usare qui.

@ om-nom-nom

La parte importante è spiegato in http://eigen.tuxfamily.org/dox/TopicInsideEigenExample.html

L'esempio spiega che un vettore aggiunta

u = v + w 

possiede buone prestazioni in (nativo) C++ poiché un la variabile temporanea viene creata per l'aggiunta e questa variabile è assegnata a te come

for(int i = 0; i < size; i++) tmp[i] = v[i] + w[i]; 
for(int i = 0; i < size; i++) u[i] = tmp[i]; 

Eigen utilizza template metaprogrammazione (passo spiegato passo nel link qui sopra) per ridurre questo al momento della compilazione di

for(int i = 0; i < size; i++) u[i] = v[i] + w[i]; 

che è ovviamente più veloce e non ha bisogno di una variabile in più.

Answer 1

di rispondere correttamente a questa domanda, è necessario porsi domande in più:

1. sei proprio sicuro che il codice C++ con i modelli si comporta meglio di codice Scala? I benchmark di Moderns mostrano che Java è più veloce di C++ all'inversione della matrice. Ciò è principalmente dovuto a un miglioramento delle VM, così come in HW.

2. Quanto sono grandi i vantaggi per l'azienda che si otterrebbero con uno strumento matrice più veloce rispetto al maggiore costo di gestione della memoria non gestita, puntatori penzolanti e errori e bug incrementati dovuti alla codifica in C++?

3. Se il problema può essere risolto con prestazioni soddisfacenti in Scala su piccola scala e le differenze diventano significative solo su grande scala, non sarebbe ragionevole considerare la suddivisione del problema (moltiplicazione di matrice/vettore) in compiti diversi che può essere eseguito in parallelo?

Nota personale: ho avuto alcune discussioni e-mail con Joshua Bloch, uno dei più influenti sviluppatori Java mai e autore di Effective Java, e lui mi ha puntato verso una presentazione interessante da Brian Goletz (autore di Java Concurrency in Practice e molto influente nel mondo Java pure): Not Your Father's Von Neumann Machine: A Crash Course in Modern Hardware

---

Se si conclude che il beneficio è lì e questo è significativo, e che in futuro il problema siz non crescerà così che y Non è necessario trarre vantaggio dall'esecuzione multi-core, probabilmente è necessario rimanere in C++. Nell'altro caso, date un'occhiata ai Macro Scala, disponibili dalla 2.10 alla M3.

* Extra: evitare una variabile intermedia non ha senso quando si utilizzano linguaggi che vengono eseguiti su una parte superiore della VM come Java o C#. Infatti, come l'articolo che hai indicato correttamente, c'è un certo rischio nel modo in cui la JVM traduce il bytecode java in assemblatore con il JIT. Molte delle ottimizzazioni che è possibile eseguire a mano sono già applicate dalla JVM e la maggior parte di questo ragionamento è inutile se si prende la precauzione di dichiarare metodi e variabili FINALI. *