freenode/#clasp - IRC Chatlog
Search
17:41:51
karlosz
so i was thinking about how to get rid of the continuation variable in unwind and i think this approach might be cleaner than what we have right now: 1. Define a new class LEXICAL which lexical-variable and catch both subclass. LEXICALs are things that can go into environments. Instead of closing over the continuation variable, we just close over the catch instruction directly instead.
17:42:09
karlosz
This has a few benefits: No strange non lisp object rtype needed for the continuation object
17:42:28
karlosz
No need to maintain the readvar stuff in unwind - it already has a slot for its catch
17:42:34
Bike
the rtype is just a reflection of what's actually happening on the lower level. it's not a tagged pointer
17:43:13
karlosz
Since the contvar is already mutable, we can simply identify it with the catch instruction anyway
18:59:01
karlosz
it would be good to figure out why cst->ast is just such a slow phase of compilation especially when bir and and eclector now hardly make a dent
18:59:37
karlosz
we have a pretty broad sjlj optimization so hopefully we run into unwind less on stupid stuff like lexical non local exits
19:05:20
drmeister
I just tried to build BIR and it dropped into the repl right after loading inline.lisp
19:06:54
Bike
the change to improve the backtraces has a change in cleavir too, so you have to get that
21:21:10
drmeister
With the sea-of-nodes (SON) compiler about half the time was spent in llvm and the other half in cleavir
21:22:14
drmeister
In llvm much of that time was spent in instruction combining. I talked with Ian Rogers (a programmer at Google) and he thought that was strange. He sees lots of time spent in register selection.
21:25:42
karlosz
drmeister: bir is definitely faster than hir, compile time wise. most of the time is now spent in cst->ast especially since eclector no longer spends so much time doing terminate-token
21:32:59
Bike
the initial bir seems to involve writing variables to themselves... not sure what's going on there
21:43:56
Bike
i put in something so that different datums with the same names should have different names in the disassembly
22:11:44
Bike
well, local call says "for" this function, not "of" this function, maybe it's calls in the body?
22:35:43
Bike
here's an example: say an enclose instruction is deleted as unreachable. it looks like the remove-use method will try to remove the enclose from the local-calls
22:37:19
Bike
would it make sense to just maintain the USES set and compute the local-calls and encloses set from it, or would that be inefficient?
22:39:59
Bike
oh, hey, there's something in find-module-local-calls saying the refresh-iblocks call can be deleted once tagbody ast-to-bir is fixed
22:40:39
karlosz
Bike: also since code is not an input of enclose, i don't think the situation you described with remove-use can happen
22:42:01
karlosz
it would be good to figure out how to make the inputs/additional slots situation clearer or more uniform
22:42:44
Bike
readvar and writevar originally didn't have the variable as an input or output and it was a little uglier that way in my opinion
22:43:12
Bike
the downside is that now you don't know if an input is linear or not immediately, but i think that's alrigth
22:44:00
karlosz
i guess right now we're just simplifying bir now that it seems to more or less work
22:44:26
Bike
i'm also writing documentation again, in the hope that i won't have to rewrite it much when we change stuff in a week
22:54:39
karlosz
The symbol DISASSEMBLE-INSTRUCTION is bound to an ordinary function and is not a valid name for a generic function
23:26:09
karlosz
okay, so optimizations in BIR we have over HIR: sjlj for local functions, local calls, zero heap allocation closures
23:29:40
karlosz
bir will have much better type inference, contification is straight forward to implement in bir
23:40:46
Bike
like if you only care about terminators, like in reduce-typeqs, mapping over the rest is dumb
23:42:03
karlosz
i ran into a nasty bug when i was doing local call stuff because i forgot map-instructions looks recursively for enclose
23:42:39
karlosz
eclector is still unwinding but thats because the bir one isn't using the no-signals branch i think
23:43:49
karlosz
verifier takes about the same amount of time as the rest of the bir passes combined
23:45:52
karlosz
Cannot add the method #<STANDARD-METHOD UNNAMED (CLIM-INTERNALS::|(presentation-type COMMON-LISP::NULL)| T T CLIM:TEXTUAL-VIEW)> to the generic function #<PRESENTATION-GENERIC-FUNCTION CLIM-INTERNALS::%ACCEPT> because their lambda lists (TYPE-KEY TYPE STREAM VIEW &KEY) and (TYPE-KEY TYPE STREAM VIEW &KEY DEFAULT DEFAULT-TYPE &ALLOW-OTHER-KEYS) are not congruent.
23:48:01
Bike
https://github.com/clasp-developers/clasp/commit/8a33acbb09357531ff645576d883542e7870d47f
23:51:16
karlosz
Bike: what ended up happening to the type inference stuff? did the transforms pan out?
23:52:48
Bike
i think the approach i want to take is having the transform work by just returning an ir function, which is then inlined
23:53:02
Bike
so all the actual rewriting code is just part of inlining and the transform doesn't have to deal with it
23:54:41
Bike
i mean, what i'm thinking is that the transform mechanism, which looks at types and stuff, doesn't really care how the transform is implemented
23:54:59
Bike
the transform could do that kind of macroexpansion approach, or it could use a static function (like it would for the simple CAR rewrite), or whatever
23:58:30
Bike
https://gist.github.com/Bike/678179dd7eadb55ff50114e85360ec35 as you can see it's very basic
0:01:07
Bike
i put the derived types in a hash table mostly because i didn't want to go through the process of adding a slot to data
0:03:48
Bike
it'll work with variables, but it's only the "local" propagation, it doesn't know about typew or control flow generally
0:05:13
karlosz
when (- (+ (the small-fixnum x) (the small-fixnum y)) 2) derives the output type of + to be fixnum, we can just worklist the rest so it keeps firing for -
0:07:04
Bike
i know you've been thinking of things in terms of known calls, but i think if possible i'd like to attach that derivation information to function types and propagate like anything else
0:07:20
karlosz
well, if you had a slot on the linear-datum directly, you can just use the same "rewriting" mechanism
0:07:24
Bike
would be cool if we could determine (funcall (if ... #'+ #'-) fixnum fixnum) an integer, that kind of thing
0:09:02
Bike
i mean i was imagining that the function type would have the whole type deriver function shebang attached
0:16:50
karlosz
if we can get the set of primops in HIR to get compiled in bir but without the inlining and delete machinery id say thats a win
0:22:31
Bike
with the local call changes it might just be printing the external entry point, or something
0:23:05
Bike
https://github.com/clasp-developers/clasp/blob/master/src/lisp/kernel/cmp/disassemble.lsp#L34-L43
0:44:08
Bike
the local call stuff might really require some rethinking there, though, since there are multiple llvm functions to disassemble
1:00:29
karlosz
im thinking of how to do contification more elegantly with hir because we have a built in way to merge with phis
1:01:01
karlosz
so seeing if theres a good abstraction to be made out of making blocks with phis and dealing with that kind of thing
1:02:31
Bike
llvm has the concept of a module, but by the time you're looking at a function object it's gone
1:04:05
Bike
i mean, it's a compiler thing. it's gone for the same reason the bir module is gone. you just have the binary left
1:04:36
Bike
obviously the function has a pointer to the start of the code, but that's about it. i don't remember how we even find the end
1:15:11
karlosz
yeah im disappointed that our runtime function objects don't have more stuff attached to them
1:16:39
karlosz
and the code component object is like the runtime representation of a module and has the metadata for that group of compiled together functions/entry points
1:17:09
karlosz
and plus the GC needs to know about it so the thing can get collected when its no longer referenced