On 14/05/2015 22:55, BartC wrote:
> def whiletest():
> i=0
> while i<=100000000:
> i=i+1
>
> whiletest()
>
Python 2.5 9.2 seconds
Python 3.1 13.1
Python 3.4.3 17.0
Python 3.4.3 14.3 (under Ubuntu on same machine, using the version
I built today)
That's quite a big range!
PyPy does it in 0.7 seconds. The same program within my own *simple*
bytecode interpreter (not for Python) has a fastest time of 1.5 seconds
but makes use of ASM. A version 100% in (gcc) C can manage 2 seconds.
(Actually my ASM-aided code took 0.5 seconds (some crucial section had
been commented out). Faster than PyPy and just using simple brute-force
methods.)
So far I haven't find anything that explains the discrepancy (the
languages are different, mine is simpler, but the Python code isn't
doing anything that complicated, only LOAD_FASTs and such, and LOAD_FAST
is apparently just an array access.
It turns out the LOAD_FASTs were the simple byte-codes!
I'm just starting to find out just how much of a big complicated mess
this project really is. I wouldn't be surprised if there aren't many
people who actually understand it all, and that would explain why no-one
seems to have had much luck in getting the speed up (if anything, it's
getting slower).
I still have no idea yet exactly what an object comprises. I know that
even an innocuous-looking LOAD_CONST actually loads a tuple from a table
(complete with flag testing and bounds checks, although taking those out
made no discernible difference).
It appears to be those "<=" and "+" operations in the code above where
much of the time is spent. When I trace out the execution paths a bit
more, I'll have a better picture of how many lines of C code are
involved in each iteration.
--
Bartc
--
https://mail.python.org/mailman/listinfo/python-list
