Is byte-compiled code supposed to call `make-byte-code'?

Is byte-compiled code supposed to call `make-byte-code'?

[Paul Pogonyshev]

Trying to disassemble a trivial function that invokes a closure:

(defun xxx (fn)
  (mapcar (lambda (x) (1+ (funcall fn x))) '(1 2 3)))
(disassemble 'xxx)

gives:

0       constant  mapcar
1       constant  make-byte-code
2       constant  257
3       constant  "\300\x01!T\207"
4       constant  vconcat
5       constant  vector
6       stack-ref 6
8       call      1
9       constant  []
10      call      2
11      constant  3
12      constant  "\n\n(fn X)"
13      call      5
14      constant  (1 2 3)
15      call      2
16      return

Is it supposed to build closure bytecode object every time? Shouldn't
it be considered a constant?

GNU Emacs 25.1.50.1 (x86_64-pc-linux-gnu, GTK+ Version 3.20.3) of 2016-05-24

Paul

Re: Is byte-compiled code supposed to call `make-byte-code'?

[Andreas Schwab]

Paul Pogonyshev <pogonyshev@gmail.com> writes:

> Is it supposed to build closure bytecode object every time? Shouldn't
> it be considered a constant?

But it isn't a constant, it depends on the function's argument.

Andreas.

-- 
Andreas Schwab, schwab@linux-m68k.org
GPG Key fingerprint = 58CA 54C7 6D53 942B 1756  01D3 44D5 214B 8276 4ED5
"And now for something completely different."

Re: Is byte-compiled code supposed to call `make-byte-code'?

[Paul Pogonyshev]

Andreas Schwab wrote:
> But it isn't a constant, it depends on the function's argument.

You are right, didn't think about it. However, given that it is a
repetetive process, shouldn't all constant parts of it be moved to C
level instead of bytecode, as an optimization? E.g. add (make-closure
descriptor &rest constants), where descriptor would include the actual
bytecode, arglist, depth and constants inherited from outer closure?
Then `xxx' would disassemble to something like

0       constant  mapcar
1       constant  make-closure
2       constant  <<descriptor>>
3       stack-ref <<fn>>
5       call      2
6       constant  (1 2 3)
7       call      2
9       return

Thus, bytecode size would decrease for closure-heavy code and speed
likely improve as well.

Paul

Re: Is byte-compiled code supposed to call `make-byte-code'?

[Stefan Monnier]

>> But it isn't a constant, it depends on the function's argument.
> You are right, didn't think about it. However, given that it is a
> repetetive process, shouldn't all constant parts of it be moved to C
> level instead of bytecode, as an optimization?

When Emacs-24.1 introduced lexical-binding, the focus was on:
- preserving backward compatibility.
- minimizing the amount of code changed.
- providing correct semantics.
- no speed regression.

IOW performance of lexically scoped code was not on the agenda.

Notice that the problem in the code you quote is not just the amount of
byte-code, but also in the closure that's generated: whether we hide it
inside a new "make-closure" bytecode or not, the construction of the new
closure object is more costly than in most "standard" representation
of closures (which normally only involves construction of one object,
rather than two).

So, yes, there's a fair bit of room for improvement (and not just in
this one particular spot).


        Stefan