I ran your program on two separate systems, three versions of Python here at work:
1. Pent M 2GHz/Windows XP Pro, running Cygwin Python 2.4.3:
flips heads tails diff %
1000000 499598 500402 804 99.9196 per cent
Time was 2.863 seconds
os.times() is (2.5779999999999998, 0.156, 0.0, 0.0, 14526.053)
2. AMD Opteron/Linux RHE 4, running Python 2.2.3:
flips heads tails diff %
1000000 499111 500889 1778 99.8222 per cent
Time was 6.972 seconds
os.times() is (6.9699999999999998, 0.02, 0.0, 0.0, 3496342.9399999999 )
3. Pent M 2GHz/Windows XP Pro, running Windows Python 2.4.3:
flips heads tails diff %
1000000 499667 500333 666 99.9334 per cent
Time was 2.172 seconds
os.times() is (0.265625, 2.125, 0.0, 0.0, 0.0)
The second machine is a workhorse doing a lot, and it is also a virtual machine. The first and third is my work laptop - notice that the difference between cygwin (Posix/UNIX) and Windows is how the user/system time is computed. And also how the real time is returned.
The Windows APIs might swap values or might just handle things differently. I can't say without a lot more research.
-Arcege
On 10/3/06,
Dick Moores <[EMAIL PROTECTED]> wrote:
At 05:24 AM 10/3/2006, Michael P. Reilly wrote:
>It is not really a "ghost". On most systems, there is a split
>between what happens while you are a "user" and what happens deep
>inside the operation "system". The function is showing you how much
>time elapsed while in those two areas of the system.
>
>To show you what I mean, take a simple program that writes to the disk:
>
>def show_me_the_spam(breakfast):
> file = open(" spam.txt", "w")
> for i in range(10:
> print >>file, "spam, spam, %s and spam" % breakfast
> file.close()
>show_me_the_spam("eggs")
( 0.25, 0.15625, 0.0, 0.0, 0.0) run included creating spam.txt
(0.171875, 0.09375, 0.0, 0.0, 0.0) after spam.txt already there
The (user time)/(system time) ratios are 1.6 and 1.83, respectively.
For my coinFlip.py I got
(0.3125, 4.015625, 0.0, 0.0, 0.0)
the (user time)/(system time) ratio was 0.079. Why the big
difference? From your explanation I would have thought that your
script would have a LOWER ratio than coinFlip.py because of the file
operations.
Here's coinFlips.py and its result again:
==================================================
# coinFlip.py
import time, os
from random import choice
heads, tails = 0, 0
flips = 1000000
timeStart = time.time()
for x in xrange(flips):
coin = choice(["heads", "tails"])
if coin == "heads":
heads += 1
else:
tails += 1
timeEnd = time.time()
osTimes = os.times
difference = abs(heads - tails)
print " flips heads tails diff %"
print flips, heads, tails, difference, 100 -
(100*difference*1.0/flips), "per cent"
print "Time was %.4g seconds" % (timeEnd - timeStart)
print "os.times() is", osTimes()
======================================================
>>>
Evaluating 1coinFlip.py
flips heads tails diff %
1000000 500902 499098 1804 99.8196 per cent
Time was 4.156 seconds
os.times() is (0.3125, 4.015625, 0.0, 0.0, 0.0)
>>>
If I reduce flips from 1000000 to 1000, I get
>>>
Evaluating 1coinFlip.py
flips heads tails diff %
1000 482 518 36 96.4 per cent
Time was 0.016 seconds
os.times() is (0.296875 , 0.09375, 0.0, 0.0, 0.0)
>>>
with a ratio of 3.17. So what's happening during the 1,000,000 loop
that's put into "system" space?
>Most of the execution of the program would happen as the "user";
>things like calling functions, evaluating string parameters,
>counting in the loop.
>
>But the parts that would need to talk to hardware, parts that might
>be dangerous to have the program have direct control over or might
>need to be shared with other programs at the same time (like a
>printer or a keyboard or a disk drive) - these parts of the program
>are hidden underneath function calls and statements like "open" and
>"print" and put into a "system" space.
>
>How much time you spend in "system" and "user" space tells you how
>CPU and resource intensive your program is.
>
>The 3rd and 4th values are the same, but cumulative for all that
>programs "children". A program can spawn subprocesses to help it
>(see os.system and the like).
>
>All the above times are CPU times - time spent while the program has
>been using fractions of CPU seconds. The last value shows that
>actual real duration of the program, similar to your (timeEnd -
>timeStart), but a bit more accurate. (Though it appears that value
>isn't supported on your system?)
My system is
a Dell Dimension 4600i running Windows XP Professional Service Pack
2 (build 2600).
Why wouldn't that value be supported? Should I call Dell? Bang on
MS's door? (I live about a mile away.) I feel a bit cheated. ;)
Thanks, Michael, for your extended answer..
Dick
_______________________________________________
Tutor maillist - Tutor@python.org
http://mail.python.org/mailman/listinfo/tutor
--
There's so many different worlds,
So many different suns.
And we have just one world,
But we live in different ones.
_______________________________________________ Tutor maillist - Tutor@python.org http://mail.python.org/mailman/listinfo/tutor
