Ottimizzazione serie mutazione in Clojure

Question

aver letto un paio di post di blog sul tema, ho trovato che mutando una matrice in Clojure come questo:

(defn m [xs ys] 
    (dotimes [i (count xs)] 
    (aset #^ints ys (int i) 
    (int (* (int 3) (int (aget #^ints xs (int i)))))))) 

dove (def xs (into-array Integer/TYPE (range 1000000))) e (def ys (into-array Integer/TYPE (range 1000000)))

ha preso una media di 14ms secondo Criterium, mentre Java per fare lo stesso,

public static int[] m(int[] x, int[] y) 
{ 
    for(int i=0; i<x.length; i++) 
    y[i] = 3*x[i]; 
    return y; 
} 

richiede una media di 800us. **

Sto facendo tutto il possibile per rendere le cose andare veloce e c'è altro posso andare giù per il percorso di ottimizzazione?

** ho cronometrato questi utilizzando Criterium con (report-result (bench (m xs ys)) :verbose) e (report-result (bench (. Test m xs ys)) :verbose)

Answer 1

Prova questo su Clojure 1.3:

(set! *unchecked-math* true) 

(defn m [^longs xs ^longs ys] 
    (dotimes [i (count xs)] 
    (aset ys i 
     (* 3 (aget xs i))))) 

Answer 2

Se volete la velocità, è necessario entrare nel mondo dei primitivi e non lasciarlo fino a quando il gioco è fatto. È inutile iniziare con una scatola Integer i e quindi convertirla in una primitiva in ogni sito di utilizzo. Forse è possibile effettuare dotimes produrre ints (digitare-suggerire la dichiarazione di i), ma non è sicuro. Quello che so funziona è un costrutto loop-recur con inizializzatori primitivi di loop vars: (loop [i (int 0)] ... (recur (unchecked-inc i)). Inoltre, nel tuo esempio hai (int 3). È necessario let che in anticipo in modo da non ripetere l'unboxing in ogni iterazione.

BTW, è possibile utilizzare (int-array (range 1000000)) per creare l'array inizializzato e solo (int-array 1000000) per quello vuoto.

UPDATE

Come di Clojure 1.3, con la sua maggiore supporto per i primitivi, la maggior parte di quello che ho scritto sopra non si applica più. dotimes utilizza già l'aritmetica primitivo, quindi tutto è necessario scrivere per ottenere il massimo delle prestazioni è

(dotimes [i (alength ^ints xs)] 
    (aset ^ints ys i (unchecked-multiply (aget ^ints xs i) 3) 

In sostanza, non int costruttori necessario, e utilizzare unchecked-multiply.