#pypy IRC log for Saturday, 2005-11-05

cfbolz (n=cfbolz@p54AB8AF2.dip0.t-ipconnect.de) left irc: "Leaving"00:20
pedronis (n=Samuele_@c-3c8b70d5.022-54-67626719.cust.bredbandsbolaget.se) left irc: "Chatzilla 0.9.68a [Firefox 1.0.4/20050511]"00:22
rhymes (n=rhymes@host126-5.pool80183.interbusiness.it) left irc: "supercalifragiliblahblah"01:26
paniq_ (n=paniq@port-212-202-49-191.dynamic.qsc.de) joined #pypy.01:44
Rhamphoryncus (n=rhamph@unaffiliated/rhamphoryncus) joined #pypy.03:11
ita (n=ita@kde/developer/tnagy) joined #pypy.03:19
itacompiling 0.8 atm here03:19
itait is huge03:30
itaIn file included from testing_1.c:1:03:53
itacommon_header.h:4:19: error: gc/gc.h:03:53
itano such file or directory mmm03:54
ita (n=ita@kde/developer/tnagy) left irc: "Konversation terminated!"04:01
_hannes (n=yuuhu@i577B40E0.versanet.de) left irc: Read error: 104 (Connection reset by peer)05:16
stakkars (n=tismer@adsl-71-133-157-81.dsl.irvnca.pacbell.net) joined #pypy.07:21
xyz359 (n=xyz359@pool-68-238-174-197.tampfl.fios.verizon.net) left irc: ";)"07:31
idnar (i=mithrand@unaffiliated/idnar) left irc: Nick collision from services.07:45
idnar_ (i=mithrand@unaffiliated/idnar) joined #pypy.07:45
guido_wesdorp (n=johnnyde@a80-127-80-154.adsl.xs4all.nl) joined #pypy.07:53
guido_w (n=johnnyde@a80-127-80-154.adsl.xs4all.nl) left irc: Read error: 110 (Connection timed out)08:10
arigo (n=arigo@c-3c8b70d5.022-54-67626719.cust.bredbandsbolaget.se) joined #pypy.10:13
rhymes (n=rhymes@host126-5.pool80183.interbusiness.it) joined #pypy.10:42
cfbolz (n=cfbolz@p54AB9DD2.dip0.t-ipconnect.de) joined #pypy.11:29
jacob22|hometic: ANTLR may be what you want.13:11
ticjacob22|home, thanks! I'll look it up13:29
xorAxAxdoes anyone know if cpython mmaps pycs?13:30
xorAxAxjava does, and so should python :)13:30
cfbolzI am pretty sure that it doesn't13:30
xorAxAxthe core team says that you should go multiprocess if the GIL is your bottleneck. and they havent even implemented this ...13:31
RhamphoryncusxorAxAx: why would it?  To avoid copying them?13:31
xorAxAxRhamphoryncus: in order to optimise mem usage for multiple py processes13:32
Rhamphoryncusahhh good point13:32
xorAxAxfor a big thing, this should decrease the mem usage significantly13:32
cfbolzbig thing meaning thousands of processes?13:33
xorAxAxno, meaning a few processes but a big source tree13:33
Rhamphoryncusit would help slightly even for single processes.  Effectively a smaller memory footprint since it would use only the kernel's cache of the file, and not a copy on the heap13:34
xorAxAxyeah, which has better paging behaviour13:35
cfbolzfeel free to submit a patch, I would say :-)13:36
xorAxAxi just realise that you would need to write c13:36
xorAxAxbecause you need a lazy read13:36
cfbolzoh yes13:36
Rhamphoryncuswhy does that need C?13:36
xorAxAxbecause the inner interpreter would need to read code chunks from a file instead of jumping in heap13:38
xorAxAxbut considering that - it would not help because those marshal blobs are deallocated after loading i guess13:38
xorAxAxso this idea is completly useless13:38
xorAxAxthe func objects are stored anyway on the heap, regardlessy where they were read from13:39
RhamphoryncusI don't know how much of it is stored as a string anyway13:40
cfbolzarigo: what are the two objectspaces supposed to do?13:52
arigocfbolz: force the 'space' to be kept around everywhere, to measure the performance impact13:57
cfbolzyes sure13:58
arigonothing more :-)13:58
cfbolzbut they don't actually provide any difference13:58
alextp (n=top@201008227201.user.veloxzone.com.br) joined #pypy.14:00
arigoit doesn't compile because of a limitation of specialization, which is mostly not working with methods14:01
arigospace.wrap -> crash14:01
cfbolzyes, I read the checkin message. is it hard/worth fixing it?14:02
arigoworth fixing it, yes14:02
arigohard, yes too14:02
arigoah, it seems that having only one real space and 'space=None' as alternative doesn't trigger this specialization problem14:02
arigobut it should force 'space' to exist everywhere in the C code14:02
cfbolza bit cheating, though14:03
arigoof course14:03
cfbolzbut valid for the performance benchmark14:04
xyz359 (n=xyz359@pool-68-238-174-197.tampfl.fios.verizon.net) joined #pypy.14:29
arigowaaaa, doesn't work14:32
cfbolzwhy not?14:33
cfbolzcrashes terribly? or does not compile?14:33
arigono no it compiles14:33
arigobut the code still has no 'space' anywhere14:33
arigoafter 'space.call_function(w_entry_point)', the annotator knows that 'space' cannot be None any more14:33
cfbolzmagic powers?14:33
Action: arigo tries a more obscure hack14:38
arigofor now, the RTyper will believe that SomePBC({space}) needs a MultipleFrozenPBCRepr instead of a SinglePBCRepr...14:39
cfbolzhow about making the annotator dumber, just for this exercise: like removing the knowlegde that a getattr on something-or-None asserts that it cannot really be None?14:39
arigoit's more indirect14:40
arigobecause it's a method call, the annotation of 'self' is entierely rebuilt as a SomeInstance() with the precise class where the method was found14:40
cfbolzuh, I see14:40
arigoyes, it's the call, not the getattr14:40
cfbolzI see14:41
cfbolzis my impression wrong that the release didn't attract much attention?14:41
xorAxAxat least i did a lot of advertising :)14:42
cfbolznot more than usual14:42
xorAxAxwhy should it attract more attention?14:54
cfbolzno, I am saying it attracted less14:55
alextp (n=top@201008227201.user.veloxzone.com.br) left #pypy.14:55
alextp (n=top@201008227201.user.veloxzone.com.br) joined #pypy.14:55
xorAxAxthe only visible difference is a speed increase for the average guy, right?14:56
cfbolztranslatable thunks14:56
xorAxAx"and it is still damn slow" or something like that they could say14:57
xorAxAxyeah, but who needs the thunkspace? :)14:57
cfbolzyes, but they also could have said that for earlier releases14:57
xorAxAxthey did :)14:57
cfbolzyes, but is beside the point14:57
xorAxAxmy point is that most guys are bored if they see the "feature list". "we have gotten faster, but still 10 times slower than ordinary python". i think they are not interested in the other parts of the pypy project - at least those who didnt know pypy before15:02
cfbolzyou have no idea. just read the comp.lang.python threads after the earlier releases. some of it was (as usual) crazy, but speed was not the most important discussion point15:03
idnar_ (i=mithrand@unaffiliated/idnar) left irc: Read error: 110 (Connection timed out)15:03
xorAxAxcfbolz: which one was, then?15:04
cfbolz(what else)15:04
xorAxAxyeah, sure15:05
xorAxAxis there any new flexibility additions besides some new partly finished backends and the thunkspace compilation possiblity?15:05
xorAxAx(that need to be discussed)15:05
jacob22|homecfbolz: I think it is a bit too early to tell about what attention the release attracts. This week and weekend is fairly holiday intensive. Halloween in the US and All Sints Day in many parts of Europe.15:06
cfbolzjacob22|home: maybe15:06
cfbolzxorAxAx: are you kidding?15:06
cfbolzthe parser/compiler is _very_ important15:06
xorAxAxcfbolz: ah, right15:06
jacob22|homexorAxAx: Indeed, it is the whole reason for making the release.15:07
jacob22|homeSo, now people can go write their own language modification in Python and they can write up their trial implementations for PEPs in Python.15:09
xorAxAxin fact, i cannot find any reply at all re the release announcements via gmane or google15:12
xorAxAxbut i dont see that usually for moinmoin either :)15:13
Nick change: paniq_ -> paniq15:15
Rhamphoryncushrm.  Alas, my favorite threading design (using sandboxes) is simply not possible with CPython, so there's no point doing it with PyPy unless PyPy is replacing CPython16:20
xorAxAxwhat are sandboxes?16:23
xorAxAxin this context16:23
Rhamphoryncusbasically seperate interpreters that can't access the outside world except by passing immutable types (such as str and int) and thread-safe types (such as queues)16:24
RhamphoryncusIf you use a tracing GC (ie Boehm) then you don't need the GIL16:25
Rhamphoryncusand there's no undefined behavior (since simultaneous access to mutable types is prohibited)16:26
RhamphoryncusContrast that to standard Python threads where the language specs don't specify interleaving or the memory model (actually, do they specify threads at all?)  The CPython implementation does treat most C functions as effectively atomic, but that's pretty hacky16:30
arigothis is indeed a sane approach, but it requires some careful language design16:46
Rhamphoryncussomewhat, yeah :)16:49
RhamphoryncusEspecially if you try to extend it to make it possible for user classes to become immutable16:49
arigoprobably modules too -- messy16:50
arigoI would say that you can already do something along these lines with py.execnet16:50
arigowell, not the sharing part, but the exchanging-only-primitive-objects part16:51
Rhamphoryncusyeah probably16:54
arigoPyPy could provide an in-process equivalent to execnet, I suppose, where you can really share the large blobs of immutable data between threads16:55
xorAxAxand there is this erlang approach16:55
Rhamphoryncuserlang was part of my inspiration :)16:55
xorAxAxarigo: but how would this fit into the language spec?16:55
arigoxorAxAx: I don't know :-)16:56
xorAxAxarigo: ;-)16:56
arigoat worst, you could provide a completely unsafe thread module16:56
arigoand let Python libraries build safe models on top of it16:56
Rhamphoryncusyum C ;)16:57
xorAxAxhmm, why is the GIL needed at all ...16:57
xorAxAx(for pypy)16:57
arigo? for the same reason as in CPython16:57
xorAxAxcpython has thread-unsafe code on the c side16:58
Rhamphoryncuswhat you need is a memory model, that specifies how things interact.  The GIL provides a very simple memory model16:58
xorAxAxdoes pypy has thread-unsafe code as well?16:58
xorAxAxi mean internally16:58
Rhamphoryncushowever, the GIL in CPython only makes C code behave sanely.  It does not protect Python code16:58
xorAxAxan unsafe thread module would not work for cpython, i guess16:59
xorAxAxwould it?16:59
RhamphoryncusIMO the *current* thread module doesn't work ;)16:59
Rhamphoryncusit prevents undefined corruption, but still permits defined corruption, if that makes sense :)17:00
xorAxAxarigo: are the answers yes and no?17:01
arigoI'm not sure I understand what you mean by having thread-unsafe code on the C side17:02
xorAxAxcode is unsafe if it relies on globals so to say17:03
_hannes (n=yuuhu@i577B52AD.versanet.de) joined #pypy.17:03
xorAxAx(modifying them potentially)17:03
arigoit's not only about globals17:03
xorAxAxassuming that there is no ref counting17:03
Rhamphoryncusanything is thread-unsafe if it can be affected multiple threads.  Funny that :)17:03
xorAxAxwhat would happen if python didnt have a GIL and the threads used locks to syncronise python globals?17:04
arigothen you would crash on synchronuous access to any mutable object17:04
arigoin the heap17:05
xorAxAxon read access?17:05
arigowhen one thread reads and another writes, or two threads write17:05
Rhamphoryncusright, you need to lock every mutable object as well.  That includes the weakref list btw17:05
arigoyes, nothing new so far17:06
xorAxAxarigo: because the old objects were deallocated when the thread 2 put his new element into the list (example), right?17:06
arigono, just any concurrent writes can leave the object in an inconsistent state17:06
xorAxAxhmm, yeah17:07
arigoor a read in the middle of a write by another thread sees an inconsistent object17:07
xorAxAxhow about an object field locked then?17:07
RhamphoryncusAnd you'd get a "crash" if you needed a couple operations to be treated as a single (atomic) operation and they're not.  You wouldn't get a segfault, but you would (probably, eventually!) get an exception17:07
arigono, you can very easily get segfaults17:07
xorAxAxwould it be difficult to implement it in pypy? such an object field?17:07
Rhamphoryncuserr.. right, we're talking about unsafe C here.  Forgot :)17:08
RhamphoryncusxorAxAx: it took java *years* to get it right, going through many revisions17:08
xorAxAxRhamphoryncus: you mean the syncronisation primitives visible to the programmer?17:08
RhamphoryncusPyPy could copy Java, making it much quicker, but it'd still be difficult17:08
Rhamphoryncusno, to come up with a memory model that let you do anything sane17:09
xorAxAxRhamphoryncus: and what was the clue they needed to accomplish that?17:09
Rhamphoryncusreally the WHOLE threading design17:09
xorAxAxi mean, what is the key point of their model?17:09
RhamphoryncusI don't think there is one key point17:10
Rhamphoryncusit's big and complicated17:10
Rhamphoryncusoh, and it reduces optimization potential ;)17:10
xorAxAxis there a page describing it well enough?17:12
Rhamphoryncuslots I believe :)17:13
Rhamphoryncusgoogle for the "double checked lock problem"17:13
Rhamphoryncusused for years, even in books on java.. turns out it doesn't work ;)17:14
Action: xorAxAx found http://www.cs.umd.edu/~pugh/java/memoryModel/DoubleCheckedLocking.html already17:14
xorAxAxhmm, thats a result of jitting17:16
Rhamphoryncusthe Boehm GC is pretty much the same btw.  C does *not* support it, but it "mostly works", so people use it..17:16
Rhamphoryncus(and that's why I can't do sandboxes in CPython.  Needs Boehm)17:17
xorAxAxhmm, the only solution is a TLS pattern17:17
xorAxAxand the volatile modifier17:17
xorAxAxbut this is another level than the issue pypy has ..17:18
xorAxAxpypy hasn't even syncronised "transactions on objects" internally (like cpython)17:18
Rhamphoryncusvolatile isn't sufficient.  It doesn't guarantee the pointer will be kept around17:19
xorAxAx"does not work" - oops17:19
xorAxAxso just TLS works17:19
xorAxAxthread local storage17:19
Rhamphoryncushrm.  Not sure what you mean though :)17:20
xorAxAxyou store a flag which is just accessible from the ucrrent thread17:20
xorAxAxtls means that some variable can have different values in different threads17:21
xorAxAxthere is an example on the page above17:21
Rhamphoryncusyes, but.. how does that fix threading? :)  I know how TLS works..17:21
Rhamphoryncusbtw, I think Boehm's support of TLS is iffy17:22
xorAxAxsee the pattern17:22
Action: Rhamphoryncus looks at the page17:23
Rhamphoryncusahh, as a work-around for double checked locking.  I should pay more attention ;)17:23
xorAxAxbut as i said - this doesnt help pypy :)17:24
RhamphoryncusAfter reading about those problems do you agree with the approach of sandboxes, where you have no undefined behavior?17:25
xorAxAxarigo: how about implementing this boolean flag in every object and implementing some CMPXCHG logic (atomic lock checking) into the backends?17:26
xorAxAxRhamphoryncus: yeah, they just dont work for python :)17:26
Rhamphoryncus*CPython*.  They can work if you don't use C ;)17:26
xorAxAxRhamphoryncus: i mean, how would such a sandbox start?17:26
xorAxAxno, i mean the language17:26
xorAxAxRhamphoryncus: empty?17:27
RhamphoryncusI've been debating how best to do that17:27
RhamphoryncusMost likely it'd start with a function call17:27
RhamphoryncusThe function itself, the globals, and the arguments would have to be immutable17:28
RhamphoryncusYou could also have monitor sandboxes, where the sandbox persists but only one call can be within it at a time17:28
xorAxAxand how do you make them immutable?17:29
Rhamphoryncusand threaded sandboxes.. used to start threads when you don't have a GIL-based threading module to fall back on ;)17:29
Rhamphoryncusstr and int are immutable to begin with, functions can be too.. the tricky part is the module that contains the function17:30
arigoxorAxAx: removing the GIL in Python is not related to this Java-level discussion...17:30
Rhamphoryncus*probably* use a freeze() function to do that17:30
arigoxorAxAx: see for example the very long discussions on python-dev,17:30
arigoxorAxAx: like  http://mail.python.org/pipermail/python-dev/2005-September/056423.html17:30
xorAxAxyeah, i know!17:30
Rhamphoryncusarigo: those get funny after you've read enough of them :)17:31
RhamphoryncusThere's even a post of mine on sandboxes17:31
xorAxAxarigo: MvL says that the idea is nice17:31
xorAxAxarigo: just that its not cpython compatible17:31
xorAxAxbecause it would be incompatible17:31
xorAxAxto old modules etc. and a lot of owrk17:32
Rhamphoryncusheh, my sandboxes are compatible, sort of.  They let you use existing modules in normal code, you just can't pass the modules in to the sandboxes :)17:32
xorAxAxbut pypy is flexible, i read somewhere %-)17:33
RhamphoryncusI may try implementing sandboxes in PyPy eventually.  Wait for the performance to get up higher first though :)17:34
Rhamphoryncuswhy wait?17:35
xorAxAxyes, why wait?17:35
Rhamphoryncuslaziness :)17:35
xorAxAxin fact, pypy is very complex - thats a good reason as well :)17:36
Rhamphoryncusand really sandboxes don't add functionality.  They impose restrictions to allow greater confidence in threading and to allow optimizations.  Obviously optimizations aren't applicable if pypy is slow17:36
cfbolzxorAxAx: depends of course, what you mean with "pypy" in that sentence. the standard interpreter is reasonably easy17:36
xorAxAxRhamphoryncus: do you know this erlang threading semantics module for python?17:37
Rhamphoryncushrm I never looked too close into it17:37
xorAxAxcfbolz: hmm, would you need to modify the interpreter to implement this object level locking and not the object space?17:38
cfbolzthe standard interpreter includes the object space17:38
cfbolzbut yes17:38
xorAxAxhmm, ok17:38
Rhamphoryncusobject-level locking requires defining wht an "object" is.  Python is rather vague on that, and is likely to get even more vague ;)17:40
xorAxAxit is an implementation detail in any case ...17:41
xorAxAxand mutable object is kinda clear for python, isnt it?17:41
RhamphoryncusGuido has mentioned removing the enforcement on class methods, letting you assign any function to a class and having it get bound and called for instances17:41
Rhamphoryncusfor CPython it is17:41
Rhamphoryncusif defined in C..17:42
RhamphoryncusIf it's a complicated object done in Python.. well it'll end up looking like RMS came up with the name ;)17:42
xorAxAxwhich name?17:42
xorAxAxrichard "root mean square" stallman?17:43
RhamphoryncusI'm thinking HURD here17:44
Rhamphoryncusor HIRD.. Hurd of Interfaces Representing Depth17:44
Rhamphoryncusconsider this.. you have a class for a tree structure, and it has a .foreach() method.  Does it remain locked while in the .foreach() method?17:45
RhamphoryncusAnd if that's not bad enough consider finalizers!  What if one of them tried to modify the tree structure.  Is it locked at the time?  Where is the finalizer getting called from?17:46
RhamphoryncusI'm actually leaning towards java on that one, atleast their weakref handling.. it doesn't call anything, it just adds it to a list that the application is expected to poll occasionally17:47
xorAxAxRhamphoryncus: that is not relevant for pypy17:47
xorAxAxlocking to ensure object integrity is not related to synchronisation directives on the language layer17:48
RhamphoryncusWhy?  Because pypy distinguishes "core" types from user-level types?17:48
xorAxAxno, because it should not e.g. lock the list for you but just the list header17:48
xorAxAxyou need to lock the elements on your own17:49
RhamphoryncusYou're implying manual locking17:49
RhamphoryncusI thought the intent was to use automatic per-object locks17:49
xorAxAxyeah, for internal integrity17:50
xorAxAxbtw, what i have never understood is this: cpython switches the thread every x words. aList[:2] = ... compiles to more than word. why is it thread-safe, though?17:51
xorAxAxs/than word/than one word/17:51
Rhamphoryncusthe aList[:2] = is actually one call to a C function17:52
xorAxAxin fact, you have to use locks in python core more often than many python programmers think. the question is: at which point does the GIL help the python programmer at all?17:52
RhamphoryncusThe real nasty thing is that Py_DECREF may call __del__ methods which may do anything, so it can switch within t hem17:53
xorAxAxRhamphoryncus: those are 4 vm steps17:53
xorAxAx3x load and one store_slice17:53
Rhamphoryncusload of what?  the 2?  the ...?17:54
xorAxAxthe operand on the right side (...), the list  and the constant in the slice arg17:54
Rhamphoryncusand I'd say the GIL *doesn't* help the python program.  It provides you with defined corruption, rather than the undefined corruption you'd get in C.  It's still corruption though17:54
xorAxAxyeah, but you often read in clp that the "GIL protects you here"17:55
RhamphoryncusWell, you're right that it doesn't make them all atomic.  Only the last part is done atomicly17:55
RhamphoryncusThat's because often you only need the last part to be atomic :)17:55
RhamphoryncusI think it's a piss-poor design if you rely on the GIL though ;)17:55
xorAxAxno, you hope that it is17:55
jacob22|homeAny sane solution to the threading problem requires semantic changes to Python.17:55
Rhamphoryncusjacob22|home: sandboxed threads are my favorite option ;)17:56
jacob22|homeRight now a thread owns nothing and has access to everything.17:56
xorAxAxjacob22|home: but the one with a field in the object header, suggested by the posting by arigo above could not even be defeated by MvL17:56
xorAxAxand it would not change the semantics17:57
jacob22|homexorAxAx: The field would indicate ownership?17:57
xorAxAxjacob22|home: to indicate the locking state17:58
jacob22|homexorAxAx: And how would that be checked by others trying to access the object?17:58
xorAxAxjacob22|home: threads wait till it has dropped to zero before modifying the object18:00
jacob22|homeIsn't that a semantic change?18:00
xorAxAxin which scenario?18:01
xorAxAxi dont think so18:01
xorAxAxthe coder would not see this at all18:01
Rhamphoryncusunless it deadlocks ;)18:02
xorAxAxbut it cannot deadlock if pypy has no bugs, right?18:02
RhamphoryncusThat assumes it's only usable for core types, in which case I regard it as entierly useless :)18:03
jacob22|homeRhamphoryncus: Actually, unless the resource isn't released. And then we need some way of making sure we can get out of such a situation.18:03
xorAxAxbecause the locked transaction is low level and would not involve calling code that needs to lock this or other objects18:03
Rhamphoryncusjacob22|home: there lies madness18:03
xorAxAxRhamphoryncus: why just for core types?18:03
RhamphoryncusCPython *could* use per-object locks.  They'd be a nightmare to maintain though18:04
Rhamphoryncus<xorAxAx> but it cannot deadlock if pypy has no bugs, right?18:04
jacob22|homeRhamphoryncus: I don't think so. There are languages with primitives to deal with such problems. SR is the best one I know of.18:04
xorAxAxRhamphoryncus: just the things in the std. object space need support for this ll thing i think18:04
RhamphoryncusI have confidence in the user.  If it COULD deadlock, it WILL deadlock ;)18:04
Rhamphoryncusjacob22|home: SR?18:05
jacob22|homeRhamphoryncus: Everything can deadlock.18:05
Rhamphoryncusjacob22|home: actually some languages can't.  They can still live lock though18:05
xorAxAxjacob22|home: things can just deadlock if there a two syncronised objects that could wait on each other at all18:05
jacob22|homeRhamphoryncus: Synchroizing Resources. Research language out of the University of Arizona. Quite old by now.18:05
xorAxAxjacob22|home: but if the locked transactions (LOCs) are such small that you dont call code that fiddles with other objects ...18:06
Rhamphoryncusheh, there's sooooooo many different designs for concurrency, once you start digging18:06
xorAxAxso the question is: why would you need to touch more than one object in the locked state?18:07
jacob22|homexorAxAx: You have to in order to guarantee atomicity.18:07
xorAxAxjacob22|home: make an example18:07
xorAxAxe.g. a list.pop - it would just need to touch the list18:08
xorAxAxwhile locking it18:08
jacob22|homeWe have a banking system. You deduct $1 from one customer account and add it to another one.18:08
xorAxAxjacob22|home: i am not talking about transactions in the python code18:08
xorAxAxjacob22|home: i am talking about python objects (the interpreter)18:09
RhamphoryncusI assert that any system that only protects core types is not worth doing18:09
xorAxAxRhamphoryncus: depends on your goal. the one i am thinking about is: the GIL has to die18:09
xorAxAxnot about language semantics or design18:10
RhamphoryncusxorAxAx: killing the GIL is a means to an end, not an end unto itself18:10
jacob22|homexorAxAx: Ahh. Well, the interpreter can be a lot more primitive, since we have control over what is going on.18:10
xorAxAxRhamphoryncus: sure, it will enable perfect threading and scalabilit18:11
xorAxAxjacob22|home: yep18:11
Rhamphoryncusthe GIL prevents using multiple CPUs and doesn't help user code use threads safely.  Per-object locks only does the first part18:11
xorAxAxand pypy is not the tool to protect coders from creating deadlock-patterns18:11
xorAxAxRhamphoryncus: i think its fairly simple. if all cpython opcodes just need to lock one object concurrently, implementing this should be nearly a no-brainer :)18:12
xorAxAxbut i am not sure if this is the case18:12
jacob22|homexorAxAx: Not that I know how much there would be to gain in being able to multi-thread the interpreter.18:12
RhamphoryncusxorAxAx: oh, did I mention it'd destroy performance? :)18:13
xorAxAxRhamphoryncus: hmm, which performance? ;-)18:13
RhamphoryncusCPython only touches the GIL once per *100* opcodes18:13
xorAxAxof course this is orthogonal to jitting18:13
jacob22|homexorAxAx: I suppose parallising the loading of modules would be the greatest advantage.18:14
Rhamphoryncusper-object locks would require touching them once per every function18:14
xorAxAxjacob22|home: umm18:14
Rhamphoryncusand at that point the locking overhead becomes the bottleneck18:14
xorAxAxjacob22|home: parallelising the interpreter means that it can benifit from multiple nodes/cpus18:14
xorAxAxwhy loading of modules?18:14
RhamphoryncusSO much that you lose what you gain from having multiple CPUs18:15
Rhamphoryncussome algorithms break even with 4 CPUs.  Many do not18:15
xorAxAxin the future, every system will have 4 cores :)18:15
Rhamphoryncuscontrast that to lockless threading (which could be done with sandboxes).  They're essentially free on a 1 CPU box, and it only gets better on a multiple CPU box18:15
xorAxAxRhamphoryncus: or micro threads in erlang :)18:17
RhamphoryncusxorAxAx: I'm talking hardware level here.  Repeated locking kills performance, lockless algorithms do not18:18
cfbolzRhamphoryncus: you really can do a lot of that with py.execnet already18:18
RhamphoryncusIf erlang uses locking (such as with a queue) then it may very well be slower than a single-threaded program18:18
Rhamphoryncuscfbolz: is that a pypy thingy?18:18
xorAxAxRhamphoryncus: umm, you dont use global queues in erlang18:19
cfbolzRhamphoryncus: no, it's part of the py-lib18:19
xorAxAxRhamphoryncus: you simply queue messages for someone18:19
RhamphoryncusxorAxAx: isn't tuplespace (isn't that what it's called?) a form of a global queue?18:19
cfbolzRhamphoryncus: http://codespeak.net/py/current/doc/execnet.html18:19
xorAxAxRhamphoryncus: just messages need to queued in erlang AFAIK, what else?18:19
xorAxAxRhamphoryncus: yeah, right18:20
xorAxAxRhamphoryncus: but they are thread-local, those tuplespaces18:20
RhamphoryncusxorAxAx: umm, being global doesn't matter anyway.  Queues in general require locks :)18:20
Rhamphoryncuseh?  erlang doesn't have threads18:20
Rhamphoryncusit has "processes", which many-to-few map to OS threads18:21
xorAxAxi mean every micro thread has one, sorry18:21
RhamphoryncusxorAxAx: I'm *sure* the micro threads communicate...18:21
jacob22|homexorAxAx: It is a matter of the code being executable in parallel at all. At what level you can express independence between execution chains.18:21
xorAxAxyeah, they queue messages18:21
xorAxAxjacob22|home: we are assuming separate threads here18:21
xorAxAxe.g. my windows has 63 processes and 571 threads currently :)18:22
jacob22|homexorAxAx: So, what parts of the interpreter can you profitably thread?18:22
RhamphoryncusI actually doubt erlang does all that good for simple tasks.  It scales very well and does a few other cool things, but it probably has a lot of overhead18:22
xorAxAxjacob22|home: it just needs to be run in one thread18:22
xorAxAxjacob22|home: but concurrently18:23
xorAxAxRhamphoryncus: "if it scales well", it can just have constant overhead18:23
Rhamphoryncushmm.  Otoh, if the ordering semantics are loose enough then they could consolidate queue accesses and mitigate the locking cost18:23
Rhamphoryncusand since it's intended to be distributed it probably has loose ordering semantics18:24
xorAxAxyeah, the messages just need to match18:24
xorAxAxthe signature or something like that18:24
Rhamphoryncusyeah, it's all pattern matching18:25
jacob22|homexorAxAx: Concurrently with what?18:25
xorAxAxjacob22|home: another interpreter thread18:25
xorAxAxjust imagine you won in the lottery and have a machine with 4 cores. using python, you would just be able to use 25% of it18:26
cfbolzthat's nonsense18:26
cfbolzjust use four interpreters18:26
xorAxAxcfbolz: but then, you have the disadvantages of scaling via processes. bigger memory overhead or passing of data (via execnet?)18:27
jacob22|homexorAxAx: Running separate programs is trivial. OS:es know how to do do that. The interesting thing is to make a single program run faster using multiple CPU:s.18:28
Rhamphoryncusheh, there's still the old standbye.. if performance is really a problem you should rewrite the bottleneck in C ;)18:28
xorAxAxjacob22|home: yes18:28
cfbolzbut if it is trivial, why then not just do it :-)18:28
Rhamphoryncusjacob22|home: and not go insane while doing it ;)18:28
xorAxAxhmm, are there any IPC libs for python optimised for local usage and large amount of data?18:28
jacob22|homexorAxAx: This is not done by running multiple interpreters.18:28
xorAxAxwhich in fact simplify Rhamphoryncus' model?18:29
xorAxAxjacob22|home: why not? lets assume that someone thought about 2 funcs being executed at the same time18:29
xorAxAxjacob22|home: then there need to be two threads at the OS level running those 2 funcs without global locks18:30
xorAxAxand those 2 threads need one interpreter each, dont they?18:31
RhamphoryncusAnyway, I'm gonna head off to bed.  G'night all :)18:31
cfbolzg'night :-)18:32
jacob22|homexorAxAx: Yes, and they need atomicity over multiple objects. We are back at my earlier objection.18:32
xorAxAxgn Rhamphoryncus 18:32
arigoxorAxAx: Samuele points me to POSH (http://poshmodule.sourceforge.net/posh/html/), never tried, though18:32
Rhamphoryncus (n=rhamph@unaffiliated/rhamphoryncus) left irc: "Support ISO 8601! http://www.cl.cam.ac.uk/~mgk25/iso-time.html"18:32
xorAxAxhmm, discontinued since 2003 :)18:33
xorAxAxjacob22|home: yeah, i posed a question: is it possible to write implementations for every byte code word that just need to lock one object at the same time18:34
xorAxAxthen you can use the simple locking idea from above18:34
xorAxAxarigo: and he somehow knows that it is the only one?18:35
arigoit seems so18:36
jacob22|homearigo: It also seems to invoke the overhead of one OS process per thread. That is fairly expensive.18:37
xorAxAxjacob22|home: yeah, processes are heavy weight18:37
xorAxAxjacob22|home: you choose threads or micro threads if you need many or few often and fast ...18:38
arigojacob22|home: that was an answer to the question "is there a Python module for fast high-volume IPC", nothing more18:38
jacob22|homearigo: Ok.18:39
xorAxAxbut IPC using python is memory intensive18:40
ita (n=ita@kde/developer/tnagy) joined #pypy.18:42
itapypy not compiling - gc/gc.h not found - any idea ?18:42
cfbolzita: yes, you need the boehm garbage collector installed18:43
alextpinstall libgc-dev18:43
alextpor something like it18:43
cfbolzor you have to use reference counting18:43
cfbolzvia the --gc=ref option18:43
cfbolzto translate_pypy18:43
Action: ita retries with gc=ref18:50
cfbolzgave up with boehm already? :-)18:50
itano package for my distro18:51
cfbolzoh, I see18:51
cfbolzwhat do you use?18:51
xorAxAxgood that windows users dont need to look for packages :)18:51
itaopensuse 10 - but i guess --gc=ref needs to be tested too18:51
cfbolzita: opensuse has boehm18:52
cfbolz(I think)18:52
alextpit should have18:52
itanot on my dvd so i have given up18:52
itastill on rc118:52
cfbolzbut 9.3 had an _extremely_ old version, maybe that did not change18:52
cfbolz(so old as to be unusable with pypy)18:52
cfbolzita: the problem with refcounting is that we don't have any cycle detection yet. so cyclic garbage will never be reclaimed18:57
itai should not make cyclic structures then ?18:57
itai only have trees18:57
cfbolzpypy is not really production ready anyway18:58
itai have seen - no threading for example18:58
itacpickle not working in the regression tests, only pickle18:58
xorAxAxit has threading. it just blocks too often18:58
cfbolzxorAxAx: not right now, there is a bug that breaks it18:58
xorAxAxcfbolz: ah, ok18:58
cfbolzita: "c"pickle does of course not make sense with pypy :-)18:59
itawill stat-ing files be faster with pypy ? :)18:59
cfbolzat the moment nothing is faster with pypy18:59
xorAxAx10 times slower i guess :)18:59
arigoita: cPickle actually works.  The 5 reported failures test an undocumented interface of Python's cPickle...19:07
arigo(which is setting 'fast=1' on the pickler object -- who knows about it?)19:07
cfbolzarigo: but for pypy pickle = cpickle, right?19:08
arigoalmost, yes19:08
arigolook at pypy/lib/cPickle.py :-)19:09
arigoit says "one-liner implementation of cPickle", but it's 40 lines actually19:09
itasome debug info  .. [rtyper:WARNING] PBC <pypy.objspace.std.stdtypedef.StdTypeDef instance at 0x4072bd0c> has no attribute 'memofield_0'19:12
cfbolzthat's a known issue19:12
cfbolz(although I don't know what the actual problem is :-)19:12
arigoindeed.  We looked it up but I don't remember19:14
arigoit was fine, though19:15
cfbolz"the mystery error"19:15
arigo"warning" :-)19:17
cfbolzoh, yes. the mystery _warning_ :-)19:18
Nick change: ita -> gruik19:47
gruikanything to do for ImportError: No module named pygame ?20:34
alextpinstall pygame20:34
gruikhehe ok :)20:34
gruik (n=ita@ left irc: Remote closed the connection20:43
bima (n=loubna_g@adsl-138-193-192-81.adsl.iam.net.ma) joined #pypy.20:49
arigo (n=arigo@c-3c8b70d5.022-54-67626719.cust.bredbandsbolaget.se) left irc: "[x]chat"21:34
alextp (n=top@201008227201.user.veloxzone.com.br) left #pypy.21:50
xorAxAxhmm, posh uses fork.22:08
xorAxAxi wonder why there are no other IPC toolkits for python22:08
cfbolzbecause all people interested in that are like discussion more than implementing stuff?22:09
xorAxAxbecause they use e.g. jython22:10
cfbolzwhy is the topic than raised so often?22:10
xorAxAxand because it is not trivial22:10
xorAxAxcfbolz: because you want to use more than one processor node and dont work around strange limits like an inner xmlrpc system (easy to implement, slow for IPC)22:11
xorAxAxcfbolz: assuming that you are going to implement it using multiple processes22:12
cfbolzsorry, my problem with all these discussions is that I never personally found a case where all that stuff would be useful for me22:12
xorAxAxi just have one multiprocessor machine - a very old sparcstation II. so i wont benefit from it22:12
xorAxAxumm, 20, not II22:12
cfbolzso I might be ignorant22:13
yota (n=seb@home.nmeos.net) joined #pypy.22:13
xorAxAxcfbolz: imagine you have a program which is cpu bound22:13
xorAxAxcfbolz: which has to work with data22:13
cfbolzsure, I have loads of them22:13
xorAxAxcfbolz: and you have two processor nodes22:13
xorAxAxnow all is written i npython22:13
cfbolzI _do_ have that situation often22:14
xorAxAxpython has the GIL like any other scripting language that is comparable22:14
cfbolzbut it could always be solved by IPC22:14
xorAxAxi _am_ talking about IPC22:14
xorAxAxso how do you do that IPC?22:14
xorAxAxposh is about IPC22:14
cfbolzpy.execnet suits my needs. pipes do it most of the time, too22:14
xorAxAxpipes ...22:15
cfbolzpy.execnet is just a clever way to wrap pipes, btw22:15
xorAxAxdoes execnet LPC/RPC?22:16
cfbolzwhat is that?22:16
xorAxAxi.e. can you call procedures with it?22:16
xorAxAxthe name suggests it22:16
cfbolzyes, you can22:16
xorAxAxbut you will realise that it will be the limiting factor in apps with much data22:16
cfbolz_some_ apps with much data, I agree22:17
cfbolzbut not all apps with much data have that problem22:17
xorAxAxesp. if you are passing non-string data22:19
cfbolzmost of the time datapassing was not the limiting factor for me22:19
cfbolzconsider raytracing a movie, for example22:19
cfbolzvery nicely clusterizable22:20
xorAxAxif the raytracer is written in python and you want to shift the movie into a codec (written in python %-) you have a lot of bandwith22:20
xorAxAxserialising that into a pipe is more expensive than passing around a pointer to a ring buffer22:20
cfbolzok, but you are not going to divide into raytracer/codec22:21
cfbolzbut rather into frames22:21
xorAxAxwhich gives you many stills that have to go to the codec22:21
cfbolzyes, but the codec is usually cheap compared to raytracing22:22
xorAxAxhmm, yeah. do you know the 500 bytes raytracer written in postscript?22:22
xorAxAxit needed 2 hours on my printer22:22
cfbolzI never had the patience to wait. just did it with qhostscript22:22
xorAxAxwhile we are at parallelisation: a backend for the cell processor would be nice22:24
cfbolznot easy22:24
cfbolzwell, depends how you want to access the multiple cores22:25
cfbolzbut doing it automatically is hard22:25
xorAxAxyou just define entry points that are getting translated separately22:25
cfbolzlet us just write the JIT first22:26
xorAxAxumm, where is the difficulty having an entry point that just calls a few funcs (those that should go to the cores)22:26
xorAxAxof course you need a lot of glue to let it work out of the box suitable for developing22:27
xorAxAxbut its not interesting anyway as long as nobody has such a playstation22:27
cfbolzright. maybe we can get IBM to sponsor us :-)22:27
xorAxAxyeah :)22:28
xorAxAx"rpython is easier than pseudo code. let your young consumers code shaders and transformers in simple lines of python"22:29
cfbolzwould be cool, actually. I would love to be able to do that22:30
cfbolzalthough I think there was a python frontend to some graphic card shading language22:30
xorAxAxhmm, there is blender :)22:31
xorAxAxand http://graphics.cs.lth.se/pyfx/22:32
xorAxAxhmm, looks nice22:32
cfbolzthe blender->python binding useable, but a bit strange22:32
cfbolzit's a bit, well, unpythonic :-)22:33
xorAxAxthe psp binding is very ... verbose22:33
cfbolzyow, pyfx looks cool22:33
xorAxAxthey have 30 -50 kwargs for many methods/classes :)22:34
xorAxAxpaint shop pro22:34
xorAxAxbut they have a macro recorder22:34
cfbolzthat records python?22:34
cfbolzthat is cool22:34
xorAxAxbetter than a VBA recorder :)22:34
cfbolzI learned what little I know of visual basic by looking a recorded code22:34
xorAxAxyeah, there code generator is really advanced22:35
xorAxAxand its using keyworded args very often22:35
xorAxAxi have never seen that in plain vb code such often22:36
cfbolzgimps python binding is quite ok too, I think22:37
cfbolzhi christian!22:38
stakkarsnice weather here in Beverly Hills22:39
xorAxAxhi stakkars 22:39
xorAxAxvacations? :-)22:39
stakkarsxorAxAx: Hi! Thanks for helping me out with testing22:39
xorAxAxno problem. i found 15 bugs as you might have read ;-)22:39
stakkarsno, paid work, some Python optimization22:40
xorAxAxwhich could be tracked down to missing quotes22:40
xorAxAxstakkars: ah, ok22:40
stakkars(didn't read yet, was veery busy)22:40
stakkarsmaybe this is becoming the first tiny commercial PyPy application.22:40
xorAxAxoh, why didnt they choose cpython?22:41
xorAxAxbecause it yields a ZeroDivisionError in their timer-calibrator? ;-)22:41
stakkarsthey do use CPython 2.4. They are processing gigs of data with this, and some very basic22:41
stakkarsstuff like parsing a line of text and extracting some fields takes too much time.22:41
stakkarsI can probably isolate this and generate a small RPython extension module for it.22:42
xorAxAxah, so you want to use rpython like it was not meant to be used? ;-)I22:42
Action: cfbolz hits xorAxAx 22:42
xorAxAxouch :)22:42
stakkarsyes. Inever felt too hapy with what I was supposed to think is "meant". If I can use anything right now, I'l do it. :-)22:43
xorAxAxthats the pythonic pragmatic approach22:43
stakkarsit will take long until we can use PyPy to optimize stuff like that. And I want to keep them away from Pyrex et. al.22:43
stakkarsthey are Python newbies and write a quite well optimized system for processing their data.22:44
stakkarsbut they can't get this kind of code fast enough:22:44
xorAxAxso you will hit a problem in the documentation phase - at the point where you explain how to maintain and extend the code, nor?22:45
stakkarscode = line[0]; amount = int(line[1:36]; name = line[36:50]; isBid = line[50] == 'B'22:45
cfbolzthat indeed looks like it could be done nicely with rpython22:45
stakkarsyes, this will be just an intermediate approach to get them some speed.22:45
stakkarsabsolutely, and this is the stuff where we already create incredible fast code.22:46
stakkarsI'm just testing whether I can get at the data, easily. I think we do support returning a tuple.22:46
stakkarsEWD, stock trading22:46
stakkarssory EWT.22:46
cfbolzI am not sure22:46
xorAxAxrpython seems to made for string processing :)22:46
xorAxAxs/to m/to be m/22:47
stakkarsI saw one piece of code in the tests where we return a tuple of numbers and check it in the CPython part.22:47
stakkarsat the same time, it was said that we cannot produce a list because it will be an RList.22:48
cfbolztuples work22:48
stakkarshowever, I'd be happy to find a way to use PyPy here, although it is immature. *** GREAT ***22:48
cfbolzsure, list is a bad idea, since the types have to match22:49
stakkarsthe idea is to create new sponsors by this. And this is a good one, the really need speed, and they love Python. Their stuff is almost all Java, but they wont to be more flexible.22:50
cfbolzand they are switching over?22:50
jacob22|homestakkars: How long will you be in the US?22:50
stakkarsif I can work for them from time to time, this is just good for the project.22:50
stakkarsIt is planned that I leave on the 14th in the evening. But the ticket can be extended.22:51
jacob22|homestakkars: Yes, it sounds quite good.22:51
stakkarsjacob22|home: I thought of our conversation when I negotiated this contract. I was apporached by head-hunters which had read conversations between Armin and me. :-)   PyPy rules!22:52
jacob22|homestakkars: I hope you can do some Pypy stuff while you are there. I'll have my deliverables ready for review in a couple of days and we really need your timesheets.22:52
jacob22|homestakkars: Yes, I think Pypy is good for everyone involved.22:53
stakkarsyes I planned to have time for reviewing. And for the latter: this is my spare day, and I'm going to finish the time sheet never-ending-story today, not programming, just a little sight-seeing and that.22:53
jacob22|homestakkars: Great!22:54
xorAxAxstakkars: what kind of "conversation" do those head hunters monitor?22:54
xorAxAxpublic ML?22:54
stakkarsjust activites on mailing lists.22:55
jacob22|homestakkars: I can recommend the Getty museum, and I have heard that the La Brea (tarpits with dinosaur fossiles) is really something to see.22:55
stakkarsyes. And I got a phone call from a nice sounding woman, and then I got contacts to the core people of EWT, and finally I got the best rate I ever had. :-))22:55
stakkarsjacob22|home: hey, this is great, thanks! It is good to have you around. How about "Jacob's guide to the Galaxy"? :)22:56
jacob22|homestakkars: Nah, I just hand out tips to people I like. ;-)22:58
jacob22|homeI even managed to get around in LA by bus. That was difficult though.22:59
bima (n=loubna_g@adsl-138-193-192-81.adsl.iam.net.ma) left #pypy.22:59
xorAxAxjacob22|home: why is that?22:59
stakkarsI got a bicycle, will see if this is enought to get at the places.   23:00
cfbolzthe USA are not always friendly to public transport. depends on the city, though23:01
stakkarspublic transportation in LA is almost only buses. They got three tram lines, all not in my area.23:01
stakkarscompared to SF or Washington DC, this is nothing.23:02
cfbolznot to talk about New York23:02
jacob22|homestakkars: It should be. Stay off the main streets though. You are usually allowed to ride bikes on the sidewalks in US cities. 23:02
stakkarsbut the citiy is incedibly nice. I can just step out of the door and start photo shooting.23:02
stakkarsI've never been to New York but for changing planes. Will happen some time.23:03
cfbolzyou should! it's a wonderful city23:03
jacob22|homestakkars: You have missed very little. Tall buildings and snotty people.23:04
cfbolzjacob22|home: careful, I have relatives there :-)23:04
stakkarsyes I was told this in the introduction to EWT and how I should get along.23:05
stakkarsthey are from New York, partially. and their working hours are New York time, to be in sync with trading.23:05
cfbolzso you have to get up early?23:06
jacob22|homestakkars: Ahh. Refugees. ;-P23:06
stakkarsit was my first day, yesterday, yet-lagged and tired, but enough to let them conclude "we're excited" in the evening.23:06
stakkarsyes, I'm starting between 7:30 and 9:0023:06
stakkarsjacob22|home: yes :-)23:07
jacob22|homestakkars: That's good. You won't be so awfully jetlagged when you get home. Going to bed late in the evening California time makes for very bad sleeping patterns when you get home.23:08
stakkarsjacob22|home. yeah. Although I'm working 10+ hours.23:09
stakkarsjacob22|home: I was thinking of hiring Richard Emslie part-time for my company and let him do some paid PyPy work, similar to what Holger does with Carl. Would this be possible, or is it a problem, time-sheet wise?23:10
jacob22|homeI'm in the middle of porting all my CDs to a hard disk. I just did the 100th one.23:10
cfbolzstakkars: might be a problem, because richard is becoming a physical person23:10
jacob22|homestakkars: There may be a problem in that he is an NP member of the project.23:11
xorAxAxcfbolz: you are virtual? :-)23:11
jacob22|homeThe PO is investigating.23:11
xorAxAxcfbolz: so you are just a chat bot?23:11
cfbolzlet's not go down that road, there are far too many bots in the python community already23:12
xorAxAxbut where is the different between a virtual and a physical guy here?23:12
cfbolzthe physical person gets his sprint travel refunded23:13
cfbolzby the EU23:13
stakkarsah, Richard is getting a role in PyPy, already, which contradicts to work for me?23:13
cfbolzstakkars: indeed, he will become a physical person23:13
cfbolzand it's not clear whether both at the same time works23:13
stakkarseeek! I need somebody. Maybe I can buy a piece of Carl the Virtual23:14
xorAxAxdoes he support LPAR already?23:14
cfbolzstakkars: don't worry, it might still work out23:14
jacob22|homestakkars: It may be that he can't work for you at all. This is unlikely. It may be that he can work for you if he resigns as a NP in the project. It may be that he can stay on as a NP, as long as he doesn't get any reimbursement directly from the EU while he works for you. We don't know yet.23:15
jacob22|homestakkars: Holger has the same issue with hiring Eric.23:15
stakkarsok. But you what I'm after: If I officially do work for other companies, I'd like to have somkebody jump in for my PyPy work, not missing funding.23:16
stakkarss/you/you know/23:16
jacob22|homestakkars: No problem, as long as the one jumping in is an official employee of your company. No contractors.23:17
cfbolzstakkars: exactly what holger does as well23:17
stakkarsthat's what I'm trying to do. Just someone tell me at some point whom I can employ.23:17
stakkarsit is not so easy because it has to be a valid PyPy developer23:18
stakkarswho is also accepted by the group 23:18
jacob22|homestakkars: I'll keep an eye on what comes from the PO and I'll make sure you get the info.23:18
stakkarsjacob22|home: thank you so much!23:19
ericvrp (n=ericvrp@ericvrp.demon.nl) joined #pypy.23:39
jacob22|homeericvrp: Hi! Javascript backend looks good.23:42
ericvrpthank you23:43
ericvrpI have not been very busy with it lately. My last checkin (where testing against browsers works) is what kept me back for a while23:44
xorAxAx+    #note: 0 second did not work probably because the GET would23:45
xorAxAx+<meta http-equiv="refresh" content="0">23:45
xorAxAxhmm :)23:45
xorAxAxmaybe a  1 should go there?23:45
cfbolzericvrp: are the tests expected to pass?23:47
cfbolzall of them, I mean?23:48
cfbolzsome do23:48
ericvrpoops. that comment should no longer be there. The problem was something else... firefox did a get /favicon.ico23:48
ericvrpno. on my system 90 pass, there rest don't.23:48
cfbolzit worked after fixing the path23:48
cfbolzwhich is highly OS dependant, I fear23:48
cfbolzand you really should put a note somewhere that your browser gets killed :-)23:49
ericvrptest/test_class.py[16] ....FFF.FF..F.F.23:49
cfbolzsame pattern for me23:49
ericvrpmaybe :/23:49
cfbolznot so bad :-)23:50
ericvrpmaybe a sys.platform test?23:50
cfbolzfirefox also supports nice options where you can open the stuff in a new tab, btw23:50
cfbolzmaybe, yet23:50
cfbolzis this related to the browser-based js tests that guido is working on?23:51
cfbolzor just a coincidence23:51
ericvrpno, I visited him last week and this is based on his code. 23:51
cfbolzvery cool23:51
cfbolz89 passed23:52
ericvrpThe differnce is mainly that he uses an external javascript unittest framework and does all the tests at once, while I run test-for-test with some simple html to fetch the next test.23:52
ericvrpIt really need to be cleaned up!23:52
cfbolzthat's ok23:53
ericvrpvery odd, 90 pass here. Sometimes spidermonkey is not reproducable too. Maybe some undefined js variable? ah well...23:54
cfbolzno idea. it scrolled away23:54
xorAxAxargh, it doesnt like spaces in the filename23:54
ericvrpProbably quotes aroung the url would fix that easilyt23:54
xorAxAxericvrp: do you know the webbrowser module? maybe it can help here23:55
cfbolzindeed, that's an idea23:55
ericvrp* googling23:55
cfbolzit's part of the stdlib23:55
ericvrpthis is nice. more discussion now already then all the time with llvm. I LOVE javascript :)23:56
cfbolzthat is not true23:56
ericvrpit the beginning no23:56
xorAxAxwhat do you mean, ericvrp?23:56
cfbolzquite a lot of the llvm discussion predates you :-)23:56
ericvrpbut lately there has not been alot of interest was there?23:57
cfbolzno, now it works more or less :-)23:57
cfbolza solved problem is uninteresing23:57
cfbolz(an unsolved one two, of course)23:57
ericvrpyes, and it proves pypy is plexable, but that's it.23:58
xorAxAxare there llvm vs. c benchmarks?23:58
cfbolzericvrp: oh come on. don't start with this again. it is a worthwhile backend to have23:58
ericvrpbut I'm not complaining, I just think it is nice that you people are looking at genjs now23:58
ericvrpxorAxAx: the speed is currently comparable23:58
cfbolzgenjs will certainly show that javascript is _not_ flexible :-)23:59
xorAxAxand not fast :)23:59
--- Sun Nov 6 200500:00

Generated by irclog2html.py 2.9.2 by Marius Gedminas - find it at mg.pov.lt!