[00:11] stakkars (~tismer@160.45.44.105) left irc: Read error: 113 (No route to host)
----- silence for 41 minutes ----- [00:52] dialtone (~dialtone@host111-56.pool80117.interbusiness.it) left irc: Read error: 104 (Connection reset by peer)
[00:52] dialtone (~dialtone@host111-56.pool80117.interbusiness.it) joined #pypy.
----- silence for 1 hr and 11 minutes ----- [02:03] __hannes (rgaupyl@dsl-62-220-12-237.berlikomm.net) left irc: "utz utz utz"
----- silence for 2 hr and 33 minutes ----- [04:36] sabren (~irc@c-24-30-92-46.hsd1.ga.comcast.net) joined #pypy.
[04:38] <sabren> do you guys have your own virtual machine?
[04:42] sabren (irc@c-24-30-92-46.hsd1.ga.comcast.net) left #pypy.
----- silence for 4 hr and 29 minutes ----- [09:11] Gromit (~bear@A36c0.a.pppool.de) joined #pypy.
[09:14] ericvrp (~a@ericvrp.demon.nl) joined #pypy.
----- silence for 56 minutes ----- [10:10] ludal (~ludal@logilab.net2.nerim.net) joined #pypy.
----- silence for 22 minutes ----- [10:32] arigo (~arigo@c-3a8b70d5.022-54-67626719.cust.bredbandsbolaget.se) joined #pypy.
----- silence for 46 minutes ----- [11:18] ericvrp (~a@ericvrp.demon.nl) left irc:
----- silence for 41 minutes ----- [11:59] Arafat (~bear@B74f4.b.pppool.de) joined #pypy.
[11:59] Nick change: Arafat -> Gromit_
[11:59] Gromit (~bear@A36c0.a.pppool.de) left irc: Nick collision from services.
[12:00] Nick change: Gromit_ -> Gromit
----- silence for 39 minutes ----- [12:39] cfbolz (~cfbolz@edv01.physi.uni-heidelberg.de) joined #pypy.
[12:39] <cfbolz> hi!
[12:39] <arigo> hi!
----- silence for 19 minutes ----- [12:58] <cfbolz> I'm looking a bit at lltypes
[12:58] <cfbolz> what are the flags of _PtrType?
[12:59] <arigo> they are used to make different kinds of pointers;
[13:00] <arigo> currently the flag 'gc' means that the pointer holds a reference counter (or a GC reference)
[13:00] <cfbolz> ah, I see. It's nothing that would be visible at target code level
[13:00] <cfbolz> ?
[13:01] <arigo> the code generator must put incref/decref if the 'gc' flag is here
[13:01] <arigo> if we had a nice GC, we could ignore pointers that don't have the 'gc' flag when marking objects
[13:01] <cfbolz> ok
[13:01] <arigo> we want to use the flags also for methods:
[13:01] <arigo> the method 'append' of a list, for example,
[13:02] <arigo> will be implemented as a pointer to the list with an extra flag method='append'
[13:02] <arigo> but here, the code generator doesn't have to worry about it
[13:03] <cfbolz> I see
[13:03] <cfbolz> The things I have seem so far should work with genllvm farly easy
[13:06] <arigo> phew :-)
[13:07] <cfbolz> well, LLVM is fairly C-centric
[13:07] Gromit (~bear@B74f4.b.pppool.de) left irc: Read error: 145 (Connection timed out)
[13:07] <cfbolz> That's one of the main complaints of the guys trying to write a Scheme compiler for it
[13:08] <arigo> I see
[13:08] <cfbolz> (though they seem to be working on it)
[13:09] arigo (~arigo@c-3a8b70d5.022-54-67626719.cust.bredbandsbolaget.se) left irc: "rebooting"
[13:18] yuuh (pvcnio@dsl-62-220-12-237.berlikomm.net) joined #pypy.
[13:18] Gromit (~bear@A368e.a.pppool.de) joined #pypy.
[13:28] <cfbolz> bye
[13:29] cfbolz (~cfbolz@edv01.physi.uni-heidelberg.de) left irc: "Leaving"
----- silence for 18 minutes ----- [13:47] -lilo (lilo@levin-pdpc.staff.freenode) to $*- [Global Notice] Hi all. We're experiencing the user summer spammer infestation. If you get klined by mistake, please email staff at freenode dot net. Apologies in advance for any problems, and thank you for using freenode!
----- silence for 18 minutes ----- [14:05] arigo (~arigo@c-3a8b70d5.022-54-67626719.cust.bredbandsbolaget.se) joined #pypy.
----- silence for 20 minutes ----- [14:25] arigo (~arigo@c-3a8b70d5.022-54-67626719.cust.bredbandsbolaget.se) left irc: "[x]chat"
----- silence for 31 minutes ----- [14:56] arre (ac@ratthing-b3fa.strakt.com) joined #pypy.
----- silence for 40 minutes ----- [15:36] pedronis (pedronis@ratthing-b246.strakt.com) joined #pypy.
[15:47] arigo (~arigo@c-3a8b70d5.022-54-67626719.cust.bredbandsbolaget.se) joined #pypy.
[15:59] stakkars (~tismer@rosine168.inf.fu-berlin.de) joined #pypy.
[16:04] Gromit (~bear@A368e.a.pppool.de) left irc: Read error: 131 (Connection reset by peer)
[16:14] yuuh (pvcnio@dsl-62-220-12-237.berlikomm.net) left irc: Read error: 113 (No route to host)
[16:15] yuuh (gagzqsqo@dsl-62-220-12-237.berlikomm.net) joined #pypy.
[16:21] ludal (ludal@logilab.net2.nerim.net) left #pypy.
[16:23] <aleale> hi
[16:24] <arigo> hi
[16:24] <aleale> stakkars: are you working on exceptions ? argument checking fx
[16:30] <aleale> at what time will we meet for the (virtual) mini-sprint ?
----- silence for 19 minutes ----- [16:49] <stakkars> hi
[16:50] <stakkars> aleale: you mean my auto-generated code produces something wrong?
[16:54] <aleale> No - not wrong. It just dont check if the arguments given to the exception is ok. There are tests in test_codeccallbacks.py specifically checking this for UnicodeEncodeError/UnicodeDecodeError/UnicodeTranslateError
[16:54] <aleale> and thus they fail
[16:55] cfbolz (~cfbolz@edv01.physi.uni-heidelberg.de) joined #pypy.
[16:55] <cfbolz> hi
[16:56] <aleale> I have been looking at adding it to your code but felt uneasy, as I didnt know how to generate the files after the changes.
[17:01] <stakkars> well,you can put something into my code and run it to create the file.
[17:02] <stakkars> but you also can change the module directly. But then I would ask you to disable _enum_exceptions
[17:02] <stakkars> and putting a comment that it is out of sync.
[17:03] <stakkars> aleale: the mini-sprint is scheduled for which day, again?
[17:03] <cfbolz> I think the whole next week, including monday
[17:03] <stakkars> ok
[17:06] <aleale> I think the plan is to get the release out by friday
[17:07] <cfbolz> at least that's what the summary of the tb meeting said
[17:07] <aleale> we should get together and discuss what is needed and who will do what
[17:07] <stakkars> yes
[17:08] <stakkars> arigo: pedronis: at the moment we seem to depend on the fact that all SomeXXX are unique instances.
[17:08] <arigo> stakkars: ?
[17:09] <stakkars> we have myriads of Variables, and finally they get a concretetype of SomeXXX assigned.
[17:09] <stakkars> the question is if it is possible to re-use these SomeXXX and create onlyone per argument set.
[17:10] arre (ac@ratthing-b3fa.strakt.com) left irc: Remote closed the connection
[17:10] <stakkars> I'm talking of folding 600000 instances into 26000 anfter my analysis from yesterday.
[17:11] <stakkars> I'm trying to find out where we change them in-place, which might be easy to change,
[17:11] <stakkars> and where we depend on complete uniqueness in the code.
[17:12] <stakkars> The latter seems to happen in annrpython's reverse_binding.
[17:13] <pedronis> I don't think the latter is used at the moment
[17:13] <stakkars> but you see my point? A huge savings
[17:16] <stakkars> and I can do it without changing other code,just by caching arguments and returning pre-built instances.
[17:16] <pedronis> stakkars: btw for the release sprint, we have a tb meeting scheduled for sun 15 at 11am
[17:17] <pedronis> stakkars: code needs to be changed
[17:17] <stakkars> but for that Imust be sure that these objects are never written after instantiation
[17:17] <pedronis> well that's done in a lot of places
[17:17] <stakkars> pedronis: thanks, I forgot (was too deep into optimization)
[17:18] <pedronis> that means we have code that does r = SomXXX() and attach stuff to r
[17:18] <stakkars> (sunday)
[17:18] <pedronis> (sunday, yes)
[17:19] <pedronis> (see the last tb meeting minutes)
[17:19] <stakkars> pedronis: I see. I can change this by putting everything into the constructor I think
[17:20] <pedronis> yes
[17:20] <pedronis> but then you should really a __setattr__ that check
[17:20] <stakkars> just the general question if this is the right thing to do?
[17:20] <pedronis> that we don't violate this
[17:20] <stakkars> yes, sure. I lock the objkects after creation!
[17:20] <pedronis> because it would be hell to track
[17:21] <stakkars> I got quite far by slottifying them, but this was not trivial.
[17:21] <stakkars> And it made comparison much slower, because I had to fake the __dict__
[17:21] <stakkars> all in all, annotation got 6 percent slower, while the savings was about 14 MB.
[17:22] <stakkars> this is not worth it, and I'mnot checking in.
[17:22] <arigo> stakkars: I've also tried a memory-saving approach for SomeObjects, and it wasn't worth it either
[17:22] <arigo> I think we create lots of them but release lots of them too
[17:22] <stakkars> what did you do?
[17:22] <arigo> inherit from 'psyco.compact' :-)
[17:23] <stakkars> this was the other question, whether to really use psyco.compact!
[17:23] <stakkars> I think it works nicely witout the trouble of slots?
[17:23] <stakkars> They do give trouble.
[17:23] <arigo> basically yes
[17:24] <stakkars> arigo: well I counted that we create 600000, but I didn't count when they died. will do that now.
[17:24] <stakkars> but basically, you have one object for every variable. How many do we have?
[17:25] <arigo> stakkars: I think there are less SomeObjects than variables
[17:25] <arigo> because they flow from one variable to the next
[17:25] <arigo> and in this case they're shared
[17:25] <stakkars> oh really?
[17:26] <stakkars> btw.: how much memory does your dusty laptop provide?
[17:26] <arigo> 64MB
[17:27] <stakkars> ahem. Well. That's really a target!
[17:27] <arigo> I never run translate_pypy on my laptop any more :-)
[17:28] <stakkars> I'm working on that. QUite a couple of common attributes can be squeezed away.
[17:28] <stakkars> first let me count the SomeXXX.
----- silence for 18 minutes ----- [17:46] <stakkars> here is the statistics:
[17:46] <stakkars> (Pdb) y.countall
[17:46] <stakkars> 613334
[17:46] <stakkars> (Pdb) y.countcurr
[17:46] <stakkars> 113575
[17:46] <stakkars> (Pdb) y.countmax
[17:46] <stakkars> 113587
[17:46] <stakkars> (Pdb)
[17:47] <stakkars> that is, there are 113500 objects concurrently alive.
[17:47] <stakkars> The number of disjoint instances is 26000 after all.
[17:50] <stakkars> and it makes comparison faster, too (same __dict__)
[17:55] <stakkars> there are 750948 Variable instances. (the counter value -- retrying now with __del__ counting)
[17:57] <stakkars> ick - makes no sense because we keep them all. Probably some are deleted, but this needs the new renaming to find out.
[17:59] yuuh (gagzqsqo@dsl-62-220-12-237.berlikomm.net) left irc: Connection timed out
[18:08] <stakkars> statistics on Variable():
[18:08] <stakkars> (Pdb) y = mo.Variable
[18:08] <stakkars> (Pdb) y.countall
[18:08] <stakkars> 750948
[18:08] <stakkars> (Pdb) y.countcurr
[18:08] <stakkars> 95440
[18:08] <stakkars> (Pdb) y.countmax
[18:08] <stakkars> 100391
[18:09] <stakkars> the number of variables appears to be even smaller that the alive SomeXXX objects.
[18:09] <stakkars> the best savings ever was that I trashed caching of all variables :-) just kept the alive names
[18:10] <cfbolz> see you
[18:11] <stakkars> HURRAY by this simple change we are down to 160 MB after annotation !!!
[18:11] <cfbolz> hey, cool. Then I can even run it again :-)
[18:11] cfbolz (~cfbolz@edv01.physi.uni-heidelberg.de) left irc: "Leaving"
[18:12] <arigo> :-)
[18:12] <arigo> we're trashing so many variables !?
[18:12] <stakkars> some fruits are hanging so low that I should have stumbled over it
[18:13] <stakkars> yes, I guess so. I added a __del__ that count--es, and changed the dict tono longer save cars.
[18:14] <arigo> I think the dict "name-to-Variable" was very useful for debugging the annotator
[18:14] <arigo> it should have been a weakvaluedict, but I was a bit afraid of the overhead when I felt that Variables were mostly never freed anyway
[18:27] <stakkars> doyou want me to make it a weak value dict, or is this phase over?
[18:28] <stakkars> (well it is easy to re-install,anyway)
[18:29] <arigo> yes, we can probably comment it out for now
[18:30] <stakkars> with my new naming, it will anyway be empty
[18:30] <stakkars> all variables get local to the flow object
[18:37] <stakkars> checked in. Now I will get ridof the renamed slot.
[18:48] <arigo> py.py
[18:48] <arigo> >>>> 2+3
[18:48] <arigo> ...
[18:48] <arigo> AttributeError: type object 'Variable' has no attribute 'instances'
[18:48] <stakkars> yuck!
[18:49] <stakkars> I'll quickly undo and then fix :-/
[18:49] <arigo> its in geninterplevel.py:1091
[18:49] <arigo> copied from genc.py:174
[18:50] <stakkars> gulp! I never should check with without test_all
[18:50] <stakkars> did you drop it, too?
[18:51] <arigo> I wasn't 100% sure: I should just drop these lines?
[18:51] <stakkars> yes
[18:51] <arigo> ok
[18:51] <stakkars> did it in geninterp
[18:51] <arigo> then drop the one in genc too, and check them both.
[18:51] <stakkars> but please do. I have a different problem now that I try to save the renamed slot
[18:52] <arigo> ah, ok, I'll do it.
[18:52] <stakkars> by making it a computed attribute which uses a dict, I now keep all the variables which were saved before :-(
[18:53] <stakkars> is a weakvalue dict expensive?
[18:53] <arigo> don't know exactly
[18:54] <stakkars> ok I'll dosometiming. If the percentage of slowness isn't below the percentage of win., I'll drop it
[18:55] <stakkars> *ick* this makes *no* sense
[18:56] <stakkars> if I use a weak value dict for saving one slot, I pay for it by using the weakref slot :-))
[18:57] <arigo> :-)
[19:01] <stakkars> ok, fornow it becomes the value in instancenames{}
[19:04] <pedronis> stakkars: why is __init__ itself using rename
[19:04] <pedronis> there is some deep reason I'm missing?
[19:05] <stakkars> not my code
[19:05] <pedronis> .rename seems not that used in the all codebase
[19:06] <stakkars> no, it is done once to set the realname, and that's it. But it appears as a really useless attribute.
[19:06] <stakkars> will give it a rewrite, later
[19:06] <stakkars> just moving slow steps
[19:07] <arigo> pedronis: rename is used in the flow graph, at one point
[19:07] <pedronis> I saw that
[19:07] <pedronis> I'm just wondering whether the complicated logic around it is needed
[19:07] <stakkars> hey, I'm donw to 157 MB just by that :_)
[19:08] <stakkars> it was hacked in right before the Lithunia sprint I think. SOmething to keep the names.
[19:08] <stakkars> sp the slot must have been at a malloc boundary.
[19:10] <stakkars> arigo: instead of dropping, we should use a reset() class method and now clear the instancenames dict. I'll do that.
[19:12] <pedronis> what was instancenames used for?
[19:12] <stakkars> it is the replacement for instances
[19:13] <stakkars> we should now clear that. Just ignore.
[19:15] <pedronis> stakkars: is the .name of a variable used apart for displaying?
[19:16] <stakkars> I don't think so. Actually, a variable could be nameless.
[19:17] <stakkars> but we need it as a representative, in a way, if we want to make the SOmeXXX things unique.
[19:17] <stakkars> Thinking the other way round, we could drop Variable and maybe turn it into SomeXXX ???
[19:18] <pedronis> no, I'm thinking simpler thoughts
[19:18] <pedronis> you are using a dict instead of renamed?
[19:19] <stakkars> I'm using a dict instancenames, keyed by the name,and the value is for the moment the renamed flag.
[19:19] <pedronis> because .name could be a property
[19:19] <stakkars> I think this will all vanish when I have the names all local.
[19:19] <pedronis> and we store a number (base case) or a string internally (renamed case)
[19:20] <stakkars> aah, and we save the whole dict!
[19:20] <pedronis> and we attach the v in front in the renamed case in the property
[19:20] <stakkars> (k)
[19:20] <stakkars> (doing it)
[19:20] <pedronis> sorry, in the non-renamed case
[19:21] <stakkars> so I put a _name attribute which is either a number or a name
[19:21] <stakkars> ok?
[19:22] <pedronis> yes
[19:22] <pedronis> and you have name and maybe renamed (if it used outside of the class) property
[19:23] <stakkars> ok
[19:23] <stakkars> undoing the resetall()
[19:25] <stakkars> renamed not used outside.
[19:29] <pedronis> I see, it is just isinstance(self._name, str)
[19:29] <stakkars> no it is type(self._name) is not int
[19:30] <arigo> pedronis: I tried to see how to to write a source-code-building helper
[19:30] <arigo> pypy/tool/test/test_template.py
[19:30] <stakkars> pedronis: sorry you were right. the Variable stuff is used to get a string,yes.
[19:31] <pedronis> yes: you need a name property thar does 'v%d' for the number case
[19:31] <stakkars> have it. need also the renamed property to make it easy.
[19:37] <arigo> just a note about 'renamed':
[19:38] <arigo> its purpose was so that a Variable gets the name of the first local variable that is found to hold it
[19:38] <arigo> if the Variable is copied into another variable later (mind the upper-casing :-) then it doesn't get renamed again
[19:38] <stakkars> (I know)
[19:39] <pedronis> (knows too)
[19:39] <arigo> fine :-)
[19:41] yuuh (uwymlyf@i3ED6B2BA.versanet.de) joined #pypy.
[19:42] <pedronis> arigo: the templating makes sense
[19:43] <arigo> at least it hides the details of capturing miniglobals by hand
[19:43] <pedronis> yes, but the yield line of code make somewhat sense too
[19:45] <arigo> in some cases yes, but not always
[19:46] <arigo> e.g. I don't know if it makes sense for descroperation.py:608
[19:48] <pedronis> I see, that code is doing a bit too much in the template btw
[19:49] <arigo> right :-)
[19:49] <arigo> but maybe we can have compile_template() accept just a string as input, so that we can use it generally instead of the various compile2 NiceCompile etc.
[19:50] <pedronis> yes, uniformity would be nice
[19:53] <stakkars> if it is as nice as NiceCompile, I'm with it.
[19:54] <arigo> well everyone's come with his own nice compile() replacement :-)
[19:54] <arigo> I'll look at NiceCompile in detail and see what nice things it does
[19:55] <stakkars> provides exact line numbers and template args
[19:55] <stakkars> given that the template can be found in the source file.
[19:58] <arigo> hum. of course py.code.Source().compile() does different things
[19:58] <arigo> it is able to satisfy inspect.getsource() on a compiled code even if it doesn't come verbatim from a .py file
[19:59] <arigo> which is better for sources that are built line-by-line
[19:59] <arigo> but worse for sources like the ones in lib/_classobj.py :-)
[20:02] <stakkars> yes, I tried to avoid storing source text if possible. Both makes sense, depending on the situation.
[20:03] Action: pedronis leaving the office
[20:03] pedronis (pedronis@ratthing-b246.strakt.com) left irc: "Chatzilla 0.9.67 [Firefox 1.0.2/20050325]"
----- silence for 28 minutes ----- [20:31] yuuh (uwymlyf@i3ED6B2BA.versanet.de) left irc: "utz utz utz"
[20:42] pedronis (~Samuele_P@c-3a8b70d5.022-54-67626719.cust.bredbandsbolaget.se) joined #pypy.
----- silence for 18 minutes ----- [21:00] <stakkars> after this change, we are down tophantastic 109 MB
----- silence for 38 minutes ----- [21:38] <arigo> excellent :-)
[21:38] <arigo> another 50% reduction and I can run it on my machine :-))
[21:38] <stakkars> that was my plan :-)
[21:39] <stakkars> currently I'm reducing links.
[21:39] <stakkars> last_exception,last_exc_value and exitcase become properties.
[21:39] <stakkars> there is only one _combi slot, which points into a dict of triples.
[21:39] <stakkars> there are justa few possible combinations :-)
----- silence for 18 minutes ----- [21:57] <stakkars> OUPPS that was bad. it grew.
[21:57] <stakkars> arigo: do the last_excXXX have to be disjoint variables?
[21:58] <arigo> they have to name the corresponding variable in the link.args
[21:58] <arigo> i.e. they are supposed to be the same Variable as one (or possibly more) of the link.args
[21:58] <stakkars> costs about 6 MB
[21:59] <stakkars> so it is just to denote which are meant as such?
[21:59] <arigo> yes
[21:59] <stakkars> gack!
[22:00] <arigo> it's a kind of implicit operation that returns the captured exception's type or value, and which has to know into which (new) Variable the result goes
[22:00] <stakkars> computing these would probably break their purpose. ?
[22:00] <arigo> they can't really be computed from anything else.
[22:01] <stakkars> yes,I understand. The question is if they can be turned into indices and then be computed attributes.
[22:01] <arigo> don't know
[22:01] <arigo> the link.args can have been modified in various ways by transformations, so maybe it doesn't contain the last_exc_value Variable any longer, or several times, in any order etc.
[22:02] <arigo> are you already turing the link.args into indices?
[22:03] <stakkars> notyes. I thought (hoped) that the exc things were all the same and folded the attributes.
[22:03] <stakkars> But that was bad.
[22:03] <stakkars> Actually I don't want tochange anything of the interface.
[22:03] <stakkars> What I want to do is some on-demand unpacking to have things like now, and use some
[22:04] <stakkars> tricks to get rid of the unpacked version behind the scenes.
[22:04] <stakkars> I'm especially keen on getting the operations foldeddown.
[22:04] <arigo> I understand that
[22:05] <stakkars> but I'm not yet sure on what level to do this at all. Maybe the flow graph itself is the right interface.
[22:05] <arigo> lots of place use blocks without knowing in which graph they belong.
[22:05] <stakkars> touching any property unpacks it and puts it into a list of things to be packed at some time.
[22:05] <arigo> like making Block.operations an attribute computed from a very dense string?
[22:05] <stakkars> so maybe theblocks are the right place, and I intercept operation access.
[22:06] <stakkars> I thought of a string as well (finally this could be a pickle),
[22:06] <stakkars> but the effect is the same as if I use tuples of operations which are tuples themselves,
[22:06] <stakkars> and keep them all in a refcounted cache dict.
[22:07] <stakkars> the thing is to remove the noise, that is:
[22:07] <stakkars> remove direct references to variables and constants,
[22:07] <stakkars> but use a block-relative index into a vars list
[22:07] <stakkars> remove absolute operand offset, use distances instead.
[22:08] <stakkars> that folds us down to a few thousand casesofblock bodies, I guess.
[22:08] <arigo> I guess so
[22:09] <stakkars> (hee hee, interstingly, these operations can be directly mapped into precompiledassemblersnippets,alloffsets are there :-) )
[22:09] <arigo> there is the RPython typer in the middle :-)
[22:09] <arigo> which modifies the operations in the block
[22:09] <arigo> but using a simple interface again,
[22:09] <stakkars> sure. But he doesn't do anything different.
[22:09] <arigo> like building a list of SpaceOperations and at the end doing "block.operation = newlist"
[22:10] <arigo> but yes, indeed, these low-level blocks could match directly to assembler snippets :-)
[22:10] <stakkars> :-)
[22:11] <stakkars> would you use some magic like I explained, or simplyexplcit pack/unpack operations which must be used?
[22:12] <arigo> magic is nice if it catches misuses
[22:12] <stakkars> you understand, I want tomake the system very muchsmaller, but not noticely slower.
[22:12] <arigo> block.operations returning a (mutable) list is a problem.
[22:12] <stakkars> So I actually think keeping a MRU structure of the last 1000 blocks alive would keep us running.
[22:13] <arigo> maybe explicitely packing/unpacking is saner.
[22:13] <stakkars> it is not alone about the modifications,
[22:13] <stakkars> it is also how to keepthe flowing process effective.
[22:13] <arigo> yes, right
[22:14] <stakkars> so I would not dropexpanded blocks which are in heavy use.
[22:14] <arigo> but I don't see right now a sane approach
[22:15] <arigo> the annotator doesn't modify the list of operations,
[22:15] <arigo> but you don't know that implicitely
[22:15] <arigo> so the magic may have to check all the time if the list was modified or not
[22:16] <stakkars> I could a) use a list subclass and b) check for block.operations direct assignments.
[22:16] <stakkars> the other,probably very clean way could be:
[22:17] <stakkars> an explicit block.attach(), finally a block.detach()
[22:17] <stakkars> or just a detach, if block access automatically unpacks on demand.
[22:17] <stakkars> The detach would just say "I don't need you any longer", and the block wouldgo into
[22:18] <stakkars> my MRU list and wait for being used, again, or collected by the MRU overflow handler.
[22:18] <arigo> looks good
[22:18] <arigo> even if someone forgets to call detach(), no deep hell ensures
[22:19] <stakkars> yes, exactly. The undetached blocks are moved into a special list, waiting for detaching.
[22:19] <stakkars> So I can check this.
[22:20] <arigo> even, you probably only need a list of detached block, and not one of undetached block.
[22:21] <stakkars> to find out that people forgot detaching?
[22:21] <arigo> ok ok :-)
[22:21] <stakkars> I think this will be cool.
[22:21] <stakkars> ok,but on the last_exception, there is nothing I can do now I guess?
[22:22] <arigo> not obviously
[22:22] <stakkars> ahhh I can!
[22:23] <stakkars> have two Link classes, one with two more slots!
[22:23] <stakkars> while the other computes the stuff toNone
[22:23] <stakkars> and the other inherits and adds two slots.
[22:24] <stakkars> then I just have to make sure that I pull the right class out of the pocket when thie attribs are changed.
[22:24] <arigo> :-)
[22:24] <arigo> you can't change the __class__ like that, though
[22:25] <arigo> :-(
[22:25] <stakkars> no I have to replace the link by a new instance when this is changed.
[22:26] <arigo> it looks rather too much effort for too little results
[22:26] <stakkars> yes, probably.
[22:26] <arigo> e.g. you could save more, I guess, by making Link a subclass of list (!)
[22:26] <arigo> (not sure it's a good idea but...)
[22:27] <stakkars> oops? Why that?
[22:27] <stakkars> I could of course, and even remove all unwanted operations, but I don't see the advantage?
[22:28] <stakkars> I fear this is more expensive through the double indirection/allocation
[22:28] <arigo> to remove the .args stored attribute
[22:28] <arigo> replace the Link by its own list of args
[22:28] <stakkars> ahh, ahh, ahh!
[22:29] <stakkars> and stick the special cases at the front of the list
[22:29] <arigo> or in slots
[22:30] <arigo> ...btw 109MB is already *fantastic* :-)
[22:30] <stakkars> slots are ok. The case that we have no exception, is it more frequent?
[22:30] <arigo> don't know for sure
[22:31] <stakkars> then I could stick one flag slot that tells that the first two list elts are last_exc...
[22:31] Action: arigo harasses stakkars with other issues like pickling the graphs or writing the rpython list implementations
[22:32] <stakkars> yeah,yeah, all these thoughts came *while* I was working on pickling
[22:32] <arigo> :-)
[22:32] <stakkars> ok, I'll drop the links for now.
[22:33] <stakkars> And the problem might completely vanish if I do the packing of the whole graph,
[22:33] <stakkars> then the links go away into tiny tuples.
[22:34] <stakkars> all referencing variables in the local variable tables of the blocks, and indexing blocks in the global block table of the graph.
[22:34] <stakkars> that's btw the thing I want to pickle. Well I shut up :-)
[22:35] <stakkars> about list implementation:
[22:35] <stakkars> last time, you mentioned you were stuck with some problem, there.
[22:36] <stakkars> Did this lead to the low-levelish thing and the say "get rid of ctyper", and is the theory there so I can implement?
----- silence for 31 minutes ----- [23:07] <arigo> yes
[23:07] <arigo> I was thinking about pypy/rpython/rlist.py
[23:07] <arigo> see also the documentation I checked in one hour ago
[23:07] <stakkars> will go for it
[23:09] <arigo> I should add a few docstring-like examples...
----- silence for 19 minutes ----- [23:28] senra (~rodrigo@200165251048.user.veloxzone.com.br) joined #pypy.
----- silence for 17 minutes ----- [23:45] <arigo> good night
[23:45] arigo (~arigo@c-3a8b70d5.022-54-67626719.cust.bredbandsbolaget.se) left irc: "[x]chat"
[23:45] senra (~rodrigo@200165251048.user.veloxzone.com.br) left irc: "Leaving"
[23:54] <stakkars> good night
[00:00] --- Sat May 14 2005