Lexical binding: why?

Lexical binding: why?

[Alan Mackenzie]

Hello, Emacs.

What is the purpose of converting Lisp files to use lexical binding?

I always thought the idea was to speed the SW up.  However, when I tried
converting CC Mode to lexical binding, I got the following timings for
two of my personal benchmarks:

                  Dynamic binding             Lexical binding

Benchmark 1           7.249s                      7.423s 

Benchmark 2          16.743s                     16.691s

.  I thus see no speedup from the use of lexical binding.

Have I, perhaps, made some mistake somewhere?  Does anybody else see
significant speed increases through the use of lexical binding?

-- 
Alan Mackenzie (Nuremberg, Germany).

Re: Lexical binding: why?

[Tadeus Prastowo]

Hi Alan,

On Tue, May 28, 2019 at 12:53 PM Alan Mackenzie <acm@muc.de> wrote:
>
> Hello, Emacs.
>
> What is the purpose of converting Lisp files to use lexical binding?

AFAIK, the primary objective is to allow a multi-threaded Emacs.

> I always thought the idea was to speed the SW up.  However, when I tried
> converting CC Mode to lexical binding, I got the following timings for
> two of my personal benchmarks:
>
>                   Dynamic binding             Lexical binding
>
> Benchmark 1           7.249s                      7.423s
>
> Benchmark 2          16.743s                     16.691s
>
> .  I thus see no speedup from the use of lexical binding.

Perhaps it is because a multi-threaded Emacs has not arrived yet?

> Have I, perhaps, made some mistake somewhere?  Does anybody else see
> significant speed increases through the use of lexical binding?
>
> --
> Alan Mackenzie (Nuremberg, Germany).

-- 
Best regards,
Tadeus

Re: Lexical binding: why?

[Stefan Monnier]

> What is the purpose of converting Lisp files to use lexical binding?

The lexical-binding version of Elisp offers closures and avoidance of
corner-case name clashes with higher-order functions.
For this reason, we added it and we're very unlikely to remove it.

In contrast the non-lexical-binding version of Elisp is now
redundant/obsolete because it does not offer any feature not already
available in the lexical-binding mode.  So we only keep it for backward
compatibility and will likely remove it in some distant future.

> I always thought the idea was to speed the SW up.

Not really, no.  It does offer a better potential for optimization, but
nobody has made any effort to take advantage of it so far.

> I thus see no speedup from the use of lexical binding.

That corresponds to my experience as well.  When I installed the
lexical-binding code, my main concern was to not impact existing code,
so the fact that the new lexical-binding mode was "about as fast" was
kind of a happy accident.

> Have I, perhaps, made some mistake somewhere?  Does anybody else see
> significant speed increases through the use of lexical binding?

IIRC some operation in the js2 code was significantly slowed down (in
Emacs-24) by lexical-binding and then (less significantly but still
significantly) sped up when the new condition-case byte-codes were
introduced in 24.4 (and used by default since Emacs-25), so there are
some cases, but by and large I wouldn't expect any major change.


        Stefan

Re: Lexical binding: why?

[Dmitry Gutov]

On 28.05.2019 15:26, Stefan Monnier wrote:
> IIRC some operation in the js2 code was significantly slowed down (in
> Emacs-24) by lexical-binding and then (less significantly but still
> significantly) sped up when the new condition-case byte-codes were
> introduced in 24.4 (and used by default since Emacs-25), so there are
> some cases, but by and large I wouldn't expect any major change.

I think js2-mode in lexical-binding is still ~10% slower than the 
dynamic binding mode, but we switched over anyway because of the sounder 
scoping model and better compiler diagnostics.

Re: Lexical binding: why?

[Stefan Monnier]

> I think js2-mode in lexical-binding is still ~10% slower than the dynamic
> binding mode,

Oh, well!  I thought we had a better story there :-(

Maybe the speed up I remember was linked to the rework I suggested back
then to work around the poor lexical-scoping performance (mainly moving
a condition-case outside of a loop, IIRC) and that actually improved
performance with both lexical and dynamic binding?


        Stefan

Re: Lexical binding: why?

[Alan Mackenzie]

Hello, Stefan.

On Tue, May 28, 2019 at 08:26:16 -0400, Stefan Monnier wrote:
> > What is the purpose of converting Lisp files to use lexical binding?

> The lexical-binding version of Elisp offers closures and avoidance of
> corner-case name clashes with higher-order functions.
> For this reason, we added it and we're very unlikely to remove it.

Perish the thought!  :-)

> In contrast the non-lexical-binding version of Elisp is now
> redundant/obsolete because it does not offer any feature not already
> available in the lexical-binding mode.  So we only keep it for backward
> compatibility and will likely remove it in some distant future.

> > I always thought the idea was to speed the SW up.

> Not really, no.  It does offer a better potential for optimization, but
> nobody has made any effort to take advantage of it so far.

> > I thus see no speedup from the use of lexical binding.

> That corresponds to my experience as well.  When I installed the
> lexical-binding code, my main concern was to not impact existing code,
> so the fact that the new lexical-binding mode was "about as fast" was
> kind of a happy accident.

