Existe-t-il des compilateurs de code natif Lisp?

Question

Existe-t-il des compilateurs de code natif pour Lisp? Dans quelle mesure peut-il même être compilé, avec toute sa nature dynamique, son garbage collection, ses macros et quoi d'autre?

Answer 1

De nombreux compilateurs Lisp compiler en natif code. "Native" signifie ici "code machine' (x86 32 bits ou 64 bits mode, PowerPC, SPARC, ...).

Autres questions:

• peut 'non-native code compilateurs" générer des fichiers exécutables? -> Oui.

• peut "code natif compilateurs" générer des fichiers exécutables? -> Oui.

• comment "native" est "native"? -> Système Lisp sera la plupart du temps ont leur propre structure de données interne de mise en page (CLOS classes), leur propre erreur de manipulation ("conditions"), leur propre gestion de la mémoire (garbage collection), leurs propres bibliothèques, ...

• peut Lisp fonctionner sans un GC? -> Généralement pas. Il y a des exceptions.

• ce sujet de la taille de l'application? -> Par défaut de moyens simples pour générer un Lisp demande souvent conduire à de grandes exécutables. Les exécutables inclure l'ensemble de Lisp, y compris sa bibliothèque, les noms de tous les symboles, les informations sur les listes d'arguments de fonctions, le compilateur, débogueur, emplacement du code source de l'information, et plus encore. Certains compilateurs génèrent également largish code (SBCL est un exemple).

• existe-il des moyens pour réduire la taille des applications? -> Cela dépend du système Lisp. Commercial Lisp comme les systèmes de LispWorks et Allegro CL. Pour la livraison d'applications, ils peuvent retirer de code inutilisé, supprimer les informations de débogage, de supprimer certaines parties du Lisp (bibliothèques, compilateur, ...) et plus.

• peut Common Lisp systèmes de générer de petits fichiers exécutables. Je veux dire, vraiment petit. -> Pas vraiment. Les exécutables sont grandes (CCL) ou très grande (SBCL). Certains Common Lisp systèmes peuvent générer de la taille moyenne des fichiers exécutables. Mais aucun ne peut vraiment générer de petits fichiers exécutables.

• il n'y a vraiment aucun moyen de générer de très petits fichiers exécutables? -> Il y a des années compilateurs ont été écrits, pour générer relativement compact C de code sans de grandes bibliothèques. Mais ces compilateurs ne sont pas entretenus.

• il existe d'autres moyens pour réduire les exécutables? -> Si vous souhaitez exécuter plus d'un Lisp application, il est logique de réutilisation de l'exécution, compilateur, bibliothèques, dans une ou plusieurs bibliothèques partagées. De cette façon, le code à livrer sera plus petite, lorsque l'exécution est déjà installé en tant que bibliothèque partagée (ou similaire).

• comment puis-je savoir ce que le Lisp, je suis en utilisant soutient que l'application de la livraison? -> lire le manuel et de demander à d'autres utilisateurs.

• ok, donc la plupart des systèmes de Common Lisp ne peut pas générer de minuscules applications. Existe-il d'autres dialectes Lisp qui peuvent générer de petits fichiers exécutables. -> Oui, certains compilateur Scheme peut.

