speedup of modifying return values

speedup of modifying return values

[Stefan Israelsson Tampe]

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

Hi all, I'm trying to make a python clone in guile. Currently the code is
slow and one of  the reasons is the following,

in my pythoon

return 1,2

returns a (values 1 2) in order to get python and scheme to interoperate.
but for python if you use

x = 1,2

then x is the tupple '(1 2) and in guile it is 1. So therefore we wrap the
result for

x=f(10)

as
(set! x (call-with-values (lambda () (f x)) (case-lambda ((x) x) (x x))))

This can be compiled to efficient bytecode but is not done so in guile. In
stead a closure is created at each assignment site and creating ineficient
code.

Any ideas how to improve this (I don't want "return a,b" to mean (list a b)
which is a quick solution
if we want to just stay in python and not interoperate with scheme at all
on this level.

Regards
Stefan

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

Re: speedup of modifying return values

[Taylan Kammer]

Stefan Israelsson Tampe <stefan.itampe@gmail.com> writes:

> Hi all, I'm trying to make a python clone in guile. Currently the code is slow and one of  the reasons is the following,
>
> in my pythoon
>
> return 1,2
>
> returns a (values 1 2) in order to get python and scheme to interoperate. but for python if you use
>
> x = 1,2
>
> then x is the tupple '(1 2) and in guile it is 1. So therefore we wrap the result for
>
> x=f(10)
>
> as
> (set! x (call-with-values (lambda () (f x)) (case-lambda ((x) x) (x x))))
>
> This can be compiled to efficient bytecode but is not done so in guile. In stead a closure is created at each assignment site and creating ineficient code.
>
> Any ideas how to improve this (I don't want "return a,b" to mean (list a b) which is a quick solution
> if we want to just stay in python and not interoperate with scheme at all on this level.

Sounds like a fun project. :-)

Idea:

Make Python tuples a new data type, instead of multi-values.

The fact that they can be stored in a single storage location in Python
means that they are actually a data type, only special-handled for
automatic destructuring in some places...

Therefore, I would represent them as a record type under the hood.
Maybe one with a single field that contains a list or a vector.

I would then compile Python syntax that destructures tuples into
corresponding Guile code that destructures them also.

> Regards
> Stefan

Happy hacking,
Taylan

Re: speedup of modifying return values

[Hans Åberg]

> On 29 Aug 2018, at 20:46, Taylan Kammer <taylanbayirli@gmail.com> wrote:
> 
> Stefan Israelsson Tampe <stefan.itampe@gmail.com> writes:
> 
>> Hi all, I'm trying to make a python clone in guile. Currently the code is slow and one of  the reasons is the following,
>> 
>> in my pythoon
>> 
>> return 1,2
>> 
>> returns a (values 1 2) in order to get python and scheme to interoperate. but for python if you use
>> 
>> x = 1,2
>> 
>> then x is the tupple '(1 2) and in guile it is 1. So therefore we wrap the result for
>> 
>> x=f(10)
>> 
>> as
>> (set! x (call-with-values (lambda () (f x)) (case-lambda ((x) x) (x x))))
>> 
>> This can be compiled to efficient bytecode but is not done so in guile. In stead a closure is created at each assignment site and creating ineficient code.
>> 
>> Any ideas how to improve this (I don't want "return a,b" to mean (list a b) which is a quick solution
>> if we want to just stay in python and not interoperate with scheme at all on this level.
> 
> Sounds like a fun project. :-)
> 
> Idea:
> 
> Make Python tuples a new data type, instead of multi-values.
> 
> The fact that they can be stored in a single storage location in Python
> means that they are actually a data type, only special-handled for
> automatic destructuring in some places...

Indeed, the problem is that in Scheme, (list f x₀ …), using normal infix tuple notation, creates the deferred function object f(x₀, …), and I found it hard to write a normal function call language on top of that.

Re: speedup of modifying return values

[Matt Wette]

On 08/29/2018 03:58 AM, Stefan Israelsson Tampe wrote:
> Hi all, I'm trying to make a python clone in guile. Currently the code 
> is slow and one of  the reasons is the following,
>
> in my pythoon
>
> return 1,2
>
> returns a (values 1 2) in order to get python and scheme to 
> interoperate. but for python if you use
>
> x = 1,2
>
> then x is the tupple '(1 2) and in guile it is 1. So therefore we wrap 
> the result for
>
> x=f(10)
>
> as
> (set! x (call-with-values (lambda () (f x)) (case-lambda ((x) x) (x x))))
>
> This can be compiled to efficient bytecode but is not done so in 
> guile. In stead a closure is created at each assignment site and 
> creating ineficient code.
>
> Any ideas how to improve this (I don't want "return a,b" to mean (list 
> a b) which is a quick solution
> if we want to just stay in python and not interoperate with scheme at 
> all on this level.
>
> Regards
> Stefan

So I'm working on extension languages in Guile.  I assume you are always returning tree-il
values from Python functions.  (Unless from functions returning tuples, but how do you
guarantee that?)  You could add a property to your functions and then compile to CPS and
do the optimization yourself.  Then convert to bytecode.  But that seems tough.

I assume the use case is being able to call Python code from Guile, so one would always call
from Scheme using call-with-values?

I am using call-with-values in nx-matlab when the function is declared with multiple values.

Also, I wonder if we should be "marking" functions with a property to indicate what the
source language is.  The property could be 'language.  (If no language assume 'scheme.)


Matt