Discussion :

[rutabagas]

Bonjour,
Suis pas un expert en common-lisp mais je trouve qu'il est long par rapport aux autres. J'ai trouvé le programme suivant en exemple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
#!/usr/bin/clisp
(dotimes (x 20)
  (dotimes (y 20)
    (format t "~3d " (* (1+ x) (1+ y))))
  (format t "~%"))

Je l'execute avec :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
time ./monprog.cl

et j'obtiens:
real 0m0.055s
user 0m0.032s
sys 0m0.024s

Le même programme, réécrit en:

ocaml :
real 0m0.025s
user 0m0.020s
sys 0m0.004s

perl:
real 0m0.011s
user 0m0.008s
sys 0m0.004s

c:
real 0m0.002s
user 0m0.000s
sys 0m0.000s

J'ai vu dans d'autres discussions que certains programmeurs utilisent lisp pour l'IA. Est-ce que la lenteur de lisp n'est pas un handicap ?
Ou bien est-ce qu'il y a un moyen de le faire aller plus vite ?

Merci.

[GnuVince]

Clisp est probablement l'implémentation de Common Lisp la plus lente. Va chercher SBCL (qui génère du code natif) et refait ton test.

[rutabagas]

Clisp est probablement l'implémentation de Common Lisp la plus lente. Va chercher SBCL (qui génère du code natif) et refait ton test.

Merci pour ta réponse.
J'ai installé sbcl (un petit coup de apt-get install sbcl)

mais avec :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
#!/usr/bin/sbcl

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
./monprog.cl

ne fait que démarrer sbcl ;-)

avec

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
#!/usr/bin/sbcl --userinit

cela marche mais je ne sors pas de sbcl et donc je ne peux pas utiliser "time"

Je dois louper quelque chose dans la doc ...
Comme dit l'Anglais "I am stuck" ....

D'autre part common-lisp est plus convivial, on peut remonter sur les expressions précédentes, pas avec sbcl si on s'est planté il faut tout réécrire.

[GnuVince]

Merci pour ta réponse.
J'ai installé sbcl (un petit coup de apt-get install sbcl)

mais avec :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
#!/usr/bin/sbcl

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
./monprog.cl

ne fait que démarrer sbcl ;-)

avec

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
#!/usr/bin/sbcl --userinit

cela marche mais je ne sors pas de sbcl et donc je ne peux pas utiliser "time"

Je dois louper quelque chose dans la doc ...
Comme dit l'Anglais "I am stuck" ....

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
$ cat > hello.lisp
(format t "Hello world~%")
(quit)
^D
$ sbcl --noinform --eval '(progn (compile-file "hello.lisp") (quit))'
; compiling file "/home/vfoley/prog/lisp/hello.lisp" (written 21 DEC 2007 02:46:28 PM):
; compiling (FORMAT T ...)
; compiling (QUIT)
 
; /home/vfoley/prog/lisp/hello.fasl written
; compilation finished in 0:00:00
$ sbcl --noinform --load hello.fasl
Hello world
$

D'autre part common-lisp est plus convivial, on peut remonter sur les expressions précédentes, pas avec sbcl si on s'est planté il faut tout réécrire.

La plupart du monde qui font du Lisp utilisent Emacs avec SLIME qui donne un accès direct au REPL et tu peux utiliser le clavier pour rappeler des commandes.

[Garulfo]

[...]
J'ai vu dans d'autres discussions que certains programmeurs utilisent lisp pour l'IA. Est-ce que la lenteur de lisp n'est pas un handicap ?

Pour répondre spécifiquement à ceci, la réponse est oui. C'est un handicap. Et plusieurs travaux modernes se tournent vers d'autres langages, dont le C. Il faut alors revoir les techniques et obtenir d'autres algorithmes se qui se fait par des recherches universitaires de haut-niveau.

[GnuVince]

Voici une différence de performance entre SBCL et Clisp.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
* (time (loop for i from 1 to 100000 count (is-prime i)))
 
Evaluation took:
  1.325 seconds of real time
  1.31 seconds of user run time
  0.0 seconds of system run time
  [Run times include 0.04 seconds GC run time.]
  0 page faults and
  122,059,280 bytes consed.
9592
 
 
[3]> (time (loop for i from 1 to 100000 count (is-prime i)))
Real time: 13.130319 sec.
Run time: 13.13 sec.
Space: 328130352 Bytes
GC: 486, GC time: 4.68 sec.
9592

Et le programme:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
(defun range (start stop)
  (loop for i from start to stop collect i))
 
(defun any (proc lst)
  (reduce #'(lambda (x y)
              (or x (funcall proc y)))
          lst
          :initial-value nil))
 
(defun is-prime (n)
  (let ((first-primes (list 2 3 5 7 11 13 17 19 23 29 31 37
                            41 43 47 53 59 61 67 71 73 79 83
                            89 97)))
    (cond ((member n first-primes) t)
          ((< n 2) nil)
          ((= 0 (mod n 2)) nil)
          ((any #'(lambda (x) (= 0 (rem n x))) (range 2 (sqrt n))) nil)
          (t (not (any #'(lambda (x) (= 0 (rem n x)))
                       (range 2 (sqrt n))))))))

[rutabagas]

Voici une différence de performance entre SBCL et Clisp.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
* (time (loop for i from 1 to 100000 count (is-prime i)))
 
Evaluation took:
  1.325 seconds of real time
  1.31 seconds of user run time
  0.0 seconds of system run time
  [Run times include 0.04 seconds GC run time.]
  0 page faults and
  122,059,280 bytes consed.
9592
 
 
[3]> (time (loop for i from 1 to 100000 count (is-prime i)))
Real time: 13.130319 sec.
Run time: 13.13 sec.
Space: 328130352 Bytes
GC: 486, GC time: 4.68 sec.
9592

Merci de ces exemples.
Pour le premier je n'ai pas la fonction is-prime mais en mettant simplement
count i à la place cela donne une grande différence.
Mais je me suis fais un exemple:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
(time (loop for i below 100000 count (print i)))

et avec sbcl cela donne:
Evaluation took:
3.139 seconds of real time
0.196013 seconds of user run time
0.084006 seconds of system run time
[Run times include 0.032 seconds GC run time.]
0 calls to %EVAL
0 page faults and
191,992,112 bytes consed.
100000

et avec clisp:
Real time: 3.49644 sec.
Run time: 3.072192 sec.
Space: 95209624 Bytes
GC: 72, GC time: 0.424025 sec.
100000

Pour le Real time il n'y a pas beaucoup d'écart, et pour l'exemple que j'ai donné au debut, avec le fichier "monprog.fasl" l'execution est plus longue
avec sbcl que l'execution de "monprog.cl avec clisp.

Merci de m'avoir fait découvrir sbcl.
Merci aussi Garulfo pour cette précision.

[Garulfo]

Est-ce ?

[rutabagas]

Est-ce ?

Ben d'après ta réponse précédente ce n'est pas nous sur le forum qui feront aller plus vite clisp ou sbcl mais ceci dit j'ai résolu le problème pour pouvoir remonter sur les expressions avec sbcl: j'ai installé le package "rlwrap".