• comment Common Lisp gérer les erreurs d'exécution? -> dépend de la façon de générer l'application. Par défaut, vous obtenez un Lisp débogueur (sauf si vous l'avez supprimé). Mais vous pouvez utiliser vos propres routines de gestion des erreurs dans votre application et peut empêcher le débogueur de figurant.

• quelles sont Common Lisp atouts, lors de la génération de très petits fichiers exécutables n'en est pas une? -> vous pouvez inclure un REPL pour interagir avec l'application, vous pouvez utiliser un compilateur pour compiler de nouvelles (ou code modifié) au moment de l'exécution, vous pouvez utiliser le FASL (compiled code Lisp) chargeur pour CHARGER d'autres en code natif au moment de l'exécution (pensez à des plugins, des patchs, des extensions, ...), sophistiqué erreur de manipulation, y compris le recouvrement d'erreur est possible, ...

• mais Lisp est dynamique? -> Oui, la dynamique signifie que cela peut changer beaucoup de choses au cours de l'exécution. Par exemple, en Common Lisp, vous pouvez changer le CLOS de la classe au moment de l'exécution et de la classe des' instances d'adopter les modifications. Mais les différents systèmes Lisp ont différentes façons de supprimer certaines des caractéristiques dynamiques. Les Structures sont moins dynamique que le CLOS des classes. Vous pouvez déclarer les types et les compiler avec différents paramètres d'optimisation (vitesse, sécurité, debug, ...). Vous pouvez les fonctions inline. Et de plus en plus.

Une façon simple de voir le code compilé pour des fonctions est d'utiliser la Common Lisp fonction DÉMONTER. Exemple dans la Clozure CL sur un système x86-64 Mac

? (defun foo (x y) (if (= x y) (sin x) (* y (cos x))))
FOO
? (disassemble 'foo)
L0
  [0]     (leaq (@ (:^ L0) (% rip)) (% fn))
  [7]     (cmpl ($ 16) (% nargs))
  [10]    (jne L209)
  [16]    (pushq (% rbp))
  [17]    (movq (% rsp) (% rbp))

...

  [172]   (pushq (@ 77752))
  [179]   (jmpq (@ 10 (% temp0)))
L189
  [189]   (leaq (@ (:^ L0) (% rip)) (% fn))
  [196]   (jmpq (@ .SPNVALRET))
L209
  [209]   (uuo-error-wrong-number-of-args)
NIL

La sortie de DÉMONTER dépend évidemment de l'architecture du processeur, le système d'exploitation, le compilateur Lisp et les paramètres d'optimisation actuels.

Answer 2

Il y a beaucoup de compilateurs Lisp que les compiler en code natif. CMUCL, SBCL, ClozureCL sont connus chez l'open-source compilateurs Lisp.

La collecte des ordures n'est pas un obstacle à la compilation en code natif. Aussi, dans certains cas, Lisp pouvez utiliser l'allocation de pile qui n'a pas besoin de GC et peut grandement améliorer les performances (à l'aide de dynamic-mesure de la déclaration; au moins SBCL prend en charge ce).

Les Macros (et tout le code qui est exécuté à lire-temps (lire les macros et read-eval), au moment de la compilation (macros, compilateur macros, code eval-quand)) nécessitent une compilation incrémentielle (première macro-fonction doit être compilé, puis le code qui utilise la macro peut être compilé). Cela complique un peu la compilation, mais il n'est pas trop un problème. Aussi, les macros et le compilateur macros même aider le processus de compilation parce qu'ils permettent au programmeur d'écrire des générateurs de code et le code optimiseurs, essentiellement personnalisation du compilateur.

Ainsi, le compilateur est plus compliqué que les quelques plus simple, les langues (comme en C), mais la complexité est gérable (voir la Conception de la CMU Common Lisp).

La nature dynamique de la Common Lisp est contrôlable et conçu pour être efficacement compilable. Contrairement à d'autres langages dynamiques (par exemple, Python), le dynamisme est limitée (par exemple, vous ne pouvez pas prendre l'actuel environnement lexical, au moment de l'exécution) qui donnent les compilateurs d'une certaine liberté pour optimiser.

Answer 3

Il existe un grand nombre de compilateurs Lisp en code natif, voir http://www.thefreecountry.com/compilers/commonlisp.shtml et par exemple le compilateur Lisp commun CMU.

Answer 4

Tu paries. Chez Scheme (un compilateur commercial) est l'un des meilleurs. Gambit et Larceny sont des compilateurs de recherche qui génèrent également du code natif.

Answer 5

N'oubliez pas le régime de poulet .