Performance des structures paresseuses de Clojure par rapport aux hachages/ensembles/vecteurs?

Question

J'utilise des structures de données Clojure partout mais je n'utilise aucune évaluation paresseuse. Y a-t-il une pénalité de performance pour l'utilisation de structures paresseuses partout?

Answer 1

à partir du code source:

clojure.lang.Cons (élément de liste stricte, clojure.lang.PersistentList est très similaire), https://github.com/clojure/clojure/blob/1.2.0/src/jvm/clojure/lang/Cons.java#L34

public Object first(){ 
    return _first; 
} 

clojure.lang.LazySeq (élément de séquence paresseux), 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(); 
} 

où

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; 
} 

Donc, vous êtes définitivement en payant un prix. Il dépend beaucoup de chaque cas d'utilisation particulier combien ce prix vous affecte et s'il est compensé par les économies de mémoire et le manque de calcul gaspillé que l'évaluation paresseuse vous achète.

Answer 2

Il y a un overhead de structures paresseuses (la réponse de pmjordan est grande pour vous donner les détails sanglants .....). Mon estimation très approximative est que vous payez une pénalité de 2-5x.

Cependant, il y a aussi des bons côtés:

• évaluation Lazy signifie que votre jeu de travail de données peut être plus petit, car il est créé uniquement en cas de besoin. Ce peut améliorer votre utilisation du cache et donc les performances dans certains cas
• L'évaluation paresseuse vous aide à écrire un code plus simple et plus propre. Vous pouvez donc vous concentrer sur l'écriture de meilleurs algorithmes. L'avantage d'avoir un meilleur algorithme (par exemple O (n log n) vs O (n^2)) peut valoir beaucoup plus que l'overhead de l'évaluation paresseuse

Mon conseil serait d'utiliser librement l'évaluation paresseuse sauf si vous êtes sûr que vous êtes dans une situation où vous avez réellement besoin de hautes performances et que vous n'avez pas les moyens de payer les frais généraux (traitement d'image, etc.)