Rendimiento de estructuras perezosas Clojure vs hashes/sets/vectores?

Question

Estoy usando estructuras de datos de Clojure en todas partes pero no estoy usando ninguna evaluación perezosa. ¿Hay una penalización de rendimiento por usar estructuras perezosas en todas partes?

Answer 1

A partir del código fuente:

clojure.lang.Cons (estricta elemento de la lista, clojure.lang.PersistentList es muy similar), https://github.com/clojure/clojure/blob/1.2.0/src/jvm/clojure/lang/Cons.java#L34

public Object first(){ 
    return _first; 
} 

clojure.lang.LazySeq (elemento de secuencia perezoso), https://github.com/clojure/clojure/blob/1.2.0/src/jvm/clojure/lang/LazySeq.java#L77

public Object first(){ 
    seq(); 
    if(s == null) 
     return null; 
    return s.first(); 
} 

donde

final synchronized Object sval(){ 
    if(fn != null) 
     { 
     try 
      { 
      sv = fn.invoke(); 
      fn = null; 
      } 
     catch(Exception e) 
      { 
      throw new RuntimeException(e); 
      } 
     } 
    if(sv != null) 
     return sv; 
    return s; 
} 

final synchronized public ISeq seq(){ 
    sval(); 
    if(sv != null) 
     { 
     Object ls = sv; 
     sv = null; 
     while(ls instanceof LazySeq) 
      { 
      ls = ((LazySeq)ls).sval(); 
      } 
     s = RT.seq(ls); 
     } 
    return s; 
} 

Así que usted es definitivamente pagando un precio. Depende mucho de cada caso de uso particular cuánto le afecta ese precio y si se ve compensado por los ahorros de memoria y la falta de cálculos desperdiciados que la evaluación lenta le compra.

Answer 2

Hay una sobrecarga de estructuras perezosas (la respuesta de pmjordan es genial para darle los detalles sangrientos .....). Mi estimación aproximada es que pagas una multa de 2-5 veces.

Sin embargo, también hay algunos aspectos positivos:

• La evaluación perezosa, significa que el conjunto de trabajo de los datos puede ser menor, ya que sólo se crea cuando sea necesario. Este puede mejorar la utilización de su memoria caché y, por lo tanto, el rendimiento en algunos casos
• La evaluación lenta le ayuda a escribir un código más simple y limpio. Para que pueda centrar su atención en escribir mejores algoritmos. El beneficio de tener un mejor algoritmo (p. Ej. O (n log n) vs O (n^2)) puede valer mucho más que la sobrecarga de evaluación perezosa

Mi consejo sería utilizar la evaluación diferida libremente a menos que esté seguro de que se encuentra en una situación en la que realmente necesita un alto rendimiento y no puede pagar los gastos generales (por ejemplo, procesamiento de imágenes o algo así ...)