Re: Identifying sources of allocations in a toy Mandelbrot package

[Tomas Hlavaty <tom@logand.com>]

[-- Attachment #1: Type: text/plain, Size: 1302 bytes --]

On Sat 20 Jan 2024 at 19:03, Psionic K <psionik@positron.solutions> wrote:
> I was mainly hoping to start identifying forms that can do okay even
> in spite of the Elisp runtime, especially for these kind of iteration
> problems that could - but should not - generate lots of garbage.  The
> first rows go by in the blink of an eye because of the cache locality.
> Elisp is almost something.  The memory pathologies are likely
> affecting every other perceived lack of responsiveness.

I was curious about:
- How does native compilation improve things?
- How does fixed point arithmetic improve things?

Run:
(benchmark-run 1 (mandelbrot))

with the attached mandelbrot1.el (floating point):
after emacs-lisp-native-compile-and-load:
=> (120.40541861 1947 93.45048212499998)
after emacs-lisp-byte-compile-and-load:
=> (128.362728323 1942 93.44881820700004)

with the attached mandelbrot.el (fixed point):
after emacs-lisp-native-compile-and-load:
(32.898215598 2 0.09366582000001245)
after emacs-lisp-byte-compile-and-load:
(51.629763289 2 0.09165389300000015)

For comparison, the attached forth version test.fs takes about 6sec.

I find it interesting that:
- native compilation improves so little compared to byte compilation.
- floating point calculations are very slow.
- emacs-lisp is very slow


[-- Attachment #2: mandelbrot1.el --]
[-- Type: application/emacs-lisp, Size: 1675 bytes --]

[-- Attachment #3: mandelbrot.el --]
[-- Type: application/emacs-lisp, Size: 2034 bytes --]

[-- Attachment #4: test.fs --]
[-- Type: text/plain, Size: 1122 bytes --]

\ (compile "time gforth test.fs >a.pnm")
1 16 lshift constant 1fx
: fx ( n -- fx ) 1fx * ;
: fx2 ( n1 n2 -- fx ) 1fx swap */ ;
: fx* ( fx1 fx2 -- fx3 ) 1fx */ ;
: fx^2 ( fx -- fx ) dup fx* ;
      1600 constant w     0 value cx
      1200 constant h     0 value cy
-25 10 fx2 constant x0    0 value zr
-15 10 fx2 constant y0    0 value zi
  4 fx w / constant dxp   0 value v
  3 fx h / constant dyp
: cx! ( n -- ) dxp * x0 + to cx ;
: cy! ( n -- ) dyp * y0 + to cy ;
: nl newline type ;
: p6 ." P6" nl w . h . nl 255 . nl ;
: rgb ( n -- ) dup emit dup emit emit ;
\ : expt ( r1 r2 -- r3 ) fexp fswap fln f* ;
: mandelbrot1 ( -- n )
  0 to v   0 to zr   0 to zi
  begin
    v 256 < ( f -- )
    zr fx^2 zi fx^2 + [ 4 fx ] literal <= ( f1 f2 -- )
  and while
    v 1+ to v
    zr fx^2 zi fx^2 - cx + ( fx -- )
    zr zi fx* 2* cy + to zi
    to zr
  repeat
  \ samples that hit 256 wrap in the graphic to display as zero
  \ exponential 0.8 enhances contrast a bit
  v \ s>f 256e f/ 0.8e expt 256e f* floor f>s
  ;
: dot mandelbrot1 rgb ;
: row w 0 do i cx! dot loop ;
: mandelbrot h 0 do i cy! row loop ;
p6 mandelbrot bye