Prevent inlining

Prevent inlining

[Stefan Israelsson Tampe]

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

Hi all,

Current guile inlines even variables exposed in the module interface, and I
understand that we must live with that and code around it. So here is a few
tips how to mitigate it.

The simplest way is to put this definition in a module:
------------------------
(define-module (syntax not-inline)
  #:export (not-inline))

(cond-expand
  (guile-3.0
     (define (not-inline x) x))
  ((or (guile-2.0 guile-2.2)
     (define-syntax-rule (not-inline x) x)))

-------------------------------------
And then in another module do,

(use-modules (syntax not-inline))
(define variable (not-inline 12))
(define function (not-inline (lambda () ...)))
etc

This is also an option (not perfect but you get the gist)

-----------------------------------------------------------------
(define-module (syntax define-not-inlinable)
   #:use-module (syntax not-inline)
   #:export (inline define lambda  define* lambda* define-values)
(define inline (lambda (x) x))
(define-syntax define
   (syntax-rules (inline)
      ((define (f . x) . code)
       (define f (not-inline (lambda x . code)))
      ((define f (inline x))
       (define f x))
      ((define f x)
       (define f (not-inlinable x))))
----------------------------------------------------------------------------------
using this module will make all usual define not inlineable and to enable
inlining you would
explicitly ask for it like

(define f (inline (lambda (x) (+ x 10))))

If there is a need for this I can write the modules and expose it on the
intertubes.

WDYT

/Stefan

[-- Attachment #2: Type: text/html, Size: 2227 bytes --]

Re: Prevent inlining

[Linus Björnstam]

If guile ever gets cross-module Inlining in even the simplest form, this will break. This kind of inlining is probably the most secure one to rely on ever (my for loops rely on it, for example). A more future proof option is maybe to (set! ...) A variable within the same module, which makes it implicitly boxed. Slow unless guile is able to do unboxing...

Ludo used the trick here: http://git.savannah.gnu.org/cgit/guile.git/commit/?id=bf1f5422bdb364667d6761dd73454558d6dbf895

-- 
  Linus Björnstam

On Wed, 12 Feb 2020, at 18:44, Stefan Israelsson Tampe wrote:
> Hi all,
> 
> Current guile inlines even variables exposed in the module interface, 
> and I understand that we must live with that and code around it. So 
> here is a few tips how to mitigate it.
> 
> The simplest way is to put this definition in a module:
> ------------------------
> (define-module (syntax not-inline)
>  #:export (not-inline))
> 
> (cond-expand
>  (guile-3.0
>  (define (not-inline x) x))
>  ((or (guile-2.0 guile-2.2)
>  (define-syntax-rule (not-inline x) x)))
> 
> -------------------------------------
> And then in another module do,
> 
> (use-modules (syntax not-inline))
> (define variable (not-inline 12))
> (define function (not-inline (lambda () ...)))
> etc
> 
> This is also an option (not perfect but you get the gist)
> 
> -----------------------------------------------------------------
> (define-module (syntax define-not-inlinable)
>  #:use-module (syntax not-inline)
>  #:export (inline define lambda define* lambda* define-values)
> (define inline (lambda (x) x))
> (define-syntax define
>  (syntax-rules (inline)
>  ((define (f . x) . code)
>  (define f (not-inline (lambda x . code)))
>  ((define f (inline x))
>  (define f x))
>  ((define f x)
>  (define f (not-inlinable x))))
> ----------------------------------------------------------------------------------
> using this module will make all usual define not inlineable and to 
> enable inlining you would
> explicitly ask for it like
> 
> (define f (inline (lambda (x) (+ x 10))))
> 
> If there is a need for this I can write the modules and expose it on 
> the intertubes.
> 
> WDYT
> 
> /Stefan
> 
> 
> 
>

Re: Prevent inlining

[Stefan Israelsson Tampe]

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

No even if you have cross module inlining you will still be able to tell i
a module will allow inlining or not else you will break quite a lot of nice
scheme idioms.
This means that this is indeed future proof.

On Wed, Feb 12, 2020 at 10:50 PM Linus Björnstam <
linus.bjornstam@veryfast.biz> wrote:

> If guile ever gets cross-module Inlining in even the simplest form, this
> will break. This kind of inlining is probably the most secure one to rely
> on ever (my for loops rely on it, for example). A more future proof option
> is maybe to (set! ...) A variable within the same module, which makes it
> implicitly boxed. Slow unless guile is able to do unboxing...
>
> Ludo used the trick here:
> http://git.savannah.gnu.org/cgit/guile.git/commit/?id=bf1f5422bdb364667d6761dd73454558d6dbf895
>
> --
>   Linus Björnstam
>
> On Wed, 12 Feb 2020, at 18:44, Stefan Israelsson Tampe wrote:
> > Hi all,
> >
> > Current guile inlines even variables exposed in the module interface,
> > and I understand that we must live with that and code around it. So
> > here is a few tips how to mitigate it.
> >
> > The simplest way is to put this definition in a module:
> > ------------------------
> > (define-module (syntax not-inline)
> >  #:export (not-inline))
> >
> > (cond-expand
> >  (guile-3.0
> >  (define (not-inline x) x))
> >  ((or (guile-2.0 guile-2.2)
> >  (define-syntax-rule (not-inline x) x)))
> >
> > -------------------------------------
> > And then in another module do,
> >
> > (use-modules (syntax not-inline))
> > (define variable (not-inline 12))
> > (define function (not-inline (lambda () ...)))
> > etc
> >
> > This is also an option (not perfect but you get the gist)
> >
> > -----------------------------------------------------------------
> > (define-module (syntax define-not-inlinable)
> >  #:use-module (syntax not-inline)
> >  #:export (inline define lambda define* lambda* define-values)
> > (define inline (lambda (x) x))
> > (define-syntax define
> >  (syntax-rules (inline)
> >  ((define (f . x) . code)
> >  (define f (not-inline (lambda x . code)))
> >  ((define f (inline x))
> >  (define f x))
> >  ((define f x)
> >  (define f (not-inlinable x))))
> >
> ----------------------------------------------------------------------------------
> > using this module will make all usual define not inlineable and to
> > enable inlining you would
> > explicitly ask for it like
> >
> > (define f (inline (lambda (x) (+ x 10))))
> >
> > If there is a need for this I can write the modules and expose it on
> > the intertubes.
> >
> > WDYT
> >
> > /Stefan
> >
> >
> >
> >
>

[-- Attachment #2: Type: text/html, Size: 3426 bytes --]

Re: Prevent inlining

[Linus Björnstam]

Will it not inline "(not-inline x)" and then peval it to x? What are you trying to avoid? I am out on very deep water here, now I am just genuinely curious :D
-- 
  Linus Björnstam

On Thu, 13 Feb 2020, at 08:36, Stefan Israelsson Tampe wrote:
> No even if you have cross module inlining you will still be able to 
> tell i a module will allow inlining or not else you will break quite a 
> lot of nice scheme idioms.
> This means that this is indeed future proof.
> 
> On Wed, Feb 12, 2020 at 10:50 PM Linus Björnstam 
> <linus.bjornstam@veryfast.biz> wrote:
> > If guile ever gets cross-module Inlining in even the simplest form, this will break. This kind of inlining is probably the most secure one to rely on ever (my for loops rely on it, for example). A more future proof option is maybe to (set! ...) A variable within the same module, which makes it implicitly boxed. Slow unless guile is able to do unboxing...
> > 
> >  Ludo used the trick here: http://git.savannah.gnu.org/cgit/guile.git/commit/?id=bf1f5422bdb364667d6761dd73454558d6dbf895
> > 
> >  -- 
> >  Linus Björnstam
> > 
> >  On Wed, 12 Feb 2020, at 18:44, Stefan Israelsson Tampe wrote:
> >  > Hi all,
> >  > 
> >  > Current guile inlines even variables exposed in the module interface, 
> >  > and I understand that we must live with that and code around it. So 
> >  > here is a few tips how to mitigate it.
> >  > 
> >  > The simplest way is to put this definition in a module:
> >  > ------------------------
> >  > (define-module (syntax not-inline)
> >  > #:export (not-inline))
> >  > 
> >  > (cond-expand
> >  > (guile-3.0
> >  > (define (not-inline x) x))
> >  > ((or (guile-2.0 guile-2.2)
> >  > (define-syntax-rule (not-inline x) x)))
> >  > 
> >  > -------------------------------------
> >  > And then in another module do,
> >  > 
> >  > (use-modules (syntax not-inline))
> >  > (define variable (not-inline 12))
> >  > (define function (not-inline (lambda () ...)))
> >  > etc
> >  > 
> >  > This is also an option (not perfect but you get the gist)
> >  > 
> >  > -----------------------------------------------------------------
> >  > (define-module (syntax define-not-inlinable)
> >  > #:use-module (syntax not-inline)
> >  > #:export (inline define lambda define* lambda* define-values)
> >  > (define inline (lambda (x) x))
> >  > (define-syntax define
> >  > (syntax-rules (inline)
> >  > ((define (f . x) . code)
> >  > (define f (not-inline (lambda x . code)))
> >  > ((define f (inline x))
> >  > (define f x))
> >  > ((define f x)
> >  > (define f (not-inlinable x))))
> >  > ----------------------------------------------------------------------------------
> >  > using this module will make all usual define not inlineable and to 
> >  > enable inlining you would
> >  > explicitly ask for it like
> >  > 
> >  > (define f (inline (lambda (x) (+ x 10))))
> >  > 
> >  > If there is a need for this I can write the modules and expose it on 
> >  > the intertubes.
> >  > 
> >  > WDYT
> >  > 
> >  > /Stefan
> >  > 
> >  > 
> >  > 
> >  >