> But it doesn't try to be a standalone platform for
> performance-oriented Lisp developers.
I hope that Emacs merges with SBCL.
Emacs and SBCL are amongst the greatest inventions in the history of the world.
Of course I should mention gcc and Linux and so much that the Free Software Foundation has given us, e.g., their 'sort' which can sort files of amazing length at amazing speed. It is crucial to my ongoing work on automatic theorem proving. If you've got a billion clause records and want to flush duplicates, who you gonna call but /usr/bin/sort. That's what I say, and what I do. To do that in Lisp might consume more space than I have except on my SD card. I run on a $100 chromebook and my 256 gb SD card only cost $30, and 1 tb SD cards are coming soon at a price I think I will be able to afford.
But of course, Coq may be the fastest thing except for C. And it has 'sanitary' macros.
Where would I be without unsanitary macros! My sorting algorithm 'msa' depends upon them!
But what do I know about sanitation.
I think that the following are very unsanitary, but what do I know?
(eval
'(defmacro key (x)
(cond (key
(cond ((symbolp key) `(the ,msa-type (,key ,x)))
(t `(the ,msa-type (funcall ,key ,x)))))
(t `(the ,msa-type ,x)))))
(eval
'(defmacro msa-equal (x y)
(cond (msa-all-keys-real `(eql ,x ,y))
(t `(equal ,x ,y)))))
(eval
'(defmacro msa-predicate (x y)
(cond ((symbolp msa-predicate) `(,msa-predicate ,x ,y))
(t `(funcall ',msa-predicate ,x ,y)))))
Bob,
welcome to the emacs-devel list, and thanks a lot for *your* wonderful
contributions (theorem prover, string search, and Lisp benchmarking -
I remember boyer.lisp from RPG's reference work[1]).
On Thu, Feb 8, 2024 at 8:15 AM Robert Boyer
<robertstephenboyer@gmail.com> wrote:
>
> Emacs 27.1 has a 'sort' function that takes longer than stable-sort of SBCL. Maybe
> by a factor of 2. See also my attached file 'ms.lisp'.
>
> There may be a lot that can be improved in Emacs'
> handling of cl-loop, setf, elt, or cl-random.
In this case, cl-random seems to be the main culprit for the slow
initialization—replacing that with plain "random" speeds it up by
about a factor of ten. There was some discussion on the list recently
about cl-random vs. random. The main functional difference is that
cl-random supports a defined state. But the performance difference may
be due more to the fact that random is written in C, and cl-random in
Lisp.
As for the sorting itself, both Emacs and SBCL seem to use mergesort
in their implementations of (stable-)sort. Emacs's implementation is
written in C, SBCL's in Lisp. Performance is quite similar—on my
system (Apple Macbook Air M2) Emacs takes about 35% longer to sort a
million random numbers than SBCL. (On the other hand when sorting it
again, i.e. when the vector is already fully sorter, Emacs is quite a
bit faster than SBCL—maybe Emacs chose to optimize for partly-sorted
vectors at the expense of a bit of performance for random input.)
In general, the Emacs Lisp runtime system and compiler(s) aren't as
optimized as SBCL for general Lisp use. But it gets quite close!
On the other hand, Emacs has editor-specific code (e.g. redisplay) and
data structures (e.g. buffers) which are highly optimized and partly
written in C. But it doesn't try to be a standalone platform for
performance-oriented Lisp developers. Of course Emacs is very
suitable as a Software Development Environment for systems such as
SBCL, and there are many good integration options—personally I use the
SLIME package these days.
Best regards, and enjoy Lisping in Emacs!
--
Simon.
> ;; First some Emacs, with times on my $100 Chromebook.
>
> (setq n 6)
> (defun make-random-array (n)
> (let ((a (make-vector n 0)))
> (cl-loop for i below n do
> (setf (elt a i) (cl-random 1000000)))
> a))
> (byte-compile 'make-random-array)
> (benchmark '(setq foo (make-random-array (expt 10 n))) 1) -- 2.3 seconds
> (benchmark '(sort foo '<) 1) -- 1 second
>
> ;; Second some Common Lisp, with times for SBCL on my $100 Chromebook.
>
> (defparameter n 6)
> (defun make-random-array (n)
> (declare (fixnum n))
> (let ((a (make-array n)))
> (declare (type array a))
> (loop for i fixnum below n do
> (setf (aref a i) (random most-positive-fixnum)))
> a))
> (time (defparameter foo (make-random-array (expt 10 n)))) -- .041 seconds
> (time (progn (stable-sort foo '<) nil)) -- .45 seconds
>
> Thanks so much for Emacs, which is so great that I cannot put it
> into words.
>
> Bob
[1] https://dreamsongs.com/Files/Timrep.pdf