libera/#clasp - IRC Chatlog
Search
13:27:51
drmeister
So the options are make entry-points into function objects or pre-allocate closures?
13:28:21
drmeister
At this point the EntryPoint_O hierarchy is starting to look like function objects
14:24:03
drmeister
1. We need to talk about pauses. https://usercontent.irccloud-cdn.com/file/4HciTBRK/image.png
14:25:10
drmeister
The cclasp compiler didn't like the (member :local :special :symbol-macro :constant) type
14:30:16
Bike
wait, it's wrong anyway, that's now how you specify a type in a defstruct. did i write that?
15:09:03
Bike
so now i'll implement the argument parsing instructions in the vm, and then i'll be able to use the vm on actual compield lisp code
16:39:30
karlosz
speaking of which i guess if we're going to make fasls with thisthing we'll have to think about load-time-value and literals
16:39:54
karlosz
but that's complicated so for now i propose we stick with it as an interpreter drop in in which case we don't need to care
18:46:15
drmeister
::notify karlosz Bike and I were discussing offline the idea of making EntryPoint_O objects funcallable vs load-time allocation of closures.
18:48:21
drmeister
A problem with funcallable EntryPoint_O objects is that every call site needs to be aware that EntryPoint_O objects are funcallable and there needs to be a test to decide if the call will be through a Function_O object or through an EntryPoint_O object. It's not an insurmountable problem. We can discuss it when we are all online.
18:49:27
drmeister
A call through a Function_O object reads the atomic Function_O slot for an EntryPoint_O object and then indexes into the EntryPoint_O object based on the number of arguments and calls that address.
18:52:43
drmeister
The code to decide if it's a Function_O call or an EntryPoint_O call (we could rename these to closure call and function call respectively) needs to be installed at every call site.
20:20:59
drmeister
Bike: How are you working with the cvm compiler and clasp? Do you clone the cvm compiler separately and run it in slime using clasp?
20:38:54
drmeister
Or you mean the values are in the multiple-values array and you want to return them? Where is the zeroth value and the number of values?
20:39:22
Bike
Yeah that one. I could do it myself, I'm just wondering if there's something already written
20:40:24
drmeister
I think it's this: https://github.com/clasp-developers/clasp/blob/vm/include/clasp/gctools/multiple_value_pointers.h#L49
20:42:03
drmeister
If you have the zeroth (first?) multiple value and the number of values you can use T_mv<T> constructor
20:42:11
drmeister
https://github.com/clasp-developers/clasp/blob/vm/include/clasp/gctools/multiple_value_pointers.h#L40
20:49:49
Colleen
karlosz: drmeister said 2 hours, 3 minutes ago: Bike and I were discussing offline the idea of making EntryPoint_O objects funcallable vs load-time allocation of closures.
20:50:58
karlosz
drmeister: the trick sbcl does to avoid the type dispatch is that the EntryPoint_O object would have a self pointer at the same slot offset that the Function_O object uses. then you have the same code path
20:52:39
karlosz
there should be a way to just pretend the EntryPoint_O object is really just a Function_O object
20:56:30
drmeister
https://github.com/clasp-developers/clasp/blob/vm/include/clasp/core/functor.h#L126
21:05:32
drmeister
If EntryPointBase_O inherits from Function_O then that will just work unless we hand coded it somewhere.
21:07:34
karlosz
so EntryPointBase_O will inherit from Function_O, but then Function_O has an EntryPointBase_O as its template
21:10:09
drmeister
It could be one of those times where we've finally made all the right choices in the implementation of the runtime that we are one tiny step away from what sbcl has been doing for a decade.
21:10:17
karlosz
maybe you can have Function_O (which just has the env slot) and EntryPointBase_O both inherit from a common Funcallable_O object which just has the entry point slot
21:12:50
karlosz
so Funcallable_O: EntryPoint_O *template -------- Function_O inherits Funcallable_O: T_O* env ------ EntryPointBase_O inherits Funcallable_O: int LocalsFrameSIze, ....
21:14:29
Bike
because it's not a T_mv, and I can't have bytecode_call return T_mv::createFromValues()
21:15:12
drmeister
Bike: gctools::return_type is a simple struct with a trivial destructor that is bit-wise equivalent with T_mv.
21:16:30
drmeister
There's a deep reason for it - but I can't quite remember what it was. T_mv has a non-trivial destructor and that's why I had to create return_type.