> > Have I, perhaps, made some mistake somewhere?  Does anybody else see
> > significant speed increases through the use of lexical binding?

> IIRC some operation in the js2 code was significantly slowed down (in
> Emacs-24) by lexical-binding and then (less significantly but still
> significantly) sped up when the new condition-case byte-codes were
> introduced in 24.4 (and used by default since Emacs-25), so there are
> some cases, but by and large I wouldn't expect any major change.

OK, thanks for the illucidation.

Just in passing, the Elisp manual doesn't seem to be as helpful as it
might be, here.  It doesn't positively recommend using lexical binding
in new programs, for example.

Just in passing2, it seems to be difficult to enable lexical binding
conditionally.  The best that I can come up with is something like:

-*- eval: (setq lexical-binding (> emacs-major-version 25)) -*-

, but that has the irritating consequence of querying the user with "Are
you sure?" for each such file that gets loaded, even though
lexical-binding is a "safe" variable.

>         Stefan

-- 
Alan Mackenzie (Nuremberg, Germany).

Re: Lexical binding: why?

[Dmitry Gutov]

On 28.05.2019 16:25, Stefan Monnier wrote:
> Maybe the speed up I remember was linked to the rework I suggested back
> then to work around the poor lexical-scoping performance (mainly moving
> a condition-case outside of a loop, IIRC) and that actually improved
> performance with both lexical and dynamic binding?

No, you remembered correctly: without the new byte-code, the situation 
was noticeably worse. Though maybe it was a 'throw' inside a loop with 
'catch' outside it.

The 10% figure I just got from this thread: 
https://github.com/mooz/js2-mode/issues/524#issuecomment-483010120

But it's actually comparing against an older js2-mode version, not 
against the current code in dynamic-binding mode. I don't have time to 
redo the measurements now myself, but thinking back, maybe the result of 
the byte-code introduction was that lexical-binding became slightly 
faster than dynamic, though not by much.

Re: Lexical binding: why?

[John Wiegley]

>>>>> "AM" == Alan Mackenzie <acm@muc.de> writes:

AM> I always thought the idea was to speed the SW up.

Note that when I did performance benchmarking of the byte-code intrepreter, by
far the slowest (and most frequent) operation was looking up dynamic
variables. I have the sense that are many sexy optimizations we could do in
this area, though I believe that work has not begun yet.

-- 
John Wiegley                  GPG fingerprint = 4710 CF98 AF9B 327B B80F
http://newartisans.com                          60E1 46C4 BD1A 7AC1 4BA2

Re: Lexical binding: why?

[Stefan Monnier]

> Just in passing, the Elisp manual doesn't seem to be as helpful as it
> might be, here.  It doesn't positively recommend using lexical binding
> in new programs, for example.

Thanks for the heads up.

> Just in passing2, it seems to be difficult to enable lexical binding
> conditionally.  The best that I can come up with is something like:
>
> -*- eval: (setq lexical-binding (> emacs-major-version 25)) -*-

Hmm... why do you need that?  Is that because of a performance problem
in Emacs-24's lexical-binding support (likely the one that affects
condition-case and friends)?


        Stefan

Re: Lexical binding: why?

[Alan Mackenzie]

Hello, Stefan.

On Tue, May 28, 2019 at 13:21:22 -0400, Stefan Monnier wrote:
> > Just in passing2, it seems to be difficult to enable lexical binding
> > conditionally.  The best that I can come up with is something like:

> > -*- eval: (setq lexical-binding (> emacs-major-version 25)) -*-

> Hmm... why do you need that?  Is that because of a performance problem
> in Emacs-24's lexical-binding support (likely the one that affects
> condition-case and friends)?

I was thinking more of a bug, since fixed, in older versions of the
lexical-binding code.  Purely hypothetically at the moment, of course.
But this code is surely not so simple that bugs can be ruled out.

But performance problems in older versions of l-b would also be a reason.

For consistency with other features, which can all be enabled
conditionally, surely lexical-binding should also be conditionally
enablable in a reasonable way.

>         Stefan

-- 
Alan Mackenzie (Nuremberg, Germany).

Re: Lexical binding: why?

[Stefan Monnier]

> I was thinking more of a bug, since fixed, in older versions of the
> lexical-binding code.  Purely hypothetically at the moment, of course.
> But this code is surely not so simple that bugs can be ruled out.

Oh, so it's a hypothetical need.

> For consistency with other features, which can all be enabled
> conditionally, surely lexical-binding should also be conditionally
> enablable in a reasonable way.

Based on the 7 years of experience since Emacs-24.1 was released,
I think YAGNI is a good reason not to bother trying to implement it.

Especially since: if the file's content really does work when
lexical-binding is nil, then a simple workaround for the lack of this
feature is to keep using lexical-binding=nil until the problematic
version(s) are not supported any more and you can set
lexical-binding=t unconditionally.

While I do hope we'll be able to drop support for lexical-binding=nil in
some distant future, "distant" is an import characterization.  I'd be
amazed if this happened before 2030.


        Stefan