Issue #15369. Please use the new "performance" benchmark suite.
Tools/Demos
-----------
+- Issue #15369: The pybench microbenchmark has been removed from Tools. Please
+ use the new Python benchmark suite https://github.com/python/performance
+ which is more reliable and includes a portable version of pybench working on
+ Python 2 and Python 3.
+
- Issue #28102: The zipfile module CLI now prints usage to stderr.
Patch by Stephen J. Turnbull.
parser Un-parsing tool to generate code from an AST.
-pybench Low-level benchmarking for the Python evaluation loop. (*)
-
pynche A Tkinter-based color editor.
scripts A number of useful single-file programs, e.g. tabnanny.py
\r
where dlltool /q && goto skipdlltoolsearch\r
set _DLLTOOL_PATH=\r
-where /R "%EXTERNALS%\" dlltool > "%TEMP%\dlltool.loc" 2> nul && set /P _DLLTOOL_PATH= < "%TEMP%\dlltool.loc" & del "%TEMP%\dlltool.loc" \r
+where /R "%EXTERNALS%\" dlltool > "%TEMP%\dlltool.loc" 2> nul && set /P _DLLTOOL_PATH= < "%TEMP%\dlltool.loc" & del "%TEMP%\dlltool.loc"\r
if not exist "%_DLLTOOL_PATH%" echo Cannot find binutils on PATH or in external && exit /B 1\r
for %%f in (%_DLLTOOL_PATH%) do set PATH=%PATH%;%%~dpf\r
set _DLLTOOL_PATH=\r
@if errorlevel 1 exit /B\r
@rem build.bat turns echo back on, so we disable it again\r
@echo off\r
- \r
+\r
if "%PGO%" EQU "" (\r
@call "%PCBUILD%build.bat" -e -p %BUILD_PLAT% -t %TARGET% %CERTOPTS%\r
) else (\r
@call "%PCBUILD%build.bat" -e -p %BUILD_PLAT% -c PGInstrument -t %TARGET% %CERTOPTS%\r
@if errorlevel 1 exit /B\r
- \r
+\r
@del "%BUILD%*.pgc"\r
if "%PGO%" EQU "default" (\r
"%BUILD%python.exe" -m test -q --pgo\r
"%BUILD%python.exe" -m test -r -q --pgo\r
) else if "%PGO%" EQU "default10" (\r
for /L %%i in (0, 1, 9) do "%BUILD%python.exe" -m test -q -r --pgo\r
- ) else if "%PGO%" EQU "pybench" (\r
- "%BUILD%python.exe" "%PCBUILD%..\Tools\pybench\pybench.py"\r
) else (\r
"%BUILD%python.exe" %PGO%\r
)\r
- \r
+\r
@call "%PCBUILD%build.bat" -e -p %BUILD_PLAT% -c PGUpdate -t Build %CERTOPTS%\r
)\r
@if errorlevel 1 exit /B\r
echo default Test suite with --pgo\r
echo default2 2x test suite with --pgo and randomized test order\r
echo default10 10x test suite with --pgo and randomized test order\r
-echo pybench pybench script\r
echo.\r
echo The following substitutions will be applied to the download URL:\r
echo Variable Description Example\r
+++ /dev/null
-from pybench import Test
-
-class SimpleIntegerArithmetic(Test):
-
- version = 2.0
- operations = 5 * (3 + 5 + 5 + 3 + 3 + 3)
- rounds = 120000
-
- def test(self):
-
- for i in range(self.rounds):
-
- a = 2
- b = 3
- c = 3
-
- c = a + b
- c = b + c
- c = c + a
- c = a + b
- c = b + c
-
- c = c - a
- c = a - b
- c = b - c
- c = c - a
- c = b - c
-
- c = a / b
- c = b / a
- c = c / b
-
- c = a * b
- c = b * a
- c = c * b
-
- c = a / b
- c = b / a
- c = c / b
-
- a = 2
- b = 3
- c = 3
-
- c = a + b
- c = b + c
- c = c + a
- c = a + b
- c = b + c
-
- c = c - a
- c = a - b
- c = b - c
- c = c - a
- c = b - c
-
- c = a / b
- c = b / a
- c = c / b
-
- c = a * b
- c = b * a
- c = c * b
-
- c = a / b
- c = b / a
- c = c / b
-
- a = 2
- b = 3
- c = 3
-
- c = a + b
- c = b + c
- c = c + a
- c = a + b
- c = b + c
-
- c = c - a
- c = a - b
- c = b - c
- c = c - a
- c = b - c
-
- c = a / b
- c = b / a
- c = c / b
-
- c = a * b
- c = b * a
- c = c * b
-
- c = a / b
- c = b / a
- c = c / b
-
- a = 2
- b = 3
- c = 3
-
- c = a + b
- c = b + c
- c = c + a
- c = a + b
- c = b + c
-
- c = c - a
- c = a - b
- c = b - c
- c = c - a
- c = b - c
-
- c = a / b
- c = b / a
- c = c / b
-
- c = a * b
- c = b * a
- c = c * b
-
- c = a / b
- c = b / a
- c = c / b
-
- a = 2
- b = 3
- c = 3
-
- c = a + b
- c = b + c
- c = c + a
- c = a + b
- c = b + c
-
- c = c - a
- c = a - b
- c = b - c
- c = c - a
- c = b - c
-
- c = a / b
- c = b / a
- c = c / b
-
- c = a * b
- c = b * a
- c = c * b
-
- c = a / b
- c = b / a
- c = c / b
-
- def calibrate(self):
-
- for i in range(self.rounds):
- pass
-
-class SimpleFloatArithmetic(Test):
-
- version = 2.0
- operations = 5 * (3 + 5 + 5 + 3 + 3 + 3)
- rounds = 120000
-
- def test(self):
-
- for i in range(self.rounds):
-
- a = 2.1
- b = 3.3332
- c = 3.14159
-
- c = a + b
- c = b + c
- c = c + a
- c = a + b
- c = b + c
-
- c = c - a
- c = a - b
- c = b - c
- c = c - a
- c = b - c
-
- c = a / b
- c = b / a
- c = c / b
-
- c = a * b
- c = b * a
- c = c * b
-
- c = a / b
- c = b / a
- c = c / b
-
- a = 2.1
- b = 3.3332
- c = 3.14159
-
- c = a + b
- c = b + c
- c = c + a
- c = a + b
- c = b + c
-
- c = c - a
- c = a - b
- c = b - c
- c = c - a
- c = b - c
-
- c = a / b
- c = b / a
- c = c / b
-
- c = a * b
- c = b * a
- c = c * b
-
- c = a / b
- c = b / a
- c = c / b
-
- a = 2.1
- b = 3.3332
- c = 3.14159
-
- c = a + b
- c = b + c
- c = c + a
- c = a + b
- c = b + c
-
- c = c - a
- c = a - b
- c = b - c
- c = c - a
- c = b - c
-
- c = a / b
- c = b / a
- c = c / b
-
- c = a * b
- c = b * a
- c = c * b
-
- c = a / b
- c = b / a
- c = c / b
-
- a = 2.1
- b = 3.3332
- c = 3.14159
-
- c = a + b
- c = b + c
- c = c + a
- c = a + b
- c = b + c
-
- c = c - a
- c = a - b
- c = b - c
- c = c - a
- c = b - c
-
- c = a / b
- c = b / a
- c = c / b
-
- c = a * b
- c = b * a
- c = c * b
-
- c = a / b
- c = b / a
- c = c / b
-
- a = 2.1
- b = 3.3332
- c = 3.14159
-
- c = a + b
- c = b + c
- c = c + a
- c = a + b
- c = b + c
-
- c = c - a
- c = a - b
- c = b - c
- c = c - a
- c = b - c
-
- c = a / b
- c = b / a
- c = c / b
-
- c = a * b
- c = b * a
- c = c * b
-
- c = a / b
- c = b / a
- c = c / b
-
- def calibrate(self):
-
- for i in range(self.rounds):
- pass
-
-class SimpleIntFloatArithmetic(Test):
-
- version = 2.0
- operations = 5 * (3 + 5 + 5 + 3 + 3 + 3)
- rounds = 120000
-
- def test(self):
-
- for i in range(self.rounds):
-
- a = 2
- b = 3
- c = 3.14159
-
- c = a + b
- c = b + c
- c = c + a
- c = a + b
- c = b + c
-
- c = c - a
- c = a - b
- c = b - c
- c = c - a
- c = b - c
-
- c = a / b
- c = b / a
- c = c / b
-
- c = a * b
- c = b * a
- c = c * b
-
- c = a / b
- c = b / a
- c = c / b
-
- a = 2
- b = 3
- c = 3.14159
-
- c = a + b
- c = b + c
- c = c + a
- c = a + b
- c = b + c
-
- c = c - a
- c = a - b
- c = b - c
- c = c - a
- c = b - c
-
- c = a / b
- c = b / a
- c = c / b
-
- c = a * b
- c = b * a
- c = c * b
-
- c = a / b
- c = b / a
- c = c / b
-
- a = 2
- b = 3
- c = 3.14159
-
- c = a + b
- c = b + c
- c = c + a
- c = a + b
- c = b + c
-
- c = c - a
- c = a - b
- c = b - c
- c = c - a
- c = b - c
-
- c = a / b
- c = b / a
- c = c / b
-
- c = a * b
- c = b * a
- c = c * b
-
- c = a / b
- c = b / a
- c = c / b
-
- a = 2
- b = 3
- c = 3.14159
-
- c = a + b
- c = b + c
- c = c + a
- c = a + b
- c = b + c
-
- c = c - a
- c = a - b
- c = b - c
- c = c - a
- c = b - c
-
- c = a / b
- c = b / a
- c = c / b
-
- c = a * b
- c = b * a
- c = c * b
-
- c = a / b
- c = b / a
- c = c / b
-
- a = 2
- b = 3
- c = 3.14159
-
- c = a + b
- c = b + c
- c = c + a
- c = a + b
- c = b + c
-
- c = c - a
- c = a - b
- c = b - c
- c = c - a
- c = b - c
-
- c = a / b
- c = b / a
- c = c / b
-
- c = a * b
- c = b * a
- c = c * b
-
- c = a / b
- c = b / a
- c = c / b
-
- def calibrate(self):
-
- for i in range(self.rounds):
- pass
-
-
-class SimpleLongArithmetic(Test):
-
- version = 2.0
- operations = 5 * (3 + 5 + 5 + 3 + 3 + 3)
- rounds = 60000
-
- def test(self):
-
- for i in range(self.rounds):
-
- a = 2220001
- b = 100001
- c = 30005
-
- c = a + b
- c = b + c
- c = c + a
- c = a + b
- c = b + c
-
- c = c - a
- c = a - b
- c = b - c
- c = c - a
- c = b - c
-
- c = a / b
- c = b / a
- c = c / b
-
- c = a * b
- c = b * a
- c = c * b
-
- c = a / b
- c = b / a
- c = c / b
-
- a = 2220001
- b = 100001
- c = 30005
-
- c = a + b
- c = b + c
- c = c + a
- c = a + b
- c = b + c
-
- c = c - a
- c = a - b
- c = b - c
- c = c - a
- c = b - c
-
- c = a / b
- c = b / a
- c = c / b
-
- c = a * b
- c = b * a
- c = c * b
-
- c = a / b
- c = b / a
- c = c / b
-
- a = 2220001
- b = 100001
- c = 30005
-
- c = a + b
- c = b + c
- c = c + a
- c = a + b
- c = b + c
-
- c = c - a
- c = a - b
- c = b - c
- c = c - a
- c = b - c
-
- c = a / b
- c = b / a
- c = c / b
-
- c = a * b
- c = b * a
- c = c * b
-
- c = a / b
- c = b / a
- c = c / b
-
- a = 2220001
- b = 100001
- c = 30005
-
- c = a + b
- c = b + c
- c = c + a
- c = a + b
- c = b + c
-
- c = c - a
- c = a - b
- c = b - c
- c = c - a
- c = b - c
-
- c = a / b
- c = b / a
- c = c / b
-
- c = a * b
- c = b * a
- c = c * b
-
- c = a / b
- c = b / a
- c = c / b
-
- a = 2220001
- b = 100001
- c = 30005
-
- c = a + b
- c = b + c
- c = c + a
- c = a + b
- c = b + c
-
- c = c - a
- c = a - b
- c = b - c
- c = c - a
- c = b - c
-
- c = a / b
- c = b / a
- c = c / b
-
- c = a * b
- c = b * a
- c = c * b
-
- c = a / b
- c = b / a
- c = c / b
-
- def calibrate(self):
-
- for i in range(self.rounds):
- pass
-
-class SimpleComplexArithmetic(Test):
-
- version = 2.0
- operations = 5 * (3 + 5 + 5 + 3 + 3 + 3)
- rounds = 80000
-
- def test(self):
-
- for i in range(self.rounds):
-
- a = 2 + 3j
- b = 2.5 + 4.5j
- c = 1.2 + 6.2j
-
- c = a + b
- c = b + c
- c = c + a
- c = a + b
- c = b + c
-
- c = c - a
- c = a - b
- c = b - c
- c = c - a
- c = b - c
-
- c = a / b
- c = b / a
- c = c / b
-
- c = a * b
- c = b * a
- c = c * b
-
- c = a / b
- c = b / a
- c = c / b
-
- a = 2 + 3j
- b = 2.5 + 4.5j
- c = 1.2 + 6.2j
-
- c = a + b
- c = b + c
- c = c + a
- c = a + b
- c = b + c
-
- c = c - a
- c = a - b
- c = b - c
- c = c - a
- c = b - c
-
- c = a / b
- c = b / a
- c = c / b
-
- c = a * b
- c = b * a
- c = c * b
-
- c = a / b
- c = b / a
- c = c / b
-
- a = 2 + 3j
- b = 2.5 + 4.5j
- c = 1.2 + 6.2j
-
- c = a + b
- c = b + c
- c = c + a
- c = a + b
- c = b + c
-
- c = c - a
- c = a - b
- c = b - c
- c = c - a
- c = b - c
-
- c = a / b
- c = b / a
- c = c / b
-
- c = a * b
- c = b * a
- c = c * b
-
- c = a / b
- c = b / a
- c = c / b
-
- a = 2 + 3j
- b = 2.5 + 4.5j
- c = 1.2 + 6.2j
-
- c = a + b
- c = b + c
- c = c + a
- c = a + b
- c = b + c
-
- c = c - a
- c = a - b
- c = b - c
- c = c - a
- c = b - c
-
- c = a / b
- c = b / a
- c = c / b
-
- c = a * b
- c = b * a
- c = c * b
-
- c = a / b
- c = b / a
- c = c / b
-
- a = 2 + 3j
- b = 2.5 + 4.5j
- c = 1.2 + 6.2j
-
- c = a + b
- c = b + c
- c = c + a
- c = a + b
- c = b + c
-
- c = c - a
- c = a - b
- c = b - c
- c = c - a
- c = b - c
-
- c = a / b
- c = b / a
- c = c / b
-
- c = a * b
- c = b * a
- c = c * b
-
- c = a / b
- c = b / a
- c = c / b
-
- def calibrate(self):
-
- for i in range(self.rounds):
- pass
+++ /dev/null
-from pybench import Test
-
-class PythonFunctionCalls(Test):
-
- version = 2.1
- operations = 5*(1+4+4+2)
- rounds = 60000
-
- def test(self):
-
- global f,f1,g,h
-
- # define functions
- def f():
- pass
-
- def f1(x):
- pass
-
- def g(a,b,c):
- return a,b,c
-
- def h(a,b,c,d=1,e=2,f=3):
- return d,e,f
-
- # do calls
- for i in range(self.rounds):
-
- f()
- f1(i)
- f1(i)
- f1(i)
- f1(i)
- g(i,i,i)
- g(i,i,i)
- g(i,i,i)
- g(i,i,i)
- h(i,i,3,i,i)
- h(i,i,i,2,i,3)
-
- f()
- f1(i)
- f1(i)
- f1(i)
- f1(i)
- g(i,i,i)
- g(i,i,i)
- g(i,i,i)
- g(i,i,i)
- h(i,i,3,i,i)
- h(i,i,i,2,i,3)
-
- f()
- f1(i)
- f1(i)
- f1(i)
- f1(i)
- g(i,i,i)
- g(i,i,i)
- g(i,i,i)
- g(i,i,i)
- h(i,i,3,i,i)
- h(i,i,i,2,i,3)
-
- f()
- f1(i)
- f1(i)
- f1(i)
- f1(i)
- g(i,i,i)
- g(i,i,i)
- g(i,i,i)
- g(i,i,i)
- h(i,i,3,i,i)
- h(i,i,i,2,i,3)
-
- f()
- f1(i)
- f1(i)
- f1(i)
- f1(i)
- g(i,i,i)
- g(i,i,i)
- g(i,i,i)
- g(i,i,i)
- h(i,i,3,i,i)
- h(i,i,i,2,i,3)
-
- def calibrate(self):
-
- global f,f1,g,h
-
- # define functions
- def f():
- pass
-
- def f1(x):
- pass
-
- def g(a,b,c):
- return a,b,c
-
- def h(a,b,c,d=1,e=2,f=3):
- return d,e,f
-
- # do calls
- for i in range(self.rounds):
- pass
-
-###
-
-class ComplexPythonFunctionCalls(Test):
-
- version = 2.0
- operations = 4*5
- rounds = 100000
-
- def test(self):
-
- # define functions
- def f(a,b,c,d=1,e=2,f=3):
- return f
-
- args = 1,2
- kwargs = dict(c=3,d=4,e=5)
-
- # do calls
- for i in range(self.rounds):
- f(a=i,b=i,c=i)
- f(f=i,e=i,d=i,c=2,b=i,a=3)
- f(1,b=i,**kwargs)
- f(*args,**kwargs)
-
- f(a=i,b=i,c=i)
- f(f=i,e=i,d=i,c=2,b=i,a=3)
- f(1,b=i,**kwargs)
- f(*args,**kwargs)
-
- f(a=i,b=i,c=i)
- f(f=i,e=i,d=i,c=2,b=i,a=3)
- f(1,b=i,**kwargs)
- f(*args,**kwargs)
-
- f(a=i,b=i,c=i)
- f(f=i,e=i,d=i,c=2,b=i,a=3)
- f(1,b=i,**kwargs)
- f(*args,**kwargs)
-
- f(a=i,b=i,c=i)
- f(f=i,e=i,d=i,c=2,b=i,a=3)
- f(1,b=i,**kwargs)
- f(*args,**kwargs)
-
-
- def calibrate(self):
-
- # define functions
- def f(a,b,c,d=1,e=2,f=3):
- return f
-
- args = 1,2
- kwargs = dict(c=3,d=4,e=5)
-
- # do calls
- for i in range(self.rounds):
- pass
-
-###
-
-class BuiltinFunctionCalls(Test):
-
- version = 2.0
- operations = 5*(2+5+5+5)
- rounds = 60000
-
- def test(self):
-
- # localize functions
- f0 = globals
- f1 = hash
- f2 = divmod
- f3 = max
-
- # do calls
- for i in range(self.rounds):
-
- f0()
- f0()
- f1(i)
- f1(i)
- f1(i)
- f1(i)
- f1(i)
- f2(1,2)
- f2(1,2)
- f2(1,2)
- f2(1,2)
- f2(1,2)
- f3(1,3,2)
- f3(1,3,2)
- f3(1,3,2)
- f3(1,3,2)
- f3(1,3,2)
-
- f0()
- f0()
- f1(i)
- f1(i)
- f1(i)
- f1(i)
- f1(i)
- f2(1,2)
- f2(1,2)
- f2(1,2)
- f2(1,2)
- f2(1,2)
- f3(1,3,2)
- f3(1,3,2)
- f3(1,3,2)
- f3(1,3,2)
- f3(1,3,2)
-
- f0()
- f0()
- f1(i)
- f1(i)
- f1(i)
- f1(i)
- f1(i)
- f2(1,2)
- f2(1,2)
- f2(1,2)
- f2(1,2)
- f2(1,2)
- f3(1,3,2)
- f3(1,3,2)
- f3(1,3,2)
- f3(1,3,2)
- f3(1,3,2)
-
- f0()
- f0()
- f1(i)
- f1(i)
- f1(i)
- f1(i)
- f1(i)
- f2(1,2)
- f2(1,2)
- f2(1,2)
- f2(1,2)
- f2(1,2)
- f3(1,3,2)
- f3(1,3,2)
- f3(1,3,2)
- f3(1,3,2)
- f3(1,3,2)
-
- f0()
- f0()
- f1(i)
- f1(i)
- f1(i)
- f1(i)
- f1(i)
- f2(1,2)
- f2(1,2)
- f2(1,2)
- f2(1,2)
- f2(1,2)
- f3(1,3,2)
- f3(1,3,2)
- f3(1,3,2)
- f3(1,3,2)
- f3(1,3,2)
-
- def calibrate(self):
-
- # localize functions
- f0 = dir
- f1 = hash
- f2 = divmod
- f3 = max
-
- # do calls
- for i in range(self.rounds):
- pass
-
-###
-
-class PythonMethodCalls(Test):
-
- version = 2.0
- operations = 5*(6 + 5 + 4)
- rounds = 30000
-
- def test(self):
-
- class c:
-
- x = 2
- s = 'string'
-
- def f(self):
-
- return self.x
-
- def j(self,a,b):
-
- self.y = a
- self.t = b
- return self.y
-
- def k(self,a,b,c=3):
-
- self.y = a
- self.s = b
- self.t = c
-
- o = c()
-
- for i in range(self.rounds):
-
- o.f()
- o.f()
- o.f()
- o.f()
- o.f()
- o.f()
- o.j(i,i)
- o.j(i,i)
- o.j(i,2)
- o.j(i,2)
- o.j(2,2)
- o.k(i,i)
- o.k(i,2)
- o.k(i,2,3)
- o.k(i,i,c=4)
-
- o.f()
- o.f()
- o.f()
- o.f()
- o.f()
- o.f()
- o.j(i,i)
- o.j(i,i)
- o.j(i,2)
- o.j(i,2)
- o.j(2,2)
- o.k(i,i)
- o.k(i,2)
- o.k(i,2,3)
- o.k(i,i,c=4)
-
- o.f()
- o.f()
- o.f()
- o.f()
- o.f()
- o.f()
- o.j(i,i)
- o.j(i,i)
- o.j(i,2)
- o.j(i,2)
- o.j(2,2)
- o.k(i,i)
- o.k(i,2)
- o.k(i,2,3)
- o.k(i,i,c=4)
-
- o.f()
- o.f()
- o.f()
- o.f()
- o.f()
- o.f()
- o.j(i,i)
- o.j(i,i)
- o.j(i,2)
- o.j(i,2)
- o.j(2,2)
- o.k(i,i)
- o.k(i,2)
- o.k(i,2,3)
- o.k(i,i,c=4)
-
- o.f()
- o.f()
- o.f()
- o.f()
- o.f()
- o.f()
- o.j(i,i)
- o.j(i,i)
- o.j(i,2)
- o.j(i,2)
- o.j(2,2)
- o.k(i,i)
- o.k(i,2)
- o.k(i,2,3)
- o.k(i,i,c=4)
-
- def calibrate(self):
-
- class c:
-
- x = 2
- s = 'string'
-
- def f(self):
-
- return self.x
-
- def j(self,a,b):
-
- self.y = a
- self.t = b
-
- def k(self,a,b,c=3):
-
- self.y = a
- self.s = b
- self.t = c
-
- o = c
-
- for i in range(self.rounds):
- pass
-
-###
-
-class Recursion(Test):
-
- version = 2.0
- operations = 5
- rounds = 100000
-
- def test(self):
-
- global f
-
- def f(x):
-
- if x > 1:
- return f(x-1)
- return 1
-
- for i in range(self.rounds):
- f(10)
- f(10)
- f(10)
- f(10)
- f(10)
-
- def calibrate(self):
-
- global f
-
- def f(x):
-
- if x > 0:
- return f(x-1)
- return 1
-
- for i in range(self.rounds):
- pass
-
-
-### Test to make Fredrik happy...
-
-if __name__ == '__main__':
- import timeit
- if 0:
- timeit.TestClass = PythonFunctionCalls
- timeit.main(['-s', 'test = TestClass(); test.rounds = 1000',
- 'test.test()'])
- else:
- setup = """\
-global f,f1,g,h
-
-# define functions
-def f():
- pass
-
-def f1(x):
- pass
-
-def g(a,b,c):
- return a,b,c
-
-def h(a,b,c,d=1,e=2,f=3):
- return d,e,f
-
-i = 1
-"""
- test = """\
-f()
-f1(i)
-f1(i)
-f1(i)
-f1(i)
-g(i,i,i)
-g(i,i,i)
-g(i,i,i)
-g(i,i,i)
-h(i,i,3,i,i)
-h(i,i,i,2,i,3)
-
-f()
-f1(i)
-f1(i)
-f1(i)
-f1(i)
-g(i,i,i)
-g(i,i,i)
-g(i,i,i)
-g(i,i,i)
-h(i,i,3,i,i)
-h(i,i,i,2,i,3)
-
-f()
-f1(i)
-f1(i)
-f1(i)
-f1(i)
-g(i,i,i)
-g(i,i,i)
-g(i,i,i)
-g(i,i,i)
-h(i,i,3,i,i)
-h(i,i,i,2,i,3)
-
-f()
-f1(i)
-f1(i)
-f1(i)
-f1(i)
-g(i,i,i)
-g(i,i,i)
-g(i,i,i)
-g(i,i,i)
-h(i,i,3,i,i)
-h(i,i,i,2,i,3)
-
-f()
-f1(i)
-f1(i)
-f1(i)
-f1(i)
-g(i,i,i)
-g(i,i,i)
-g(i,i,i)
-g(i,i,i)
-h(i,i,3,i,i)
-h(i,i,i,2,i,3)
-"""
-
- timeit.main(['-s', setup,
- test])
+++ /dev/null
-""" CommandLine - Get and parse command line options
-
- NOTE: This still is very much work in progress !!!
-
- Different version are likely to be incompatible.
-
- TODO:
-
- * Incorporate the changes made by (see Inbox)
- * Add number range option using srange()
-
-"""
-
-from __future__ import print_function
-
-__copyright__ = """\
-Copyright (c), 1997-2006, Marc-Andre Lemburg (mal@lemburg.com)
-Copyright (c), 2000-2006, eGenix.com Software GmbH (info@egenix.com)
-See the documentation for further information on copyrights,
-or contact the author. All Rights Reserved.
-"""
-
-__version__ = '1.2'
-
-import sys, getopt, glob, os, re, traceback
-
-### Helpers
-
-def _getopt_flags(options):
-
- """ Convert the option list to a getopt flag string and long opt
- list
-
- """
- s = []
- l = []
- for o in options:
- if o.prefix == '-':
- # short option
- s.append(o.name)
- if o.takes_argument:
- s.append(':')
- else:
- # long option
- if o.takes_argument:
- l.append(o.name+'=')
- else:
- l.append(o.name)
- return ''.join(s), l
-
-def invisible_input(prompt='>>> '):
-
- """ Get raw input from a terminal without echoing the characters to
- the terminal, e.g. for password queries.
-
- """
- import getpass
- entry = getpass.getpass(prompt)
- if entry is None:
- raise KeyboardInterrupt
- return entry
-
-def fileopen(name, mode='wb', encoding=None):
-
- """ Open a file using mode.
-
- Default mode is 'wb' meaning to open the file for writing in
- binary mode. If encoding is given, I/O to and from the file is
- transparently encoded using the given encoding.
-
- Files opened for writing are chmod()ed to 0600.
-
- """
- if name == 'stdout':
- return sys.stdout
- elif name == 'stderr':
- return sys.stderr
- elif name == 'stdin':
- return sys.stdin
- else:
- if encoding is not None:
- import codecs
- f = codecs.open(name, mode, encoding)
- else:
- f = open(name, mode)
- if 'w' in mode:
- os.chmod(name, 0o600)
- return f
-
-def option_dict(options):
-
- """ Return a dictionary mapping option names to Option instances.
- """
- d = {}
- for option in options:
- d[option.name] = option
- return d
-
-# Alias
-getpasswd = invisible_input
-
-_integerRE = re.compile(r'\s*(-?\d+)\s*$')
-_integerRangeRE = re.compile(r'\s*(-?\d+)\s*-\s*(-?\d+)\s*$')
-
-def srange(s,
-
- integer=_integerRE,
- integerRange=_integerRangeRE):
-
- """ Converts a textual representation of integer numbers and ranges
- to a Python list.
-
- Supported formats: 2,3,4,2-10,-1 - -3, 5 - -2
-
- Values are appended to the created list in the order specified
- in the string.
-
- """
- l = []
- append = l.append
- for entry in s.split(','):
- m = integer.match(entry)
- if m:
- append(int(m.groups()[0]))
- continue
- m = integerRange.match(entry)
- if m:
- start,end = map(int,m.groups())
- l[len(l):] = range(start,end+1)
- return l
-
-def abspath(path,
-
- expandvars=os.path.expandvars,expanduser=os.path.expanduser,
- join=os.path.join,getcwd=os.getcwd):
-
- """ Return the corresponding absolute path for path.
-
- path is expanded in the usual shell ways before
- joining it with the current working directory.
-
- """
- try:
- path = expandvars(path)
- except AttributeError:
- pass
- try:
- path = expanduser(path)
- except AttributeError:
- pass
- return join(getcwd(), path)
-
-### Option classes
-
-class Option:
-
- """ Option base class. Takes no argument.
-
- """
- default = None
- helptext = ''
- prefix = '-'
- takes_argument = 0
- has_default = 0
- tab = 15
-
- def __init__(self,name,help=None):
-
- if not name[:1] == '-':
- raise TypeError('option names must start with "-"')
- if name[1:2] == '-':
- self.prefix = '--'
- self.name = name[2:]
- else:
- self.name = name[1:]
- if help:
- self.help = help
-
- def __str__(self):
-
- o = self
- name = o.prefix + o.name
- if o.takes_argument:
- name = name + ' arg'
- if len(name) > self.tab:
- name = name + '\n' + ' ' * (self.tab + 1 + len(o.prefix))
- else:
- name = '%-*s ' % (self.tab, name)
- description = o.help
- if o.has_default:
- description = description + ' (%s)' % o.default
- return '%s %s' % (name, description)
-
-class ArgumentOption(Option):
-
- """ Option that takes an argument.
-
- An optional default argument can be given.
-
- """
- def __init__(self,name,help=None,default=None):
-
- # Basemethod
- Option.__init__(self,name,help)
-
- if default is not None:
- self.default = default
- self.has_default = 1
- self.takes_argument = 1
-
-class SwitchOption(Option):
-
- """ Options that can be on or off. Has an optional default value.
-
- """
- def __init__(self,name,help=None,default=None):
-
- # Basemethod
- Option.__init__(self,name,help)
-
- if default is not None:
- self.default = default
- self.has_default = 1
-
-### Application baseclass
-
-class Application:
-
- """ Command line application interface with builtin argument
- parsing.
-
- """
- # Options the program accepts (Option instances)
- options = []
-
- # Standard settings; these are appended to options in __init__
- preset_options = [SwitchOption('-v',
- 'generate verbose output'),
- SwitchOption('-h',
- 'show this help text'),
- SwitchOption('--help',
- 'show this help text'),
- SwitchOption('--debug',
- 'enable debugging'),
- SwitchOption('--copyright',
- 'show copyright'),
- SwitchOption('--examples',
- 'show examples of usage')]
-
- # The help layout looks like this:
- # [header] - defaults to ''
- #
- # [synopsis] - formatted as '<self.name> %s' % self.synopsis
- #
- # options:
- # [options] - formatted from self.options
- #
- # [version] - formatted as 'Version:\n %s' % self.version, if given
- #
- # [about] - defaults to ''
- #
- # Note: all fields that do not behave as template are formatted
- # using the instances dictionary as substitution namespace,
- # e.g. %(name)s will be replaced by the applications name.
- #
-
- # Header (default to program name)
- header = ''
-
- # Name (defaults to program name)
- name = ''
-
- # Synopsis (%(name)s is replaced by the program name)
- synopsis = '%(name)s [option] files...'
-
- # Version (optional)
- version = ''
-
- # General information printed after the possible options (optional)
- about = ''
-
- # Examples of usage to show when the --examples option is given (optional)
- examples = ''
-
- # Copyright to show
- copyright = __copyright__
-
- # Apply file globbing ?
- globbing = 1
-
- # Generate debug output ?
- debug = 0
-
- # Generate verbose output ?
- verbose = 0
-
- # Internal errors to catch
- InternalError = BaseException
-
- # Instance variables:
- values = None # Dictionary of passed options (or default values)
- # indexed by the options name, e.g. '-h'
- files = None # List of passed filenames
- optionlist = None # List of passed options
-
- def __init__(self,argv=None):
-
- # Setup application specs
- if argv is None:
- argv = sys.argv
- self.filename = os.path.split(argv[0])[1]
- if not self.name:
- self.name = os.path.split(self.filename)[1]
- else:
- self.name = self.name
- if not self.header:
- self.header = self.name
- else:
- self.header = self.header
-
- # Init .arguments list
- self.arguments = argv[1:]
-
- # Setup Option mapping
- self.option_map = option_dict(self.options)
-
- # Append preset options
- for option in self.preset_options:
- if not option.name in self.option_map:
- self.add_option(option)
-
- # Init .files list
- self.files = []
-
- # Start Application
- rc = 0
- try:
- # Process startup
- rc = self.startup()
- if rc is not None:
- raise SystemExit(rc)
-
- # Parse command line
- rc = self.parse()
- if rc is not None:
- raise SystemExit(rc)
-
- # Start application
- rc = self.main()
- if rc is None:
- rc = 0
-
- except SystemExit as rcException:
- rc = rcException
- pass
-
- except KeyboardInterrupt:
- print()
- print('* User Break')
- print()
- rc = 1
-
- except self.InternalError:
- print()
- print('* Internal Error (use --debug to display the traceback)')
- if self.debug:
- print()
- traceback.print_exc(20, sys.stdout)
- elif self.verbose:
- print(' %s: %s' % sys.exc_info()[:2])
- print()
- rc = 1
-
- raise SystemExit(rc)
-
- def add_option(self, option):
-
- """ Add a new Option instance to the Application dynamically.
-
- Note that this has to be done *before* .parse() is being
- executed.
-
- """
- self.options.append(option)
- self.option_map[option.name] = option
-
- def startup(self):
-
- """ Set user defined instance variables.
-
- If this method returns anything other than None, the
- process is terminated with the return value as exit code.
-
- """
- return None
-
- def exit(self, rc=0):
-
- """ Exit the program.
-
- rc is used as exit code and passed back to the calling
- program. It defaults to 0 which usually means: OK.
-
- """
- raise SystemExit(rc)
-
- def parse(self):
-
- """ Parse the command line and fill in self.values and self.files.
-
- After having parsed the options, the remaining command line
- arguments are interpreted as files and passed to .handle_files()
- for processing.
-
- As final step the option handlers are called in the order
- of the options given on the command line.
-
- """
- # Parse arguments
- self.values = values = {}
- for o in self.options:
- if o.has_default:
- values[o.prefix+o.name] = o.default
- else:
- values[o.prefix+o.name] = 0
- flags,lflags = _getopt_flags(self.options)
- try:
- optlist,files = getopt.getopt(self.arguments,flags,lflags)
- if self.globbing:
- l = []
- for f in files:
- gf = glob.glob(f)
- if not gf:
- l.append(f)
- else:
- l[len(l):] = gf
- files = l
- self.optionlist = optlist
- self.files = files + self.files
- except getopt.error as why:
- self.help(why)
- sys.exit(1)
-
- # Call file handler
- rc = self.handle_files(self.files)
- if rc is not None:
- sys.exit(rc)
-
- # Call option handlers
- for optionname, value in optlist:
-
- # Try to convert value to integer
- try:
- value = int(value)
- except ValueError:
- pass
-
- # Find handler and call it (or count the number of option
- # instances on the command line)
- handlername = 'handle' + optionname.replace('-', '_')
- try:
- handler = getattr(self, handlername)
- except AttributeError:
- if value == '':
- # count the number of occurrences
- if optionname in values:
- values[optionname] = values[optionname] + 1
- else:
- values[optionname] = 1
- else:
- values[optionname] = value
- else:
- rc = handler(value)
- if rc is not None:
- raise SystemExit(rc)
-
- # Apply final file check (for backward compatibility)
- rc = self.check_files(self.files)
- if rc is not None:
- sys.exit(rc)
-
- def check_files(self,filelist):
-
- """ Apply some user defined checks on the files given in filelist.
-
- This may modify filelist in place. A typical application
- is checking that at least n files are given.
-
- If this method returns anything other than None, the
- process is terminated with the return value as exit code.
-
- """
- return None
-
- def help(self,note=''):
-
- self.print_header()
- if self.synopsis:
- print('Synopsis:')
- # To remain backward compatible:
- try:
- synopsis = self.synopsis % self.name
- except (NameError, KeyError, TypeError):
- synopsis = self.synopsis % self.__dict__
- print(' ' + synopsis)
- print()
- self.print_options()
- if self.version:
- print('Version:')
- print(' %s' % self.version)
- print()
- if self.about:
- about = self.about % self.__dict__
- print(about.strip())
- print()
- if note:
- print('-'*72)
- print('Note:',note)
- print()
-
- def notice(self,note):
-
- print('-'*72)
- print('Note:',note)
- print('-'*72)
- print()
-
- def print_header(self):
-
- print('-'*72)
- print(self.header % self.__dict__)
- print('-'*72)
- print()
-
- def print_options(self):
-
- options = self.options
- print('Options and default settings:')
- if not options:
- print(' None')
- return
- int = [x for x in options if x.prefix == '--']
- short = [x for x in options if x.prefix == '-']
- items = short + int
- for o in options:
- print(' ',o)
- print()
-
- #
- # Example handlers:
- #
- # If a handler returns anything other than None, processing stops
- # and the return value is passed to sys.exit() as argument.
- #
-
- # File handler
- def handle_files(self,files):
-
- """ This may process the files list in place.
- """
- return None
-
- # Short option handler
- def handle_h(self,arg):
-
- self.help()
- return 0
-
- def handle_v(self, value):
-
- """ Turn on verbose output.
- """
- self.verbose = 1
-
- # Handlers for long options have two underscores in their name
- def handle__help(self,arg):
-
- self.help()
- return 0
-
- def handle__debug(self,arg):
-
- self.debug = 1
- # We don't want to catch internal errors:
- class NoErrorToCatch(Exception): pass
- self.InternalError = NoErrorToCatch
-
- def handle__copyright(self,arg):
-
- self.print_header()
- copyright = self.copyright % self.__dict__
- print(copyright.strip())
- print()
- return 0
-
- def handle__examples(self,arg):
-
- self.print_header()
- if self.examples:
- print('Examples:')
- print()
- examples = self.examples % self.__dict__
- print(examples.strip())
- print()
- else:
- print('No examples available.')
- print()
- return 0
-
- def main(self):
-
- """ Override this method as program entry point.
-
- The return value is passed to sys.exit() as argument. If
- it is None, 0 is assumed (meaning OK). Unhandled
- exceptions are reported with exit status code 1 (see
- __init__ for further details).
-
- """
- return None
-
-# Alias
-CommandLine = Application
-
-def _test():
-
- class MyApplication(Application):
- header = 'Test Application'
- version = __version__
- options = [Option('-v','verbose')]
-
- def handle_v(self,arg):
- print('VERBOSE, Yeah !')
-
- cmd = MyApplication()
- if not cmd.values['-h']:
- cmd.help()
- print('files:',cmd.files)
- print('Bye...')
-
-if __name__ == '__main__':
- _test()
+++ /dev/null
-from pybench import Test
-
-class IfThenElse(Test):
-
- version = 2.0
- operations = 30*3 # hard to say...
- rounds = 150000
-
- def test(self):
-
- a,b,c = 1,2,3
- for i in range(self.rounds):
-
- if a == 1:
- if b == 2:
- if c != 3:
- c = 3
- b = 3
- else:
- c = 2
- elif b == 3:
- b = 2
- a = 2
- elif a == 2:
- a = 3
- else:
- a = 1
-
- if a == 1:
- if b == 2:
- if c != 3:
- c = 3
- b = 3
- else:
- c = 2
- elif b == 3:
- b = 2
- a = 2
- elif a == 2:
- a = 3
- else:
- a = 1
-
- if a == 1:
- if b == 2:
- if c != 3:
- c = 3
- b = 3
- else:
- c = 2
- elif b == 3:
- b = 2
- a = 2
- elif a == 2:
- a = 3
- else:
- a = 1
-
- if a == 1:
- if b == 2:
- if c != 3:
- c = 3
- b = 3
- else:
- c = 2
- elif b == 3:
- b = 2
- a = 2
- elif a == 2:
- a = 3
- else:
- a = 1
-
- if a == 1:
- if b == 2:
- if c != 3:
- c = 3
- b = 3
- else:
- c = 2
- elif b == 3:
- b = 2
- a = 2
- elif a == 2:
- a = 3
- else:
- a = 1
-
- if a == 1:
- if b == 2:
- if c != 3:
- c = 3
- b = 3
- else:
- c = 2
- elif b == 3:
- b = 2
- a = 2
- elif a == 2:
- a = 3
- else:
- a = 1
-
- if a == 1:
- if b == 2:
- if c != 3:
- c = 3
- b = 3
- else:
- c = 2
- elif b == 3:
- b = 2
- a = 2
- elif a == 2:
- a = 3
- else:
- a = 1
-
- if a == 1:
- if b == 2:
- if c != 3:
- c = 3
- b = 3
- else:
- c = 2
- elif b == 3:
- b = 2
- a = 2
- elif a == 2:
- a = 3
- else:
- a = 1
-
- if a == 1:
- if b == 2:
- if c != 3:
- c = 3
- b = 3
- else:
- c = 2
- elif b == 3:
- b = 2
- a = 2
- elif a == 2:
- a = 3
- else:
- a = 1
-
- if a == 1:
- if b == 2:
- if c != 3:
- c = 3
- b = 3
- else:
- c = 2
- elif b == 3:
- b = 2
- a = 2
- elif a == 2:
- a = 3
- else:
- a = 1
-
- if a == 1:
- if b == 2:
- if c != 3:
- c = 3
- b = 3
- else:
- c = 2
- elif b == 3:
- b = 2
- a = 2
- elif a == 2:
- a = 3
- else:
- a = 1
-
- if a == 1:
- if b == 2:
- if c != 3:
- c = 3
- b = 3
- else:
- c = 2
- elif b == 3:
- b = 2
- a = 2
- elif a == 2:
- a = 3
- else:
- a = 1
-
- if a == 1:
- if b == 2:
- if c != 3:
- c = 3
- b = 3
- else:
- c = 2
- elif b == 3:
- b = 2
- a = 2
- elif a == 2:
- a = 3
- else:
- a = 1
-
- if a == 1:
- if b == 2:
- if c != 3:
- c = 3
- b = 3
- else:
- c = 2
- elif b == 3:
- b = 2
- a = 2
- elif a == 2:
- a = 3
- else:
- a = 1
-
- if a == 1:
- if b == 2:
- if c != 3:
- c = 3
- b = 3
- else:
- c = 2
- elif b == 3:
- b = 2
- a = 2
- elif a == 2:
- a = 3
- else:
- a = 1
-
- if a == 1:
- if b == 2:
- if c != 3:
- c = 3
- b = 3
- else:
- c = 2
- elif b == 3:
- b = 2
- a = 2
- elif a == 2:
- a = 3
- else:
- a = 1
-
- if a == 1:
- if b == 2:
- if c != 3:
- c = 3
- b = 3
- else:
- c = 2
- elif b == 3:
- b = 2
- a = 2
- elif a == 2:
- a = 3
- else:
- a = 1
-
- if a == 1:
- if b == 2:
- if c != 3:
- c = 3
- b = 3
- else:
- c = 2
- elif b == 3:
- b = 2
- a = 2
- elif a == 2:
- a = 3
- else:
- a = 1
-
- if a == 1:
- if b == 2:
- if c != 3:
- c = 3
- b = 3
- else:
- c = 2
- elif b == 3:
- b = 2
- a = 2
- elif a == 2:
- a = 3
- else:
- a = 1
-
- if a == 1:
- if b == 2:
- if c != 3:
- c = 3
- b = 3
- else:
- c = 2
- elif b == 3:
- b = 2
- a = 2
- elif a == 2:
- a = 3
- else:
- a = 1
-
- if a == 1:
- if b == 2:
- if c != 3:
- c = 3
- b = 3
- else:
- c = 2
- elif b == 3:
- b = 2
- a = 2
- elif a == 2:
- a = 3
- else:
- a = 1
-
- if a == 1:
- if b == 2:
- if c != 3:
- c = 3
- b = 3
- else:
- c = 2
- elif b == 3:
- b = 2
- a = 2
- elif a == 2:
- a = 3
- else:
- a = 1
-
- if a == 1:
- if b == 2:
- if c != 3:
- c = 3
- b = 3
- else:
- c = 2
- elif b == 3:
- b = 2
- a = 2
- elif a == 2:
- a = 3
- else:
- a = 1
-
- if a == 1:
- if b == 2:
- if c != 3:
- c = 3
- b = 3
- else:
- c = 2
- elif b == 3:
- b = 2
- a = 2
- elif a == 2:
- a = 3
- else:
- a = 1
-
- if a == 1:
- if b == 2:
- if c != 3:
- c = 3
- b = 3
- else:
- c = 2
- elif b == 3:
- b = 2
- a = 2
- elif a == 2:
- a = 3
- else:
- a = 1
-
- if a == 1:
- if b == 2:
- if c != 3:
- c = 3
- b = 3
- else:
- c = 2
- elif b == 3:
- b = 2
- a = 2
- elif a == 2:
- a = 3
- else:
- a = 1
-
- if a == 1:
- if b == 2:
- if c != 3:
- c = 3
- b = 3
- else:
- c = 2
- elif b == 3:
- b = 2
- a = 2
- elif a == 2:
- a = 3
- else:
- a = 1
-
- if a == 1:
- if b == 2:
- if c != 3:
- c = 3
- b = 3
- else:
- c = 2
- elif b == 3:
- b = 2
- a = 2
- elif a == 2:
- a = 3
- else:
- a = 1
-
- if a == 1:
- if b == 2:
- if c != 3:
- c = 3
- b = 3
- else:
- c = 2
- elif b == 3:
- b = 2
- a = 2
- elif a == 2:
- a = 3
- else:
- a = 1
-
- if a == 1:
- if b == 2:
- if c != 3:
- c = 3
- b = 3
- else:
- c = 2
- elif b == 3:
- b = 2
- a = 2
- elif a == 2:
- a = 3
- else:
- a = 1
-
- def calibrate(self):
-
- a,b,c = 1,2,3
- for i in range(self.rounds):
- pass
-
-class NestedForLoops(Test):
-
- version = 2.0
- operations = 1000*10*5
- rounds = 300
-
- def test(self):
-
- l1 = range(1000)
- l2 = range(10)
- l3 = range(5)
- for i in range(self.rounds):
- for i in l1:
- for j in l2:
- for k in l3:
- pass
-
- def calibrate(self):
-
- l1 = range(1000)
- l2 = range(10)
- l3 = range(5)
- for i in range(self.rounds):
- pass
-
-class ForLoops(Test):
-
- version = 2.0
- operations = 5 * 5
- rounds = 10000
-
- def test(self):
-
- l1 = range(100)
- for i in range(self.rounds):
- for i in l1:
- pass
- for i in l1:
- pass
- for i in l1:
- pass
- for i in l1:
- pass
- for i in l1:
- pass
-
- for i in l1:
- pass
- for i in l1:
- pass
- for i in l1:
- pass
- for i in l1:
- pass
- for i in l1:
- pass
-
- for i in l1:
- pass
- for i in l1:
- pass
- for i in l1:
- pass
- for i in l1:
- pass
- for i in l1:
- pass
-
- for i in l1:
- pass
- for i in l1:
- pass
- for i in l1:
- pass
- for i in l1:
- pass
- for i in l1:
- pass
-
- for i in l1:
- pass
- for i in l1:
- pass
- for i in l1:
- pass
- for i in l1:
- pass
- for i in l1:
- pass
-
- def calibrate(self):
-
- l1 = range(1000)
- for i in range(self.rounds):
- pass
+++ /dev/null
-from pybench import Test
-
-class DictCreation(Test):
-
- version = 2.0
- operations = 5*(5 + 5)
- rounds = 80000
-
- def test(self):
-
- for i in range(self.rounds):
-
- d1 = {}
- d2 = {}
- d3 = {}
- d4 = {}
- d5 = {}
-
- d1 = {1:2,3:4,5:6}
- d2 = {2:3,4:5,6:7}
- d3 = {3:4,5:6,7:8}
- d4 = {4:5,6:7,8:9}
- d5 = {6:7,8:9,10:11}
-
- d1 = {}
- d2 = {}
- d3 = {}
- d4 = {}
- d5 = {}
-
- d1 = {1:2,3:4,5:6}
- d2 = {2:3,4:5,6:7}
- d3 = {3:4,5:6,7:8}
- d4 = {4:5,6:7,8:9}
- d5 = {6:7,8:9,10:11}
-
- d1 = {}
- d2 = {}
- d3 = {}
- d4 = {}
- d5 = {}
-
- d1 = {1:2,3:4,5:6}
- d2 = {2:3,4:5,6:7}
- d3 = {3:4,5:6,7:8}
- d4 = {4:5,6:7,8:9}
- d5 = {6:7,8:9,10:11}
-
- d1 = {}
- d2 = {}
- d3 = {}
- d4 = {}
- d5 = {}
-
- d1 = {1:2,3:4,5:6}
- d2 = {2:3,4:5,6:7}
- d3 = {3:4,5:6,7:8}
- d4 = {4:5,6:7,8:9}
- d5 = {6:7,8:9,10:11}
-
- d1 = {}
- d2 = {}
- d3 = {}
- d4 = {}
- d5 = {}
-
- d1 = {1:2,3:4,5:6}
- d2 = {2:3,4:5,6:7}
- d3 = {3:4,5:6,7:8}
- d4 = {4:5,6:7,8:9}
- d5 = {6:7,8:9,10:11}
-
- def calibrate(self):
-
- for i in range(self.rounds):
- pass
-
-class DictWithStringKeys(Test):
-
- version = 2.0
- operations = 5*(6 + 6)
- rounds = 200000
-
- def test(self):
-
- d = {}
-
- for i in range(self.rounds):
-
- d['abc'] = 1
- d['def'] = 2
- d['ghi'] = 3
- d['jkl'] = 4
- d['mno'] = 5
- d['pqr'] = 6
-
- d['abc']
- d['def']
- d['ghi']
- d['jkl']
- d['mno']
- d['pqr']
-
- d['abc'] = 1
- d['def'] = 2
- d['ghi'] = 3
- d['jkl'] = 4
- d['mno'] = 5
- d['pqr'] = 6
-
- d['abc']
- d['def']
- d['ghi']
- d['jkl']
- d['mno']
- d['pqr']
-
- d['abc'] = 1
- d['def'] = 2
- d['ghi'] = 3
- d['jkl'] = 4
- d['mno'] = 5
- d['pqr'] = 6
-
- d['abc']
- d['def']
- d['ghi']
- d['jkl']
- d['mno']
- d['pqr']
-
- d['abc'] = 1
- d['def'] = 2
- d['ghi'] = 3
- d['jkl'] = 4
- d['mno'] = 5
- d['pqr'] = 6
-
- d['abc']
- d['def']
- d['ghi']
- d['jkl']
- d['mno']
- d['pqr']
-
- d['abc'] = 1
- d['def'] = 2
- d['ghi'] = 3
- d['jkl'] = 4
- d['mno'] = 5
- d['pqr'] = 6
-
- d['abc']
- d['def']
- d['ghi']
- d['jkl']
- d['mno']
- d['pqr']
-
- def calibrate(self):
-
- d = {}
-
- for i in range(self.rounds):
- pass
-
-class DictWithFloatKeys(Test):
-
- version = 2.0
- operations = 5*(6 + 6)
- rounds = 150000
-
- def test(self):
-
- d = {}
-
- for i in range(self.rounds):
-
- d[1.234] = 1
- d[2.345] = 2
- d[3.456] = 3
- d[4.567] = 4
- d[5.678] = 5
- d[6.789] = 6
-
- d[1.234]
- d[2.345]
- d[3.456]
- d[4.567]
- d[5.678]
- d[6.789]
-
- d[1.234] = 1
- d[2.345] = 2
- d[3.456] = 3
- d[4.567] = 4
- d[5.678] = 5
- d[6.789] = 6
-
- d[1.234]
- d[2.345]
- d[3.456]
- d[4.567]
- d[5.678]
- d[6.789]
-
- d[1.234] = 1
- d[2.345] = 2
- d[3.456] = 3
- d[4.567] = 4
- d[5.678] = 5
- d[6.789] = 6
-
- d[1.234]
- d[2.345]
- d[3.456]
- d[4.567]
- d[5.678]
- d[6.789]
-
- d[1.234] = 1
- d[2.345] = 2
- d[3.456] = 3
- d[4.567] = 4
- d[5.678] = 5
- d[6.789] = 6
-
- d[1.234]
- d[2.345]
- d[3.456]
- d[4.567]
- d[5.678]
- d[6.789]
-
- d[1.234] = 1
- d[2.345] = 2
- d[3.456] = 3
- d[4.567] = 4
- d[5.678] = 5
- d[6.789] = 6
-
- d[1.234]
- d[2.345]
- d[3.456]
- d[4.567]
- d[5.678]
- d[6.789]
-
- def calibrate(self):
-
- d = {}
-
- for i in range(self.rounds):
- pass
-
-class DictWithIntegerKeys(Test):
-
- version = 2.0
- operations = 5*(6 + 6)
- rounds = 200000
-
- def test(self):
-
- d = {}
-
- for i in range(self.rounds):
-
- d[1] = 1
- d[2] = 2
- d[3] = 3
- d[4] = 4
- d[5] = 5
- d[6] = 6
-
- d[1]
- d[2]
- d[3]
- d[4]
- d[5]
- d[6]
-
- d[1] = 1
- d[2] = 2
- d[3] = 3
- d[4] = 4
- d[5] = 5
- d[6] = 6
-
- d[1]
- d[2]
- d[3]
- d[4]
- d[5]
- d[6]
-
- d[1] = 1
- d[2] = 2
- d[3] = 3
- d[4] = 4
- d[5] = 5
- d[6] = 6
-
- d[1]
- d[2]
- d[3]
- d[4]
- d[5]
- d[6]
-
- d[1] = 1
- d[2] = 2
- d[3] = 3
- d[4] = 4
- d[5] = 5
- d[6] = 6
-
- d[1]
- d[2]
- d[3]
- d[4]
- d[5]
- d[6]
-
- d[1] = 1
- d[2] = 2
- d[3] = 3
- d[4] = 4
- d[5] = 5
- d[6] = 6
-
- d[1]
- d[2]
- d[3]
- d[4]
- d[5]
- d[6]
-
- def calibrate(self):
-
- d = {}
-
- for i in range(self.rounds):
- pass
-
-class SimpleDictManipulation(Test):
-
- version = 2.0
- operations = 5*(6 + 6 + 6 + 6)
- rounds = 100000
-
- def test(self):
-
- d = {}
- has_key = lambda key: key in d
-
- for i in range(self.rounds):
-
- d[0] = 3
- d[1] = 4
- d[2] = 5
- d[3] = 3
- d[4] = 4
- d[5] = 5
-
- x = d[0]
- x = d[1]
- x = d[2]
- x = d[3]
- x = d[4]
- x = d[5]
-
- has_key(0)
- has_key(2)
- has_key(4)
- has_key(6)
- has_key(8)
- has_key(10)
-
- del d[0]
- del d[1]
- del d[2]
- del d[3]
- del d[4]
- del d[5]
-
- d[0] = 3
- d[1] = 4
- d[2] = 5
- d[3] = 3
- d[4] = 4
- d[5] = 5
-
- x = d[0]
- x = d[1]
- x = d[2]
- x = d[3]
- x = d[4]
- x = d[5]
-
- has_key(0)
- has_key(2)
- has_key(4)
- has_key(6)
- has_key(8)
- has_key(10)
-
- del d[0]
- del d[1]
- del d[2]
- del d[3]
- del d[4]
- del d[5]
-
- d[0] = 3
- d[1] = 4
- d[2] = 5
- d[3] = 3
- d[4] = 4
- d[5] = 5
-
- x = d[0]
- x = d[1]
- x = d[2]
- x = d[3]
- x = d[4]
- x = d[5]
-
- has_key(0)
- has_key(2)
- has_key(4)
- has_key(6)
- has_key(8)
- has_key(10)
-
- del d[0]
- del d[1]
- del d[2]
- del d[3]
- del d[4]
- del d[5]
-
- d[0] = 3
- d[1] = 4
- d[2] = 5
- d[3] = 3
- d[4] = 4
- d[5] = 5
-
- x = d[0]
- x = d[1]
- x = d[2]
- x = d[3]
- x = d[4]
- x = d[5]
-
- has_key(0)
- has_key(2)
- has_key(4)
- has_key(6)
- has_key(8)
- has_key(10)
-
- del d[0]
- del d[1]
- del d[2]
- del d[3]
- del d[4]
- del d[5]
-
- d[0] = 3
- d[1] = 4
- d[2] = 5
- d[3] = 3
- d[4] = 4
- d[5] = 5
-
- x = d[0]
- x = d[1]
- x = d[2]
- x = d[3]
- x = d[4]
- x = d[5]
-
- has_key(0)
- has_key(2)
- has_key(4)
- has_key(6)
- has_key(8)
- has_key(10)
-
- del d[0]
- del d[1]
- del d[2]
- del d[3]
- del d[4]
- del d[5]
-
- def calibrate(self):
-
- d = {}
- has_key = lambda key: key in d
-
- for i in range(self.rounds):
- pass
+++ /dev/null
-from pybench import Test
-
-class TryRaiseExcept(Test):
-
- version = 2.0
- operations = 2 + 3 + 3
- rounds = 80000
-
- def test(self):
-
- error = ValueError
-
- for i in range(self.rounds):
- try:
- raise error
- except:
- pass
- try:
- raise error
- except:
- pass
- try:
- raise error("something")
- except:
- pass
- try:
- raise error("something")
- except:
- pass
- try:
- raise error("something")
- except:
- pass
- try:
- raise error("something")
- except:
- pass
- try:
- raise error("something")
- except:
- pass
- try:
- raise error("something")
- except:
- pass
-
- def calibrate(self):
-
- error = ValueError
-
- for i in range(self.rounds):
- pass
-
-
-class TryExcept(Test):
-
- version = 2.0
- operations = 15 * 10
- rounds = 150000
-
- def test(self):
-
- for i in range(self.rounds):
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
-
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
-
-
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
-
-
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
-
-
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
-
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
-
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
-
-
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
-
-
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
-
-
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
-
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
-
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
-
-
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
-
-
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
-
-
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
- try:
- pass
- except:
- pass
-
- def calibrate(self):
-
- for i in range(self.rounds):
- pass
-
-### Test to make Fredrik happy...
-
-if __name__ == '__main__':
- import timeit
- timeit.TestClass = TryRaiseExcept
- timeit.main(['-s', 'test = TestClass(); test.rounds = 1000',
- 'test.test()'])
+++ /dev/null
-from pybench import Test
-
-# First imports:
-import os
-import package.submodule
-
-class SecondImport(Test):
-
- version = 2.0
- operations = 5 * 5
- rounds = 40000
-
- def test(self):
-
- for i in range(self.rounds):
- import os
- import os
- import os
- import os
- import os
-
- import os
- import os
- import os
- import os
- import os
-
- import os
- import os
- import os
- import os
- import os
-
- import os
- import os
- import os
- import os
- import os
-
- import os
- import os
- import os
- import os
- import os
-
- def calibrate(self):
-
- for i in range(self.rounds):
- pass
-
-
-class SecondPackageImport(Test):
-
- version = 2.0
- operations = 5 * 5
- rounds = 40000
-
- def test(self):
-
- for i in range(self.rounds):
- import package
- import package
- import package
- import package
- import package
-
- import package
- import package
- import package
- import package
- import package
-
- import package
- import package
- import package
- import package
- import package
-
- import package
- import package
- import package
- import package
- import package
-
- import package
- import package
- import package
- import package
- import package
-
- def calibrate(self):
-
- for i in range(self.rounds):
- pass
-
-class SecondSubmoduleImport(Test):
-
- version = 2.0
- operations = 5 * 5
- rounds = 40000
-
- def test(self):
-
- for i in range(self.rounds):
- import package.submodule
- import package.submodule
- import package.submodule
- import package.submodule
- import package.submodule
-
- import package.submodule
- import package.submodule
- import package.submodule
- import package.submodule
- import package.submodule
-
- import package.submodule
- import package.submodule
- import package.submodule
- import package.submodule
- import package.submodule
-
- import package.submodule
- import package.submodule
- import package.submodule
- import package.submodule
- import package.submodule
-
- import package.submodule
- import package.submodule
- import package.submodule
- import package.submodule
- import package.submodule
-
- def calibrate(self):
-
- for i in range(self.rounds):
- pass
+++ /dev/null
-from pybench import Test
-
-class CreateInstances(Test):
-
- version = 2.0
- operations = 3 + 7 + 4
- rounds = 80000
-
- def test(self):
-
- class c:
- pass
-
- class d:
- def __init__(self,a,b,c):
- self.a = a
- self.b = b
- self.c = c
-
- class e:
- def __init__(self,a,b,c=4):
- self.a = a
- self.b = b
- self.c = c
- self.d = a
- self.e = b
- self.f = c
-
- for i in range(self.rounds):
- o = c()
- o1 = c()
- o2 = c()
- p = d(i,i,3)
- p1 = d(i,i,3)
- p2 = d(i,3,3)
- p3 = d(3,i,3)
- p4 = d(i,i,i)
- p5 = d(3,i,3)
- p6 = d(i,i,i)
- q = e(i,i,3)
- q1 = e(i,i,3)
- q2 = e(i,i,3)
- q3 = e(i,i)
-
- def calibrate(self):
-
- class c:
- pass
-
- class d:
- def __init__(self,a,b,c):
- self.a = a
- self.b = b
- self.c = c
-
- class e:
- def __init__(self,a,b,c=4):
- self.a = a
- self.b = b
- self.c = c
- self.d = a
- self.e = b
- self.f = c
-
- for i in range(self.rounds):
- pass
+++ /dev/null
-pybench License
----------------
-
-This copyright notice and license applies to all files in the pybench
-directory of the pybench distribution.
-
-Copyright (c), 1997-2006, Marc-Andre Lemburg (mal@lemburg.com)
-Copyright (c), 2000-2006, eGenix.com Software GmbH (info@egenix.com)
-
- All Rights Reserved.
-
-Permission to use, copy, modify, and distribute this software and its
-documentation for any purpose and without fee or royalty is hereby
-granted, provided that the above copyright notice appear in all copies
-and that both that copyright notice and this permission notice appear
-in supporting documentation or portions thereof, including
-modifications, that you make.
-
-THE AUTHOR MARC-ANDRE LEMBURG DISCLAIMS ALL WARRANTIES WITH REGARD TO
-THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
-FITNESS, IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL,
-INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING
-FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
-NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
-WITH THE USE OR PERFORMANCE OF THIS SOFTWARE !
+++ /dev/null
-from pybench import Test
-
-class SimpleListManipulation(Test):
-
- version = 2.0
- operations = 5* (6 + 6 + 6)
- rounds = 130000
-
- def test(self):
-
- l = []
- append = l.append
-
- for i in range(self.rounds):
-
- append(2)
- append(3)
- append(4)
- append(2)
- append(3)
- append(4)
-
- l[0] = 3
- l[1] = 4
- l[2] = 5
- l[3] = 3
- l[4] = 4
- l[5] = 5
-
- x = l[0]
- x = l[1]
- x = l[2]
- x = l[3]
- x = l[4]
- x = l[5]
-
- append(2)
- append(3)
- append(4)
- append(2)
- append(3)
- append(4)
-
- l[0] = 3
- l[1] = 4
- l[2] = 5
- l[3] = 3
- l[4] = 4
- l[5] = 5
-
- x = l[0]
- x = l[1]
- x = l[2]
- x = l[3]
- x = l[4]
- x = l[5]
-
- append(2)
- append(3)
- append(4)
- append(2)
- append(3)
- append(4)
-
- l[0] = 3
- l[1] = 4
- l[2] = 5
- l[3] = 3
- l[4] = 4
- l[5] = 5
-
- x = l[0]
- x = l[1]
- x = l[2]
- x = l[3]
- x = l[4]
- x = l[5]
-
- append(2)
- append(3)
- append(4)
- append(2)
- append(3)
- append(4)
-
- l[0] = 3
- l[1] = 4
- l[2] = 5
- l[3] = 3
- l[4] = 4
- l[5] = 5
-
- x = l[0]
- x = l[1]
- x = l[2]
- x = l[3]
- x = l[4]
- x = l[5]
-
- append(2)
- append(3)
- append(4)
- append(2)
- append(3)
- append(4)
-
- l[0] = 3
- l[1] = 4
- l[2] = 5
- l[3] = 3
- l[4] = 4
- l[5] = 5
-
- x = l[0]
- x = l[1]
- x = l[2]
- x = l[3]
- x = l[4]
- x = l[5]
-
- if len(l) > 10000:
- # cut down the size
- del l[:]
-
- def calibrate(self):
-
- l = []
- append = l.append
-
- for i in range(self.rounds):
- pass
-
-class ListSlicing(Test):
-
- version = 2.0
- operations = 25*(3+1+2+1)
- rounds = 800
-
- def test(self):
-
- n = list(range(100))
- r = list(range(25))
-
- for i in range(self.rounds):
-
- l = n[:]
-
- for j in r:
-
- m = l[50:]
- m = l[:25]
- m = l[50:55]
- l[:3] = n
- m = l[:-1]
- m = l[1:]
- l[-1:] = n
-
- def calibrate(self):
-
- n = list(range(100))
- r = list(range(25))
-
- for i in range(self.rounds):
- for j in r:
- pass
-
-class SmallLists(Test):
-
- version = 2.0
- operations = 5*(1+ 6 + 6 + 3 + 1)
- rounds = 80000
-
- def test(self):
-
- for i in range(self.rounds):
-
- l = []
-
- append = l.append
- append(2)
- append(3)
- append(4)
- append(2)
- append(3)
- append(4)
-
- l[0] = 3
- l[1] = 4
- l[2] = 5
- l[3] = 3
- l[4] = 4
- l[5] = 5
-
- l[:3] = [1,2,3]
- m = l[:-1]
- m = l[1:]
-
- l[-1:] = [4,5,6]
-
- l = []
-
- append = l.append
- append(2)
- append(3)
- append(4)
- append(2)
- append(3)
- append(4)
-
- l[0] = 3
- l[1] = 4
- l[2] = 5
- l[3] = 3
- l[4] = 4
- l[5] = 5
-
- l[:3] = [1,2,3]
- m = l[:-1]
- m = l[1:]
-
- l[-1:] = [4,5,6]
-
- l = []
-
- append = l.append
- append(2)
- append(3)
- append(4)
- append(2)
- append(3)
- append(4)
-
- l[0] = 3
- l[1] = 4
- l[2] = 5
- l[3] = 3
- l[4] = 4
- l[5] = 5
-
- l[:3] = [1,2,3]
- m = l[:-1]
- m = l[1:]
-
- l[-1:] = [4,5,6]
-
- l = []
-
- append = l.append
- append(2)
- append(3)
- append(4)
- append(2)
- append(3)
- append(4)
-
- l[0] = 3
- l[1] = 4
- l[2] = 5
- l[3] = 3
- l[4] = 4
- l[5] = 5
-
- l[:3] = [1,2,3]
- m = l[:-1]
- m = l[1:]
-
- l[-1:] = [4,5,6]
-
- l = []
-
- append = l.append
- append(2)
- append(3)
- append(4)
- append(2)
- append(3)
- append(4)
-
- l[0] = 3
- l[1] = 4
- l[2] = 5
- l[3] = 3
- l[4] = 4
- l[5] = 5
-
- l[:3] = [1,2,3]
- m = l[:-1]
- m = l[1:]
-
- l[-1:] = [4,5,6]
-
- def calibrate(self):
-
- for i in range(self.rounds):
- pass
-
-class SimpleListComprehensions(Test):
-
- version = 2.0
- operations = 6
- rounds = 20000
-
- def test(self):
-
- n = list(range(10)) * 10
-
- for i in range(self.rounds):
- l = [x for x in n]
- l = [x for x in n if x]
- l = [x for x in n if not x]
-
- l = [x for x in n]
- l = [x for x in n if x]
- l = [x for x in n if not x]
-
- def calibrate(self):
-
- n = list(range(10)) * 10
-
- for i in range(self.rounds):
- pass
-
-class NestedListComprehensions(Test):
-
- version = 2.0
- operations = 6
- rounds = 20000
-
- def test(self):
-
- m = list(range(10))
- n = list(range(10))
-
- for i in range(self.rounds):
- l = [x for x in n for y in m]
- l = [y for x in n for y in m]
-
- l = [x for x in n for y in m if y]
- l = [y for x in n for y in m if x]
-
- l = [x for x in n for y in m if not y]
- l = [y for x in n for y in m if not x]
-
- def calibrate(self):
-
- m = list(range(10))
- n = list(range(10))
-
- for i in range(self.rounds):
- pass
+++ /dev/null
-from pybench import Test
-
-class SpecialClassAttribute(Test):
-
- version = 2.0
- operations = 5*(12 + 12)
- rounds = 100000
-
- def test(self):
-
- class c:
- pass
-
- for i in range(self.rounds):
-
- c.__a = 2
- c.__b = 3
- c.__c = 4
-
- c.__a = 2
- c.__b = 3
- c.__c = 4
-
- c.__a = 2
- c.__b = 3
- c.__c = 4
-
- c.__a = 2
- c.__b = 3
- c.__c = 4
-
- x = c.__a
- x = c.__b
- x = c.__c
-
- x = c.__a
- x = c.__b
- x = c.__c
-
- x = c.__a
- x = c.__b
- x = c.__c
-
- x = c.__a
- x = c.__b
- x = c.__c
-
- c.__a = 2
- c.__b = 3
- c.__c = 4
-
- c.__a = 2
- c.__b = 3
- c.__c = 4
-
- c.__a = 2
- c.__b = 3
- c.__c = 4
-
- c.__a = 2
- c.__b = 3
- c.__c = 4
-
- x = c.__a
- x = c.__b
- x = c.__c
-
- x = c.__a
- x = c.__b
- x = c.__c
-
- x = c.__a
- x = c.__b
- x = c.__c
-
- x = c.__a
- x = c.__b
- x = c.__c
-
- c.__a = 2
- c.__b = 3
- c.__c = 4
-
- c.__a = 2
- c.__b = 3
- c.__c = 4
-
- c.__a = 2
- c.__b = 3
- c.__c = 4
-
- c.__a = 2
- c.__b = 3
- c.__c = 4
-
- x = c.__a
- x = c.__b
- x = c.__c
-
- x = c.__a
- x = c.__b
- x = c.__c
-
- x = c.__a
- x = c.__b
- x = c.__c
-
- x = c.__a
- x = c.__b
- x = c.__c
-
- c.__a = 2
- c.__b = 3
- c.__c = 4
-
- c.__a = 2
- c.__b = 3
- c.__c = 4
-
- c.__a = 2
- c.__b = 3
- c.__c = 4
-
- c.__a = 2
- c.__b = 3
- c.__c = 4
-
- x = c.__a
- x = c.__b
- x = c.__c
-
- x = c.__a
- x = c.__b
- x = c.__c
-
- x = c.__a
- x = c.__b
- x = c.__c
-
- x = c.__a
- x = c.__b
- x = c.__c
-
- c.__a = 2
- c.__b = 3
- c.__c = 4
-
- c.__a = 2
- c.__b = 3
- c.__c = 4
-
- c.__a = 2
- c.__b = 3
- c.__c = 4
-
- c.__a = 2
- c.__b = 3
- c.__c = 4
-
- x = c.__a
- x = c.__b
- x = c.__c
-
- x = c.__a
- x = c.__b
- x = c.__c
-
- x = c.__a
- x = c.__b
- x = c.__c
-
- x = c.__a
- x = c.__b
- x = c.__c
-
- def calibrate(self):
-
- class c:
- pass
-
- for i in range(self.rounds):
- pass
-
-class NormalClassAttribute(Test):
-
- version = 2.0
- operations = 5*(12 + 12)
- rounds = 100000
-
- def test(self):
-
- class c:
- pass
-
- for i in range(self.rounds):
-
- c.a = 2
- c.b = 3
- c.c = 4
-
- c.a = 2
- c.b = 3
- c.c = 4
-
- c.a = 2
- c.b = 3
- c.c = 4
-
- c.a = 2
- c.b = 3
- c.c = 4
-
-
- x = c.a
- x = c.b
- x = c.c
-
- x = c.a
- x = c.b
- x = c.c
-
- x = c.a
- x = c.b
- x = c.c
-
- x = c.a
- x = c.b
- x = c.c
-
- c.a = 2
- c.b = 3
- c.c = 4
-
- c.a = 2
- c.b = 3
- c.c = 4
-
- c.a = 2
- c.b = 3
- c.c = 4
-
- c.a = 2
- c.b = 3
- c.c = 4
-
-
- x = c.a
- x = c.b
- x = c.c
-
- x = c.a
- x = c.b
- x = c.c
-
- x = c.a
- x = c.b
- x = c.c
-
- x = c.a
- x = c.b
- x = c.c
-
- c.a = 2
- c.b = 3
- c.c = 4
-
- c.a = 2
- c.b = 3
- c.c = 4
-
- c.a = 2
- c.b = 3
- c.c = 4
-
- c.a = 2
- c.b = 3
- c.c = 4
-
-
- x = c.a
- x = c.b
- x = c.c
-
- x = c.a
- x = c.b
- x = c.c
-
- x = c.a
- x = c.b
- x = c.c
-
- x = c.a
- x = c.b
- x = c.c
-
- c.a = 2
- c.b = 3
- c.c = 4
-
- c.a = 2
- c.b = 3
- c.c = 4
-
- c.a = 2
- c.b = 3
- c.c = 4
-
- c.a = 2
- c.b = 3
- c.c = 4
-
-
- x = c.a
- x = c.b
- x = c.c
-
- x = c.a
- x = c.b
- x = c.c
-
- x = c.a
- x = c.b
- x = c.c
-
- x = c.a
- x = c.b
- x = c.c
-
- c.a = 2
- c.b = 3
- c.c = 4
-
- c.a = 2
- c.b = 3
- c.c = 4
-
- c.a = 2
- c.b = 3
- c.c = 4
-
- c.a = 2
- c.b = 3
- c.c = 4
-
-
- x = c.a
- x = c.b
- x = c.c
-
- x = c.a
- x = c.b
- x = c.c
-
- x = c.a
- x = c.b
- x = c.c
-
- x = c.a
- x = c.b
- x = c.c
-
- def calibrate(self):
-
- class c:
- pass
-
- for i in range(self.rounds):
- pass
-
-class SpecialInstanceAttribute(Test):
-
- version = 2.0
- operations = 5*(12 + 12)
- rounds = 100000
-
- def test(self):
-
- class c:
- pass
- o = c()
-
- for i in range(self.rounds):
-
- o.__a__ = 2
- o.__b__ = 3
- o.__c__ = 4
-
- o.__a__ = 2
- o.__b__ = 3
- o.__c__ = 4
-
- o.__a__ = 2
- o.__b__ = 3
- o.__c__ = 4
-
- o.__a__ = 2
- o.__b__ = 3
- o.__c__ = 4
-
-
- x = o.__a__
- x = o.__b__
- x = o.__c__
-
- x = o.__a__
- x = o.__b__
- x = o.__c__
-
- x = o.__a__
- x = o.__b__
- x = o.__c__
-
- x = o.__a__
- x = o.__b__
- x = o.__c__
-
- o.__a__ = 2
- o.__b__ = 3
- o.__c__ = 4
-
- o.__a__ = 2
- o.__b__ = 3
- o.__c__ = 4
-
- o.__a__ = 2
- o.__b__ = 3
- o.__c__ = 4
-
- o.__a__ = 2
- o.__b__ = 3
- o.__c__ = 4
-
-
- x = o.__a__
- x = o.__b__
- x = o.__c__
-
- x = o.__a__
- x = o.__b__
- x = o.__c__
-
- x = o.__a__
- x = o.__b__
- x = o.__c__
-
- x = o.__a__
- x = o.__b__
- x = o.__c__
-
- o.__a__ = 2
- o.__b__ = 3
- o.__c__ = 4
-
- o.__a__ = 2
- o.__b__ = 3
- o.__c__ = 4
-
- o.__a__ = 2
- o.__b__ = 3
- o.__c__ = 4
-
- o.__a__ = 2
- o.__b__ = 3
- o.__c__ = 4
-
-
- x = o.__a__
- x = o.__b__
- x = o.__c__
-
- x = o.__a__
- x = o.__b__
- x = o.__c__
-
- x = o.__a__
- x = o.__b__
- x = o.__c__
-
- x = o.__a__
- x = o.__b__
- x = o.__c__
-
- o.__a__ = 2
- o.__b__ = 3
- o.__c__ = 4
-
- o.__a__ = 2
- o.__b__ = 3
- o.__c__ = 4
-
- o.__a__ = 2
- o.__b__ = 3
- o.__c__ = 4
-
- o.__a__ = 2
- o.__b__ = 3
- o.__c__ = 4
-
-
- x = o.__a__
- x = o.__b__
- x = o.__c__
-
- x = o.__a__
- x = o.__b__
- x = o.__c__
-
- x = o.__a__
- x = o.__b__
- x = o.__c__
-
- x = o.__a__
- x = o.__b__
- x = o.__c__
-
- o.__a__ = 2
- o.__b__ = 3
- o.__c__ = 4
-
- o.__a__ = 2
- o.__b__ = 3
- o.__c__ = 4
-
- o.__a__ = 2
- o.__b__ = 3
- o.__c__ = 4
-
- o.__a__ = 2
- o.__b__ = 3
- o.__c__ = 4
-
-
- x = o.__a__
- x = o.__b__
- x = o.__c__
-
- x = o.__a__
- x = o.__b__
- x = o.__c__
-
- x = o.__a__
- x = o.__b__
- x = o.__c__
-
- x = o.__a__
- x = o.__b__
- x = o.__c__
-
- def calibrate(self):
-
- class c:
- pass
- o = c()
-
- for i in range(self.rounds):
- pass
-
-class NormalInstanceAttribute(Test):
-
- version = 2.0
- operations = 5*(12 + 12)
- rounds = 100000
-
- def test(self):
-
- class c:
- pass
- o = c()
-
- for i in range(self.rounds):
-
- o.a = 2
- o.b = 3
- o.c = 4
-
- o.a = 2
- o.b = 3
- o.c = 4
-
- o.a = 2
- o.b = 3
- o.c = 4
-
- o.a = 2
- o.b = 3
- o.c = 4
-
-
- x = o.a
- x = o.b
- x = o.c
-
- x = o.a
- x = o.b
- x = o.c
-
- x = o.a
- x = o.b
- x = o.c
-
- x = o.a
- x = o.b
- x = o.c
-
- o.a = 2
- o.b = 3
- o.c = 4
-
- o.a = 2
- o.b = 3
- o.c = 4
-
- o.a = 2
- o.b = 3
- o.c = 4
-
- o.a = 2
- o.b = 3
- o.c = 4
-
-
- x = o.a
- x = o.b
- x = o.c
-
- x = o.a
- x = o.b
- x = o.c
-
- x = o.a
- x = o.b
- x = o.c
-
- x = o.a
- x = o.b
- x = o.c
-
- o.a = 2
- o.b = 3
- o.c = 4
-
- o.a = 2
- o.b = 3
- o.c = 4
-
- o.a = 2
- o.b = 3
- o.c = 4
-
- o.a = 2
- o.b = 3
- o.c = 4
-
-
- x = o.a
- x = o.b
- x = o.c
-
- x = o.a
- x = o.b
- x = o.c
-
- x = o.a
- x = o.b
- x = o.c
-
- x = o.a
- x = o.b
- x = o.c
-
- o.a = 2
- o.b = 3
- o.c = 4
-
- o.a = 2
- o.b = 3
- o.c = 4
-
- o.a = 2
- o.b = 3
- o.c = 4
-
- o.a = 2
- o.b = 3
- o.c = 4
-
-
- x = o.a
- x = o.b
- x = o.c
-
- x = o.a
- x = o.b
- x = o.c
-
- x = o.a
- x = o.b
- x = o.c
-
- x = o.a
- x = o.b
- x = o.c
-
- o.a = 2
- o.b = 3
- o.c = 4
-
- o.a = 2
- o.b = 3
- o.c = 4
-
- o.a = 2
- o.b = 3
- o.c = 4
-
- o.a = 2
- o.b = 3
- o.c = 4
-
-
- x = o.a
- x = o.b
- x = o.c
-
- x = o.a
- x = o.b
- x = o.c
-
- x = o.a
- x = o.b
- x = o.c
-
- x = o.a
- x = o.b
- x = o.c
-
- def calibrate(self):
-
- class c:
- pass
- o = c()
-
- for i in range(self.rounds):
- pass
-
-class BuiltinMethodLookup(Test):
-
- version = 2.0
- operations = 5*(3*5 + 3*5)
- rounds = 70000
-
- def test(self):
-
- l = []
- d = {}
-
- for i in range(self.rounds):
-
- l.append
- l.append
- l.append
- l.append
- l.append
-
- l.insert
- l.insert
- l.insert
- l.insert
- l.insert
-
- l.sort
- l.sort
- l.sort
- l.sort
- l.sort
-
- # d.has_key
- # d.has_key
- # d.has_key
- # d.has_key
- # d.has_key
-
- d.items
- d.items
- d.items
- d.items
- d.items
-
- d.get
- d.get
- d.get
- d.get
- d.get
-
- l.append
- l.append
- l.append
- l.append
- l.append
-
- l.insert
- l.insert
- l.insert
- l.insert
- l.insert
-
- l.sort
- l.sort
- l.sort
- l.sort
- l.sort
-
- # d.has_key
- # d.has_key
- # d.has_key
- # d.has_key
- # d.has_key
-
- d.items
- d.items
- d.items
- d.items
- d.items
-
- d.get
- d.get
- d.get
- d.get
- d.get
-
- l.append
- l.append
- l.append
- l.append
- l.append
-
- l.insert
- l.insert
- l.insert
- l.insert
- l.insert
-
- l.sort
- l.sort
- l.sort
- l.sort
- l.sort
-
- # d.has_key
- # d.has_key
- # d.has_key
- # d.has_key
- # d.has_key
-
- d.items
- d.items
- d.items
- d.items
- d.items
-
- d.get
- d.get
- d.get
- d.get
- d.get
-
- l.append
- l.append
- l.append
- l.append
- l.append
-
- l.insert
- l.insert
- l.insert
- l.insert
- l.insert
-
- l.sort
- l.sort
- l.sort
- l.sort
- l.sort
-
- # d.has_key
- # d.has_key
- # d.has_key
- # d.has_key
- # d.has_key
-
- d.items
- d.items
- d.items
- d.items
- d.items
-
- d.get
- d.get
- d.get
- d.get
- d.get
-
- l.append
- l.append
- l.append
- l.append
- l.append
-
- l.insert
- l.insert
- l.insert
- l.insert
- l.insert
-
- l.sort
- l.sort
- l.sort
- l.sort
- l.sort
-
- # d.has_key
- # d.has_key
- # d.has_key
- # d.has_key
- # d.has_key
-
- d.items
- d.items
- d.items
- d.items
- d.items
-
- d.get
- d.get
- d.get
- d.get
- d.get
-
- def calibrate(self):
-
- l = []
- d = {}
-
- for i in range(self.rounds):
- pass
+++ /dev/null
-from pybench import Test
-
-# Check for new-style class support:
-try:
- class c(object):
- pass
-except NameError:
- raise ImportError
-
-###
-
-class CreateNewInstances(Test):
-
- version = 2.0
- operations = 3 + 7 + 4
- rounds = 60000
-
- def test(self):
-
- class c(object):
- pass
-
- class d(object):
- def __init__(self,a,b,c):
- self.a = a
- self.b = b
- self.c = c
-
- class e(object):
- def __init__(self,a,b,c=4):
- self.a = a
- self.b = b
- self.c = c
- self.d = a
- self.e = b
- self.f = c
-
- for i in range(self.rounds):
- o = c()
- o1 = c()
- o2 = c()
- p = d(i,i,3)
- p1 = d(i,i,3)
- p2 = d(i,3,3)
- p3 = d(3,i,3)
- p4 = d(i,i,i)
- p5 = d(3,i,3)
- p6 = d(i,i,i)
- q = e(i,i,3)
- q1 = e(i,i,3)
- q2 = e(i,i,3)
- q3 = e(i,i)
-
- def calibrate(self):
-
- class c(object):
- pass
-
- class d(object):
- def __init__(self,a,b,c):
- self.a = a
- self.b = b
- self.c = c
-
- class e(object):
- def __init__(self,a,b,c=4):
- self.a = a
- self.b = b
- self.c = c
- self.d = a
- self.e = b
- self.f = c
-
- for i in range(self.rounds):
- pass
+++ /dev/null
-from pybench import Test
-
-class CompareIntegers(Test):
-
- version = 2.0
- operations = 30 * 5
- rounds = 120000
-
- def test(self):
-
- for i in range(self.rounds):
-
- 2 < 3
- 2 > 3
- 2 == 3
- 2 > 3
- 2 < 3
-
- 2 < 3
- 2 > 3
- 2 == 3
- 2 > 3
- 2 < 3
-
- 2 < 3
- 2 > 3
- 2 == 3
- 2 > 3
- 2 < 3
-
- 2 < 3
- 2 > 3
- 2 == 3
- 2 > 3
- 2 < 3
-
- 2 < 3
- 2 > 3
- 2 == 3
- 2 > 3
- 2 < 3
-
- 2 < 3
- 2 > 3
- 2 == 3
- 2 > 3
- 2 < 3
-
- 2 < 3
- 2 > 3
- 2 == 3
- 2 > 3
- 2 < 3
-
- 2 < 3
- 2 > 3
- 2 == 3
- 2 > 3
- 2 < 3
-
- 2 < 3
- 2 > 3
- 2 == 3
- 2 > 3
- 2 < 3
-
- 2 < 3
- 2 > 3
- 2 == 3
- 2 > 3
- 2 < 3
-
- 2 < 3
- 2 > 3
- 2 == 3
- 2 > 3
- 2 < 3
-
- 2 < 3
- 2 > 3
- 2 == 3
- 2 > 3
- 2 < 3
-
- 2 < 3
- 2 > 3
- 2 == 3
- 2 > 3
- 2 < 3
-
- 2 < 3
- 2 > 3
- 2 == 3
- 2 > 3
- 2 < 3
-
- 2 < 3
- 2 > 3
- 2 == 3
- 2 > 3
- 2 < 3
-
- 2 < 3
- 2 > 3
- 2 == 3
- 2 > 3
- 2 < 3
-
- 2 < 3
- 2 > 3
- 2 == 3
- 2 > 3
- 2 < 3
-
- 2 < 3
- 2 > 3
- 2 == 3
- 2 > 3
- 2 < 3
-
- 2 < 3
- 2 > 3
- 2 == 3
- 2 > 3
- 2 < 3
-
- 2 < 3
- 2 > 3
- 2 == 3
- 2 > 3
- 2 < 3
-
- 2 < 3
- 2 > 3
- 2 == 3
- 2 > 3
- 2 < 3
-
- 2 < 3
- 2 > 3
- 2 == 3
- 2 > 3
- 2 < 3
-
- 2 < 3
- 2 > 3
- 2 == 3
- 2 > 3
- 2 < 3
-
- 2 < 3
- 2 > 3
- 2 == 3
- 2 > 3
- 2 < 3
-
- 2 < 3
- 2 > 3
- 2 == 3
- 2 > 3
- 2 < 3
-
- 2 < 3
- 2 > 3
- 2 == 3
- 2 > 3
- 2 < 3
-
- 2 < 3
- 2 > 3
- 2 == 3
- 2 > 3
- 2 < 3
-
- 2 < 3
- 2 > 3
- 2 == 3
- 2 > 3
- 2 < 3
-
- 2 < 3
- 2 > 3
- 2 == 3
- 2 > 3
- 2 < 3
-
- 2 < 3
- 2 > 3
- 2 == 3
- 2 > 3
- 2 < 3
-
- def calibrate(self):
-
- for i in range(self.rounds):
- pass
-
-
-class CompareFloats(Test):
-
- version = 2.0
- operations = 30 * 5
- rounds = 80000
-
- def test(self):
-
- for i in range(self.rounds):
-
- 2.1 < 3.31
- 2.1 > 3.31
- 2.1 == 3.31
- 2.1 > 3.31
- 2.1 < 3.31
-
- 2.1 < 3.31
- 2.1 > 3.31
- 2.1 == 3.31
- 2.1 > 3.31
- 2.1 < 3.31
-
- 2.1 < 3.31
- 2.1 > 3.31
- 2.1 == 3.31
- 2.1 > 3.31
- 2.1 < 3.31
-
- 2.1 < 3.31
- 2.1 > 3.31
- 2.1 == 3.31
- 2.1 > 3.31
- 2.1 < 3.31
-
- 2.1 < 3.31
- 2.1 > 3.31
- 2.1 == 3.31
- 2.1 > 3.31
- 2.1 < 3.31
-
- 2.1 < 3.31
- 2.1 > 3.31
- 2.1 == 3.31
- 2.1 > 3.31
- 2.1 < 3.31
-
- 2.1 < 3.31
- 2.1 > 3.31
- 2.1 == 3.31
- 2.1 > 3.31
- 2.1 < 3.31
-
- 2.1 < 3.31
- 2.1 > 3.31
- 2.1 == 3.31
- 2.1 > 3.31
- 2.1 < 3.31
-
- 2.1 < 3.31
- 2.1 > 3.31
- 2.1 == 3.31
- 2.1 > 3.31
- 2.1 < 3.31
-
- 2.1 < 3.31
- 2.1 > 3.31
- 2.1 == 3.31
- 2.1 > 3.31
- 2.1 < 3.31
-
- 2.1 < 3.31
- 2.1 > 3.31
- 2.1 == 3.31
- 2.1 > 3.31
- 2.1 < 3.31
-
- 2.1 < 3.31
- 2.1 > 3.31
- 2.1 == 3.31
- 2.1 > 3.31
- 2.1 < 3.31
-
- 2.1 < 3.31
- 2.1 > 3.31
- 2.1 == 3.31
- 2.1 > 3.31
- 2.1 < 3.31
-
- 2.1 < 3.31
- 2.1 > 3.31
- 2.1 == 3.31
- 2.1 > 3.31
- 2.1 < 3.31
-
- 2.1 < 3.31
- 2.1 > 3.31
- 2.1 == 3.31
- 2.1 > 3.31
- 2.1 < 3.31
-
- 2.1 < 3.31
- 2.1 > 3.31
- 2.1 == 3.31
- 2.1 > 3.31
- 2.1 < 3.31
-
- 2.1 < 3.31
- 2.1 > 3.31
- 2.1 == 3.31
- 2.1 > 3.31
- 2.1 < 3.31
-
- 2.1 < 3.31
- 2.1 > 3.31
- 2.1 == 3.31
- 2.1 > 3.31
- 2.1 < 3.31
-
- 2.1 < 3.31
- 2.1 > 3.31
- 2.1 == 3.31
- 2.1 > 3.31
- 2.1 < 3.31
-
- 2.1 < 3.31
- 2.1 > 3.31
- 2.1 == 3.31
- 2.1 > 3.31
- 2.1 < 3.31
-
- 2.1 < 3.31
- 2.1 > 3.31
- 2.1 == 3.31
- 2.1 > 3.31
- 2.1 < 3.31
-
- 2.1 < 3.31
- 2.1 > 3.31
- 2.1 == 3.31
- 2.1 > 3.31
- 2.1 < 3.31
-
- 2.1 < 3.31
- 2.1 > 3.31
- 2.1 == 3.31
- 2.1 > 3.31
- 2.1 < 3.31
-
- 2.1 < 3.31
- 2.1 > 3.31
- 2.1 == 3.31
- 2.1 > 3.31
- 2.1 < 3.31
-
- 2.1 < 3.31
- 2.1 > 3.31
- 2.1 == 3.31
- 2.1 > 3.31
- 2.1 < 3.31
-
- 2.1 < 3.31
- 2.1 > 3.31
- 2.1 == 3.31
- 2.1 > 3.31
- 2.1 < 3.31
-
- 2.1 < 3.31
- 2.1 > 3.31
- 2.1 == 3.31
- 2.1 > 3.31
- 2.1 < 3.31
-
- 2.1 < 3.31
- 2.1 > 3.31
- 2.1 == 3.31
- 2.1 > 3.31
- 2.1 < 3.31
-
- 2.1 < 3.31
- 2.1 > 3.31
- 2.1 == 3.31
- 2.1 > 3.31
- 2.1 < 3.31
-
- 2.1 < 3.31
- 2.1 > 3.31
- 2.1 == 3.31
- 2.1 > 3.31
- 2.1 < 3.31
-
- def calibrate(self):
-
- for i in range(self.rounds):
- pass
-
-
-class CompareFloatsIntegers(Test):
-
- version = 2.0
- operations = 30 * 5
- rounds = 60000
-
- def test(self):
-
- for i in range(self.rounds):
-
- 2.1 < 4
- 2.1 > 4
- 2.1 == 4
- 2.1 > 4
- 2.1 < 4
-
- 2.1 < 4
- 2.1 > 4
- 2.1 == 4
- 2.1 > 4
- 2.1 < 4
-
- 2.1 < 4
- 2.1 > 4
- 2.1 == 4
- 2.1 > 4
- 2.1 < 4
-
- 2.1 < 4
- 2.1 > 4
- 2.1 == 4
- 2.1 > 4
- 2.1 < 4
-
- 2.1 < 4
- 2.1 > 4
- 2.1 == 4
- 2.1 > 4
- 2.1 < 4
-
- 2.1 < 4
- 2.1 > 4
- 2.1 == 4
- 2.1 > 4
- 2.1 < 4
-
- 2.1 < 4
- 2.1 > 4
- 2.1 == 4
- 2.1 > 4
- 2.1 < 4
-
- 2.1 < 4
- 2.1 > 4
- 2.1 == 4
- 2.1 > 4
- 2.1 < 4
-
- 2.1 < 4
- 2.1 > 4
- 2.1 == 4
- 2.1 > 4
- 2.1 < 4
-
- 2.1 < 4
- 2.1 > 4
- 2.1 == 4
- 2.1 > 4
- 2.1 < 4
-
- 2.1 < 4
- 2.1 > 4
- 2.1 == 4
- 2.1 > 4
- 2.1 < 4
-
- 2.1 < 4
- 2.1 > 4
- 2.1 == 4
- 2.1 > 4
- 2.1 < 4
-
- 2.1 < 4
- 2.1 > 4
- 2.1 == 4
- 2.1 > 4
- 2.1 < 4
-
- 2.1 < 4
- 2.1 > 4
- 2.1 == 4
- 2.1 > 4
- 2.1 < 4
-
- 2.1 < 4
- 2.1 > 4
- 2.1 == 4
- 2.1 > 4
- 2.1 < 4
-
- 2.1 < 4
- 2.1 > 4
- 2.1 == 4
- 2.1 > 4
- 2.1 < 4
-
- 2.1 < 4
- 2.1 > 4
- 2.1 == 4
- 2.1 > 4
- 2.1 < 4
-
- 2.1 < 4
- 2.1 > 4
- 2.1 == 4
- 2.1 > 4
- 2.1 < 4
-
- 2.1 < 4
- 2.1 > 4
- 2.1 == 4
- 2.1 > 4
- 2.1 < 4
-
- 2.1 < 4
- 2.1 > 4
- 2.1 == 4
- 2.1 > 4
- 2.1 < 4
-
- 2.1 < 4
- 2.1 > 4
- 2.1 == 4
- 2.1 > 4
- 2.1 < 4
-
- 2.1 < 4
- 2.1 > 4
- 2.1 == 4
- 2.1 > 4
- 2.1 < 4
-
- 2.1 < 4
- 2.1 > 4
- 2.1 == 4
- 2.1 > 4
- 2.1 < 4
-
- 2.1 < 4
- 2.1 > 4
- 2.1 == 4
- 2.1 > 4
- 2.1 < 4
-
- 2.1 < 4
- 2.1 > 4
- 2.1 == 4
- 2.1 > 4
- 2.1 < 4
-
- 2.1 < 4
- 2.1 > 4
- 2.1 == 4
- 2.1 > 4
- 2.1 < 4
-
- 2.1 < 4
- 2.1 > 4
- 2.1 == 4
- 2.1 > 4
- 2.1 < 4
-
- 2.1 < 4
- 2.1 > 4
- 2.1 == 4
- 2.1 > 4
- 2.1 < 4
-
- 2.1 < 4
- 2.1 > 4
- 2.1 == 4
- 2.1 > 4
- 2.1 < 4
-
- 2.1 < 4
- 2.1 > 4
- 2.1 == 4
- 2.1 > 4
- 2.1 < 4
-
- def calibrate(self):
-
- for i in range(self.rounds):
- pass
-
-
-class CompareLongs(Test):
-
- version = 2.0
- operations = 30 * 5
- rounds = 70000
-
- def test(self):
-
- for i in range(self.rounds):
-
- 1234567890 < 3456789012345
- 1234567890 > 3456789012345
- 1234567890 == 3456789012345
- 1234567890 > 3456789012345
- 1234567890 < 3456789012345
-
- 1234567890 < 3456789012345
- 1234567890 > 3456789012345
- 1234567890 == 3456789012345
- 1234567890 > 3456789012345
- 1234567890 < 3456789012345
-
- 1234567890 < 3456789012345
- 1234567890 > 3456789012345
- 1234567890 == 3456789012345
- 1234567890 > 3456789012345
- 1234567890 < 3456789012345
-
- 1234567890 < 3456789012345
- 1234567890 > 3456789012345
- 1234567890 == 3456789012345
- 1234567890 > 3456789012345
- 1234567890 < 3456789012345
-
- 1234567890 < 3456789012345
- 1234567890 > 3456789012345
- 1234567890 == 3456789012345
- 1234567890 > 3456789012345
- 1234567890 < 3456789012345
-
- 1234567890 < 3456789012345
- 1234567890 > 3456789012345
- 1234567890 == 3456789012345
- 1234567890 > 3456789012345
- 1234567890 < 3456789012345
-
- 1234567890 < 3456789012345
- 1234567890 > 3456789012345
- 1234567890 == 3456789012345
- 1234567890 > 3456789012345
- 1234567890 < 3456789012345
-
- 1234567890 < 3456789012345
- 1234567890 > 3456789012345
- 1234567890 == 3456789012345
- 1234567890 > 3456789012345
- 1234567890 < 3456789012345
-
- 1234567890 < 3456789012345
- 1234567890 > 3456789012345
- 1234567890 == 3456789012345
- 1234567890 > 3456789012345
- 1234567890 < 3456789012345
-
- 1234567890 < 3456789012345
- 1234567890 > 3456789012345
- 1234567890 == 3456789012345
- 1234567890 > 3456789012345
- 1234567890 < 3456789012345
-
- 1234567890 < 3456789012345
- 1234567890 > 3456789012345
- 1234567890 == 3456789012345
- 1234567890 > 3456789012345
- 1234567890 < 3456789012345
-
- 1234567890 < 3456789012345
- 1234567890 > 3456789012345
- 1234567890 == 3456789012345
- 1234567890 > 3456789012345
- 1234567890 < 3456789012345
-
- 1234567890 < 3456789012345
- 1234567890 > 3456789012345
- 1234567890 == 3456789012345
- 1234567890 > 3456789012345
- 1234567890 < 3456789012345
-
- 1234567890 < 3456789012345
- 1234567890 > 3456789012345
- 1234567890 == 3456789012345
- 1234567890 > 3456789012345
- 1234567890 < 3456789012345
-
- 1234567890 < 3456789012345
- 1234567890 > 3456789012345
- 1234567890 == 3456789012345
- 1234567890 > 3456789012345
- 1234567890 < 3456789012345
-
- 1234567890 < 3456789012345
- 1234567890 > 3456789012345
- 1234567890 == 3456789012345
- 1234567890 > 3456789012345
- 1234567890 < 3456789012345
-
- 1234567890 < 3456789012345
- 1234567890 > 3456789012345
- 1234567890 == 3456789012345
- 1234567890 > 3456789012345
- 1234567890 < 3456789012345
-
- 1234567890 < 3456789012345
- 1234567890 > 3456789012345
- 1234567890 == 3456789012345
- 1234567890 > 3456789012345
- 1234567890 < 3456789012345
-
- 1234567890 < 3456789012345
- 1234567890 > 3456789012345
- 1234567890 == 3456789012345
- 1234567890 > 3456789012345
- 1234567890 < 3456789012345
-
- 1234567890 < 3456789012345
- 1234567890 > 3456789012345
- 1234567890 == 3456789012345
- 1234567890 > 3456789012345
- 1234567890 < 3456789012345
-
- 1234567890 < 3456789012345
- 1234567890 > 3456789012345
- 1234567890 == 3456789012345
- 1234567890 > 3456789012345
- 1234567890 < 3456789012345
-
- 1234567890 < 3456789012345
- 1234567890 > 3456789012345
- 1234567890 == 3456789012345
- 1234567890 > 3456789012345
- 1234567890 < 3456789012345
-
- 1234567890 < 3456789012345
- 1234567890 > 3456789012345
- 1234567890 == 3456789012345
- 1234567890 > 3456789012345
- 1234567890 < 3456789012345
-
- 1234567890 < 3456789012345
- 1234567890 > 3456789012345
- 1234567890 == 3456789012345
- 1234567890 > 3456789012345
- 1234567890 < 3456789012345
-
- 1234567890 < 3456789012345
- 1234567890 > 3456789012345
- 1234567890 == 3456789012345
- 1234567890 > 3456789012345
- 1234567890 < 3456789012345
-
- 1234567890 < 3456789012345
- 1234567890 > 3456789012345
- 1234567890 == 3456789012345
- 1234567890 > 3456789012345
- 1234567890 < 3456789012345
-
- 1234567890 < 3456789012345
- 1234567890 > 3456789012345
- 1234567890 == 3456789012345
- 1234567890 > 3456789012345
- 1234567890 < 3456789012345
-
- 1234567890 < 3456789012345
- 1234567890 > 3456789012345
- 1234567890 == 3456789012345
- 1234567890 > 3456789012345
- 1234567890 < 3456789012345
-
- 1234567890 < 3456789012345
- 1234567890 > 3456789012345
- 1234567890 == 3456789012345
- 1234567890 > 3456789012345
- 1234567890 < 3456789012345
-
- 1234567890 < 3456789012345
- 1234567890 > 3456789012345
- 1234567890 == 3456789012345
- 1234567890 > 3456789012345
- 1234567890 < 3456789012345
-
- def calibrate(self):
-
- for i in range(self.rounds):
- pass
+++ /dev/null
-________________________________________________________________________
-
-PYBENCH - A Python Benchmark Suite
-________________________________________________________________________
-
- Extendable suite of low-level benchmarks for measuring
- the performance of the Python implementation
- (interpreter, compiler or VM).
-
-pybench is a collection of tests that provides a standardized way to
-measure the performance of Python implementations. It takes a very
-close look at different aspects of Python programs and let's you
-decide which factors are more important to you than others, rather
-than wrapping everything up in one number, like the other performance
-tests do (e.g. pystone which is included in the Python Standard
-Library).
-
-pybench has been used in the past by several Python developers to
-track down performance bottlenecks or to demonstrate the impact of
-optimizations and new features in Python.
-
-The command line interface for pybench is the file pybench.py. Run
-this script with option '--help' to get a listing of the possible
-options. Without options, pybench will simply execute the benchmark
-and then print out a report to stdout.
-
-
-Micro-Manual
-------------
-
-Run 'pybench.py -h' to see the help screen. Run 'pybench.py' to run
-the benchmark suite using default settings and 'pybench.py -f <file>'
-to have it store the results in a file too.
-
-It is usually a good idea to run pybench.py multiple times to see
-whether the environment, timers and benchmark run-times are suitable
-for doing benchmark tests.
-
-You can use the comparison feature of pybench.py ('pybench.py -c
-<file>') to check how well the system behaves in comparison to a
-reference run.
-
-If the differences are well below 10% for each test, then you have a
-system that is good for doing benchmark testings. Of you get random
-differences of more than 10% or significant differences between the
-values for minimum and average time, then you likely have some
-background processes running which cause the readings to become
-inconsistent. Examples include: web-browsers, email clients, RSS
-readers, music players, backup programs, etc.
-
-If you are only interested in a few tests of the whole suite, you can
-use the filtering option, e.g. 'pybench.py -t string' will only
-run/show the tests that have 'string' in their name.
-
-This is the current output of pybench.py --help:
-
-"""
-------------------------------------------------------------------------
-PYBENCH - a benchmark test suite for Python interpreters/compilers.
-------------------------------------------------------------------------
-
-Synopsis:
- pybench.py [option] files...
-
-Options and default settings:
- -n arg number of rounds (10)
- -f arg save benchmark to file arg ()
- -c arg compare benchmark with the one in file arg ()
- -s arg show benchmark in file arg, then exit ()
- -w arg set warp factor to arg (10)
- -t arg run only tests with names matching arg ()
- -C arg set the number of calibration runs to arg (20)
- -d hide noise in comparisons (0)
- -v verbose output (not recommended) (0)
- --with-gc enable garbage collection (0)
- --with-syscheck use default sys check interval (0)
- --timer arg use given timer (time.time)
- -h show this help text
- --help show this help text
- --debug enable debugging
- --copyright show copyright
- --examples show examples of usage
-
-Version:
- 2.1
-
-The normal operation is to run the suite and display the
-results. Use -f to save them for later reuse or comparisons.
-
-Available timers:
-
- time.time
- time.clock
- systimes.processtime
-
-Examples:
-
-python3.0 pybench.py -f p30.pybench
-python3.1 pybench.py -f p31.pybench
-python pybench.py -s p31.pybench -c p30.pybench
-"""
-
-License
--------
-
-See LICENSE file.
-
-
-Sample output
--------------
-
-"""
--------------------------------------------------------------------------------
-PYBENCH 2.1
--------------------------------------------------------------------------------
-* using CPython 3.0
-* disabled garbage collection
-* system check interval set to maximum: 2147483647
-* using timer: time.time
-
-Calibrating tests. Please wait...
-
-Running 10 round(s) of the suite at warp factor 10:
-
-* Round 1 done in 6.388 seconds.
-* Round 2 done in 6.485 seconds.
-* Round 3 done in 6.786 seconds.
-...
-* Round 10 done in 6.546 seconds.
-
--------------------------------------------------------------------------------
-Benchmark: 2006-06-12 12:09:25
--------------------------------------------------------------------------------
-
- Rounds: 10
- Warp: 10
- Timer: time.time
-
- Machine Details:
- Platform ID: Linux-2.6.8-24.19-default-x86_64-with-SuSE-9.2-x86-64
- Processor: x86_64
-
- Python:
- Implementation: CPython
- Executable: /usr/local/bin/python
- Version: 3.0
- Compiler: GCC 3.3.4 (pre 3.3.5 20040809)
- Bits: 64bit
- Build: Oct 1 2005 15:24:35 (#1)
- Unicode: UCS2
-
-
-Test minimum average operation overhead
--------------------------------------------------------------------------------
- BuiltinFunctionCalls: 126ms 145ms 0.28us 0.274ms
- BuiltinMethodLookup: 124ms 130ms 0.12us 0.316ms
- CompareFloats: 109ms 110ms 0.09us 0.361ms
- CompareFloatsIntegers: 100ms 104ms 0.12us 0.271ms
- CompareIntegers: 137ms 138ms 0.08us 0.542ms
- CompareInternedStrings: 124ms 127ms 0.08us 1.367ms
- CompareLongs: 100ms 104ms 0.10us 0.316ms
- CompareStrings: 111ms 115ms 0.12us 0.929ms
- CompareUnicode: 108ms 128ms 0.17us 0.693ms
- ConcatStrings: 142ms 155ms 0.31us 0.562ms
- ConcatUnicode: 119ms 127ms 0.42us 0.384ms
- CreateInstances: 123ms 128ms 1.14us 0.367ms
- CreateNewInstances: 121ms 126ms 1.49us 0.335ms
- CreateStringsWithConcat: 130ms 135ms 0.14us 0.916ms
- CreateUnicodeWithConcat: 130ms 135ms 0.34us 0.361ms
- DictCreation: 108ms 109ms 0.27us 0.361ms
- DictWithFloatKeys: 149ms 153ms 0.17us 0.678ms
- DictWithIntegerKeys: 124ms 126ms 0.11us 0.915ms
- DictWithStringKeys: 114ms 117ms 0.10us 0.905ms
- ForLoops: 110ms 111ms 4.46us 0.063ms
- IfThenElse: 118ms 119ms 0.09us 0.685ms
- ListSlicing: 116ms 120ms 8.59us 0.103ms
- NestedForLoops: 125ms 137ms 0.09us 0.019ms
- NormalClassAttribute: 124ms 136ms 0.11us 0.457ms
- NormalInstanceAttribute: 110ms 117ms 0.10us 0.454ms
- PythonFunctionCalls: 107ms 113ms 0.34us 0.271ms
- PythonMethodCalls: 140ms 149ms 0.66us 0.141ms
- Recursion: 156ms 166ms 3.32us 0.452ms
- SecondImport: 112ms 118ms 1.18us 0.180ms
- SecondPackageImport: 118ms 127ms 1.27us 0.180ms
- SecondSubmoduleImport: 140ms 151ms 1.51us 0.180ms
- SimpleComplexArithmetic: 128ms 139ms 0.16us 0.361ms
- SimpleDictManipulation: 134ms 136ms 0.11us 0.452ms
- SimpleFloatArithmetic: 110ms 113ms 0.09us 0.571ms
- SimpleIntFloatArithmetic: 106ms 111ms 0.08us 0.548ms
- SimpleIntegerArithmetic: 106ms 109ms 0.08us 0.544ms
- SimpleListManipulation: 103ms 113ms 0.10us 0.587ms
- SimpleLongArithmetic: 112ms 118ms 0.18us 0.271ms
- SmallLists: 105ms 116ms 0.17us 0.366ms
- SmallTuples: 108ms 128ms 0.24us 0.406ms
- SpecialClassAttribute: 119ms 136ms 0.11us 0.453ms
- SpecialInstanceAttribute: 143ms 155ms 0.13us 0.454ms
- StringMappings: 115ms 121ms 0.48us 0.405ms
- StringPredicates: 120ms 129ms 0.18us 2.064ms
- StringSlicing: 111ms 127ms 0.23us 0.781ms
- TryExcept: 125ms 126ms 0.06us 0.681ms
- TryRaiseExcept: 133ms 137ms 2.14us 0.361ms
- TupleSlicing: 117ms 120ms 0.46us 0.066ms
- UnicodeMappings: 156ms 160ms 4.44us 0.429ms
- UnicodePredicates: 117ms 121ms 0.22us 2.487ms
- UnicodeProperties: 115ms 153ms 0.38us 2.070ms
- UnicodeSlicing: 126ms 129ms 0.26us 0.689ms
--------------------------------------------------------------------------------
-Totals: 6283ms 6673ms
-"""
-________________________________________________________________________
-
-Writing New Tests
-________________________________________________________________________
-
-pybench tests are simple modules defining one or more pybench.Test
-subclasses.
-
-Writing a test essentially boils down to providing two methods:
-.test() which runs .rounds number of .operations test operations each
-and .calibrate() which does the same except that it doesn't actually
-execute the operations.
-
-
-Here's an example:
-------------------
-
-from pybench import Test
-
-class IntegerCounting(Test):
-
- # Version number of the test as float (x.yy); this is important
- # for comparisons of benchmark runs - tests with unequal version
- # number will not get compared.
- version = 1.0
-
- # The number of abstract operations done in each round of the
- # test. An operation is the basic unit of what you want to
- # measure. The benchmark will output the amount of run-time per
- # operation. Note that in order to raise the measured timings
- # significantly above noise level, it is often required to repeat
- # sets of operations more than once per test round. The measured
- # overhead per test round should be less than 1 second.
- operations = 20
-
- # Number of rounds to execute per test run. This should be
- # adjusted to a figure that results in a test run-time of between
- # 1-2 seconds (at warp 1).
- rounds = 100000
-
- def test(self):
-
- """ Run the test.
-
- The test needs to run self.rounds executing
- self.operations number of operations each.
-
- """
- # Init the test
- a = 1
-
- # Run test rounds
- #
- for i in range(self.rounds):
-
- # Repeat the operations per round to raise the run-time
- # per operation significantly above the noise level of the
- # for-loop overhead.
-
- # Execute 20 operations (a += 1):
- a += 1
- a += 1
- a += 1
- a += 1
- a += 1
- a += 1
- a += 1
- a += 1
- a += 1
- a += 1
- a += 1
- a += 1
- a += 1
- a += 1
- a += 1
- a += 1
- a += 1
- a += 1
- a += 1
- a += 1
-
- def calibrate(self):
-
- """ Calibrate the test.
-
- This method should execute everything that is needed to
- setup and run the test - except for the actual operations
- that you intend to measure. pybench uses this method to
- measure the test implementation overhead.
-
- """
- # Init the test
- a = 1
-
- # Run test rounds (without actually doing any operation)
- for i in range(self.rounds):
-
- # Skip the actual execution of the operations, since we
- # only want to measure the test's administration overhead.
- pass
-
-Registering a new test module
------------------------------
-
-To register a test module with pybench, the classes need to be
-imported into the pybench.Setup module. pybench will then scan all the
-symbols defined in that module for subclasses of pybench.Test and
-automatically add them to the benchmark suite.
-
-
-Breaking Comparability
-----------------------
-
-If a change is made to any individual test that means it is no
-longer strictly comparable with previous runs, the '.version' class
-variable should be updated. Therefafter, comparisons with previous
-versions of the test will list as "n/a" to reflect the change.
-
-
-Version History
----------------
-
- 2.1: made some minor changes for compatibility with Python 3.0:
- - replaced cmp with divmod and range with max in Calls.py
- (cmp no longer exists in 3.0, and range is a list in
- Python 2.x and an iterator in Python 3.x)
-
- 2.0: rewrote parts of pybench which resulted in more repeatable
- timings:
- - made timer a parameter
- - changed the platform default timer to use high-resolution
- timers rather than process timers (which have a much lower
- resolution)
- - added option to select timer
- - added process time timer (using systimes.py)
- - changed to use min() as timing estimator (average
- is still taken as well to provide an idea of the difference)
- - garbage collection is turned off per default
- - sys check interval is set to the highest possible value
- - calibration is now a separate step and done using
- a different strategy that allows measuring the test
- overhead more accurately
- - modified the tests to each give a run-time of between
- 100-200ms using warp 10
- - changed default warp factor to 10 (from 20)
- - compared results with timeit.py and confirmed measurements
- - bumped all test versions to 2.0
- - updated platform.py to the latest version
- - changed the output format a bit to make it look
- nicer
- - refactored the APIs somewhat
- 1.3+: Steve Holden added the NewInstances test and the filtering
- option during the NeedForSpeed sprint; this also triggered a long
- discussion on how to improve benchmark timing and finally
- resulted in the release of 2.0
- 1.3: initial checkin into the Python SVN repository
-
-
-Have fun,
---
-Marc-Andre Lemburg
-mal@lemburg.com
+++ /dev/null
-#!python
-
-# Setup file for pybench
-#
-# This file has to import all tests to be run; it is executed as
-# Python source file, so you can do all kinds of manipulations here
-# rather than having to edit the tests themselves.
-#
-# Note: Please keep this module compatible to Python 1.5.2.
-#
-# Tests may include features in later Python versions, but these
-# should then be embedded in try-except clauses in this configuration
-# module.
-
-# Defaults
-Number_of_rounds = 10
-Warp_factor = 10
-
-# Import tests
-from Arithmetic import *
-from Calls import *
-from Constructs import *
-from Lookups import *
-from Instances import *
-try:
- from NewInstances import *
-except ImportError:
- pass
-from Lists import *
-from Tuples import *
-from Dict import *
-from Exceptions import *
-try:
- from With import *
-except SyntaxError:
- pass
-from Imports import *
-from Strings import *
-from Numbers import *
-try:
- from Unicode import *
-except (ImportError, SyntaxError):
- pass
+++ /dev/null
-from pybench import Test
-import sys
-
-try:
- intern
-except NameError:
- intern = sys.intern
-
-
-class ConcatStrings(Test):
-
- version = 2.0
- operations = 10 * 5
- rounds = 100000
-
- def test(self):
-
- # Make sure the strings are *not* interned
- s = ''.join(map(str,range(100)))
- t = ''.join(map(str,range(1,101)))
-
- for i in range(self.rounds):
- t + s
- t + s
- t + s
- t + s
- t + s
-
- t + s
- t + s
- t + s
- t + s
- t + s
-
- t + s
- t + s
- t + s
- t + s
- t + s
-
- t + s
- t + s
- t + s
- t + s
- t + s
-
- t + s
- t + s
- t + s
- t + s
- t + s
-
- t + s
- t + s
- t + s
- t + s
- t + s
-
- t + s
- t + s
- t + s
- t + s
- t + s
-
- t + s
- t + s
- t + s
- t + s
- t + s
-
- t + s
- t + s
- t + s
- t + s
- t + s
-
- t + s
- t + s
- t + s
- t + s
- t + s
-
- def calibrate(self):
-
- s = ''.join(map(str,range(100)))
- t = ''.join(map(str,range(1,101)))
-
- for i in range(self.rounds):
- pass
-
-
-class CompareStrings(Test):
-
- version = 2.0
- operations = 10 * 5
- rounds = 200000
-
- def test(self):
-
- # Make sure the strings are *not* interned
- s = ''.join(map(str,range(10)))
- t = ''.join(map(str,range(10))) + "abc"
-
- for i in range(self.rounds):
- t < s
- t > s
- t == s
- t > s
- t < s
-
- t < s
- t > s
- t == s
- t > s
- t < s
-
- t < s
- t > s
- t == s
- t > s
- t < s
-
- t < s
- t > s
- t == s
- t > s
- t < s
-
- t < s
- t > s
- t == s
- t > s
- t < s
-
- t < s
- t > s
- t == s
- t > s
- t < s
-
- t < s
- t > s
- t == s
- t > s
- t < s
-
- t < s
- t > s
- t == s
- t > s
- t < s
-
- t < s
- t > s
- t == s
- t > s
- t < s
-
- t < s
- t > s
- t == s
- t > s
- t < s
-
- def calibrate(self):
-
- s = ''.join(map(str,range(10)))
- t = ''.join(map(str,range(10))) + "abc"
-
- for i in range(self.rounds):
- pass
-
-
-class CompareInternedStrings(Test):
-
- version = 2.0
- operations = 10 * 5
- rounds = 300000
-
- def test(self):
-
- # Make sure the strings *are* interned
- s = intern(''.join(map(str,range(10))))
- t = s
-
- for i in range(self.rounds):
- t == s
- t == s
- t >= s
- t > s
- t < s
-
- t == s
- t == s
- t >= s
- t > s
- t < s
-
- t == s
- t == s
- t >= s
- t > s
- t < s
-
- t == s
- t == s
- t >= s
- t > s
- t < s
-
- t == s
- t == s
- t >= s
- t > s
- t < s
-
- t == s
- t == s
- t >= s
- t > s
- t < s
-
- t == s
- t == s
- t >= s
- t > s
- t < s
-
- t == s
- t == s
- t >= s
- t > s
- t < s
-
- t == s
- t == s
- t >= s
- t > s
- t < s
-
- t == s
- t == s
- t >= s
- t > s
- t < s
-
- def calibrate(self):
-
- s = intern(''.join(map(str,range(10))))
- t = s
-
- for i in range(self.rounds):
- pass
-
-
-class CreateStringsWithConcat(Test):
-
- version = 2.0
- operations = 10 * 5
- rounds = 200000
-
- def test(self):
-
- for i in range(self.rounds):
- s = 'om'
- s = s + 'xbx'
- s = s + 'xcx'
- s = s + 'xdx'
- s = s + 'xex'
-
- s = s + 'xax'
- s = s + 'xbx'
- s = s + 'xcx'
- s = s + 'xdx'
- s = s + 'xex'
-
- s = s + 'xax'
- s = s + 'xbx'
- s = s + 'xcx'
- s = s + 'xdx'
- s = s + 'xex'
-
- s = s + 'xax'
- s = s + 'xbx'
- s = s + 'xcx'
- s = s + 'xdx'
- s = s + 'xex'
-
- s = s + 'xax'
- s = s + 'xbx'
- s = s + 'xcx'
- s = s + 'xdx'
- s = s + 'xex'
-
- s = s + 'xax'
- s = s + 'xbx'
- s = s + 'xcx'
- s = s + 'xdx'
- s = s + 'xex'
-
- s = s + 'xax'
- s = s + 'xbx'
- s = s + 'xcx'
- s = s + 'xdx'
- s = s + 'xex'
-
- s = s + 'xax'
- s = s + 'xbx'
- s = s + 'xcx'
- s = s + 'xdx'
- s = s + 'xex'
-
- s = s + 'xax'
- s = s + 'xbx'
- s = s + 'xcx'
- s = s + 'xdx'
- s = s + 'xex'
-
- s = s + 'xax'
- s = s + 'xbx'
- s = s + 'xcx'
- s = s + 'xdx'
- s = s + 'xex'
-
- def calibrate(self):
-
- for i in range(self.rounds):
- pass
-
-
-class StringSlicing(Test):
-
- version = 2.0
- operations = 5 * 7
- rounds = 160000
-
- def test(self):
-
- s = ''.join(map(str,range(100)))
-
- for i in range(self.rounds):
-
- s[50:]
- s[:25]
- s[50:55]
- s[-1:]
- s[:1]
- s[2:]
- s[11:-11]
-
- s[50:]
- s[:25]
- s[50:55]
- s[-1:]
- s[:1]
- s[2:]
- s[11:-11]
-
- s[50:]
- s[:25]
- s[50:55]
- s[-1:]
- s[:1]
- s[2:]
- s[11:-11]
-
- s[50:]
- s[:25]
- s[50:55]
- s[-1:]
- s[:1]
- s[2:]
- s[11:-11]
-
- s[50:]
- s[:25]
- s[50:55]
- s[-1:]
- s[:1]
- s[2:]
- s[11:-11]
-
- def calibrate(self):
-
- s = ''.join(map(str,range(100)))
-
- for i in range(self.rounds):
- pass
-
-### String methods
-
-if hasattr('', 'lower'):
-
- class StringMappings(Test):
-
- version = 2.0
- operations = 3 * (5 + 4 + 2 + 1)
- rounds = 70000
-
- def test(self):
-
- s = ''.join(map(chr,range(20)))
- t = ''.join(map(chr,range(50)))
- u = ''.join(map(chr,range(100)))
- v = ''.join(map(chr,range(256)))
-
- for i in range(self.rounds):
-
- s.lower()
- s.lower()
- s.lower()
- s.lower()
- s.lower()
-
- s.upper()
- s.upper()
- s.upper()
- s.upper()
- s.upper()
-
- s.title()
- s.title()
- s.title()
- s.title()
- s.title()
-
- t.lower()
- t.lower()
- t.lower()
- t.lower()
-
- t.upper()
- t.upper()
- t.upper()
- t.upper()
-
- t.title()
- t.title()
- t.title()
- t.title()
-
- u.lower()
- u.lower()
-
- u.upper()
- u.upper()
-
- u.title()
- u.title()
-
- v.lower()
-
- v.upper()
-
- v.title()
-
- def calibrate(self):
-
- s = ''.join(map(chr,range(20)))
- t = ''.join(map(chr,range(50)))
- u = ''.join(map(chr,range(100)))
- v = ''.join(map(chr,range(256)))
-
- for i in range(self.rounds):
- pass
-
- class StringPredicates(Test):
-
- version = 2.0
- operations = 10 * 7
- rounds = 100000
-
- def test(self):
-
- data = ('abc', '123', ' ', '\xe4\xf6\xfc', '\xdf'*10)
- len_data = len(data)
-
- for i in range(self.rounds):
- s = data[i % len_data]
-
- s.isalnum()
- s.isalpha()
- s.isdigit()
- s.islower()
- s.isspace()
- s.istitle()
- s.isupper()
-
- s.isalnum()
- s.isalpha()
- s.isdigit()
- s.islower()
- s.isspace()
- s.istitle()
- s.isupper()
-
- s.isalnum()
- s.isalpha()
- s.isdigit()
- s.islower()
- s.isspace()
- s.istitle()
- s.isupper()
-
- s.isalnum()
- s.isalpha()
- s.isdigit()
- s.islower()
- s.isspace()
- s.istitle()
- s.isupper()
-
- s.isalnum()
- s.isalpha()
- s.isdigit()
- s.islower()
- s.isspace()
- s.istitle()
- s.isupper()
-
- s.isalnum()
- s.isalpha()
- s.isdigit()
- s.islower()
- s.isspace()
- s.istitle()
- s.isupper()
-
- s.isalnum()
- s.isalpha()
- s.isdigit()
- s.islower()
- s.isspace()
- s.istitle()
- s.isupper()
-
- s.isalnum()
- s.isalpha()
- s.isdigit()
- s.islower()
- s.isspace()
- s.istitle()
- s.isupper()
-
- s.isalnum()
- s.isalpha()
- s.isdigit()
- s.islower()
- s.isspace()
- s.istitle()
- s.isupper()
-
- s.isalnum()
- s.isalpha()
- s.isdigit()
- s.islower()
- s.isspace()
- s.istitle()
- s.isupper()
-
- def calibrate(self):
-
- data = ('abc', '123', ' ', '\u1234\u2345\u3456', '\uFFFF'*10)
- data = ('abc', '123', ' ', '\xe4\xf6\xfc', '\xdf'*10)
- len_data = len(data)
-
- for i in range(self.rounds):
- s = data[i % len_data]
+++ /dev/null
-from pybench import Test
-
-class TupleSlicing(Test):
-
- version = 2.0
- operations = 3 * 25 * 10 * 7
- rounds = 500
-
- def test(self):
-
- r = range(25)
- t = tuple(range(100))
-
- for i in range(self.rounds):
-
- for j in r:
-
- m = t[50:]
- m = t[:25]
- m = t[50:55]
- m = t[:-1]
- m = t[1:]
- m = t[-10:]
- m = t[:10]
-
- m = t[50:]
- m = t[:25]
- m = t[50:55]
- m = t[:-1]
- m = t[1:]
- m = t[-10:]
- m = t[:10]
-
- m = t[50:]
- m = t[:25]
- m = t[50:55]
- m = t[:-1]
- m = t[1:]
- m = t[-10:]
- m = t[:10]
-
- m = t[50:]
- m = t[:25]
- m = t[50:55]
- m = t[:-1]
- m = t[1:]
- m = t[-10:]
- m = t[:10]
-
- m = t[50:]
- m = t[:25]
- m = t[50:55]
- m = t[:-1]
- m = t[1:]
- m = t[-10:]
- m = t[:10]
-
- m = t[50:]
- m = t[:25]
- m = t[50:55]
- m = t[:-1]
- m = t[1:]
- m = t[-10:]
- m = t[:10]
-
- m = t[50:]
- m = t[:25]
- m = t[50:55]
- m = t[:-1]
- m = t[1:]
- m = t[-10:]
- m = t[:10]
-
- m = t[50:]
- m = t[:25]
- m = t[50:55]
- m = t[:-1]
- m = t[1:]
- m = t[-10:]
- m = t[:10]
-
- m = t[50:]
- m = t[:25]
- m = t[50:55]
- m = t[:-1]
- m = t[1:]
- m = t[-10:]
- m = t[:10]
-
- m = t[50:]
- m = t[:25]
- m = t[50:55]
- m = t[:-1]
- m = t[1:]
- m = t[-10:]
- m = t[:10]
-
- m = t[50:]
- m = t[:25]
- m = t[50:55]
- m = t[:-1]
- m = t[1:]
- m = t[-10:]
- m = t[:10]
-
- m = t[50:]
- m = t[:25]
- m = t[50:55]
- m = t[:-1]
- m = t[1:]
- m = t[-10:]
- m = t[:10]
-
- m = t[50:]
- m = t[:25]
- m = t[50:55]
- m = t[:-1]
- m = t[1:]
- m = t[-10:]
- m = t[:10]
-
- m = t[50:]
- m = t[:25]
- m = t[50:55]
- m = t[:-1]
- m = t[1:]
- m = t[-10:]
- m = t[:10]
-
- m = t[50:]
- m = t[:25]
- m = t[50:55]
- m = t[:-1]
- m = t[1:]
- m = t[-10:]
- m = t[:10]
-
- m = t[50:]
- m = t[:25]
- m = t[50:55]
- m = t[:-1]
- m = t[1:]
- m = t[-10:]
- m = t[:10]
-
- m = t[50:]
- m = t[:25]
- m = t[50:55]
- m = t[:-1]
- m = t[1:]
- m = t[-10:]
- m = t[:10]
-
- m = t[50:]
- m = t[:25]
- m = t[50:55]
- m = t[:-1]
- m = t[1:]
- m = t[-10:]
- m = t[:10]
-
- m = t[50:]
- m = t[:25]
- m = t[50:55]
- m = t[:-1]
- m = t[1:]
- m = t[-10:]
- m = t[:10]
-
- m = t[50:]
- m = t[:25]
- m = t[50:55]
- m = t[:-1]
- m = t[1:]
- m = t[-10:]
- m = t[:10]
-
- m = t[50:]
- m = t[:25]
- m = t[50:55]
- m = t[:-1]
- m = t[1:]
- m = t[-10:]
- m = t[:10]
-
- m = t[50:]
- m = t[:25]
- m = t[50:55]
- m = t[:-1]
- m = t[1:]
- m = t[-10:]
- m = t[:10]
-
- m = t[50:]
- m = t[:25]
- m = t[50:55]
- m = t[:-1]
- m = t[1:]
- m = t[-10:]
- m = t[:10]
-
- m = t[50:]
- m = t[:25]
- m = t[50:55]
- m = t[:-1]
- m = t[1:]
- m = t[-10:]
- m = t[:10]
-
- m = t[50:]
- m = t[:25]
- m = t[50:55]
- m = t[:-1]
- m = t[1:]
- m = t[-10:]
- m = t[:10]
-
- m = t[50:]
- m = t[:25]
- m = t[50:55]
- m = t[:-1]
- m = t[1:]
- m = t[-10:]
- m = t[:10]
-
- m = t[50:]
- m = t[:25]
- m = t[50:55]
- m = t[:-1]
- m = t[1:]
- m = t[-10:]
- m = t[:10]
-
- m = t[50:]
- m = t[:25]
- m = t[50:55]
- m = t[:-1]
- m = t[1:]
- m = t[-10:]
- m = t[:10]
-
- m = t[50:]
- m = t[:25]
- m = t[50:55]
- m = t[:-1]
- m = t[1:]
- m = t[-10:]
- m = t[:10]
-
- m = t[50:]
- m = t[:25]
- m = t[50:55]
- m = t[:-1]
- m = t[1:]
- m = t[-10:]
- m = t[:10]
-
- def calibrate(self):
-
- r = range(25)
- t = tuple(range(100))
-
- for i in range(self.rounds):
- for j in r:
- pass
-
-class SmallTuples(Test):
-
- version = 2.0
- operations = 5*(1 + 3 + 6 + 2)
- rounds = 90000
-
- def test(self):
-
- for i in range(self.rounds):
-
- t = (1,2,3,4,5,6)
-
- a,b,c,d,e,f = t
- a,b,c,d,e,f = t
- a,b,c,d,e,f = t
-
- a,b,c = t[:3]
- a,b,c = t[:3]
- a,b,c = t[:3]
- a,b,c = t[:3]
- a,b,c = t[:3]
- a,b,c = t[:3]
-
- l = list(t)
- t = tuple(l)
-
- t = (1,2,3,4,5,6)
-
- a,b,c,d,e,f = t
- a,b,c,d,e,f = t
- a,b,c,d,e,f = t
-
- a,b,c = t[:3]
- a,b,c = t[:3]
- a,b,c = t[:3]
- a,b,c = t[:3]
- a,b,c = t[:3]
- a,b,c = t[:3]
-
- l = list(t)
- t = tuple(l)
-
- t = (1,2,3,4,5,6)
-
- a,b,c,d,e,f = t
- a,b,c,d,e,f = t
- a,b,c,d,e,f = t
-
- a,b,c = t[:3]
- a,b,c = t[:3]
- a,b,c = t[:3]
- a,b,c = t[:3]
- a,b,c = t[:3]
- a,b,c = t[:3]
-
- l = list(t)
- t = tuple(l)
-
- t = (1,2,3,4,5,6)
-
- a,b,c,d,e,f = t
- a,b,c,d,e,f = t
- a,b,c,d,e,f = t
-
- a,b,c = t[:3]
- a,b,c = t[:3]
- a,b,c = t[:3]
- a,b,c = t[:3]
- a,b,c = t[:3]
- a,b,c = t[:3]
-
- l = list(t)
- t = tuple(l)
-
- t = (1,2,3,4,5,6)
-
- a,b,c,d,e,f = t
- a,b,c,d,e,f = t
- a,b,c,d,e,f = t
-
- a,b,c = t[:3]
- a,b,c = t[:3]
- a,b,c = t[:3]
- a,b,c = t[:3]
- a,b,c = t[:3]
- a,b,c = t[:3]
-
- l = list(t)
- t = tuple(l)
-
- def calibrate(self):
-
- for i in range(self.rounds):
- pass
+++ /dev/null
-try:
- unicode
-except NameError:
- raise ImportError
-
-from pybench import Test
-
-class ConcatUnicode(Test):
-
- version = 2.0
- operations = 10 * 5
- rounds = 60000
-
- def test(self):
-
- # Make sure the strings are *not* interned
- s = unicode(u''.join(map(str,range(100))))
- t = unicode(u''.join(map(str,range(1,101))))
-
- for i in range(self.rounds):
- t + s
- t + s
- t + s
- t + s
- t + s
-
- t + s
- t + s
- t + s
- t + s
- t + s
-
- t + s
- t + s
- t + s
- t + s
- t + s
-
- t + s
- t + s
- t + s
- t + s
- t + s
-
- t + s
- t + s
- t + s
- t + s
- t + s
-
- t + s
- t + s
- t + s
- t + s
- t + s
-
- t + s
- t + s
- t + s
- t + s
- t + s
-
- t + s
- t + s
- t + s
- t + s
- t + s
-
- t + s
- t + s
- t + s
- t + s
- t + s
-
- t + s
- t + s
- t + s
- t + s
- t + s
-
- def calibrate(self):
-
- s = unicode(u''.join(map(str,range(100))))
- t = unicode(u''.join(map(str,range(1,101))))
-
- for i in range(self.rounds):
- pass
-
-
-class CompareUnicode(Test):
-
- version = 2.0
- operations = 10 * 5
- rounds = 150000
-
- def test(self):
-
- # Make sure the strings are *not* interned
- s = unicode(u''.join(map(str,range(10))))
- t = unicode(u''.join(map(str,range(10))) + "abc")
-
- for i in range(self.rounds):
- t < s
- t > s
- t == s
- t > s
- t < s
-
- t < s
- t > s
- t == s
- t > s
- t < s
-
- t < s
- t > s
- t == s
- t > s
- t < s
-
- t < s
- t > s
- t == s
- t > s
- t < s
-
- t < s
- t > s
- t == s
- t > s
- t < s
-
- t < s
- t > s
- t == s
- t > s
- t < s
-
- t < s
- t > s
- t == s
- t > s
- t < s
-
- t < s
- t > s
- t == s
- t > s
- t < s
-
- t < s
- t > s
- t == s
- t > s
- t < s
-
- t < s
- t > s
- t == s
- t > s
- t < s
-
- def calibrate(self):
-
- s = unicode(u''.join(map(str,range(10))))
- t = unicode(u''.join(map(str,range(10))) + "abc")
-
- for i in range(self.rounds):
- pass
-
-
-class CreateUnicodeWithConcat(Test):
-
- version = 2.0
- operations = 10 * 5
- rounds = 80000
-
- def test(self):
-
- for i in range(self.rounds):
- s = u'om'
- s = s + u'xbx'
- s = s + u'xcx'
- s = s + u'xdx'
- s = s + u'xex'
-
- s = s + u'xax'
- s = s + u'xbx'
- s = s + u'xcx'
- s = s + u'xdx'
- s = s + u'xex'
-
- s = s + u'xax'
- s = s + u'xbx'
- s = s + u'xcx'
- s = s + u'xdx'
- s = s + u'xex'
-
- s = s + u'xax'
- s = s + u'xbx'
- s = s + u'xcx'
- s = s + u'xdx'
- s = s + u'xex'
-
- s = s + u'xax'
- s = s + u'xbx'
- s = s + u'xcx'
- s = s + u'xdx'
- s = s + u'xex'
-
- s = s + u'xax'
- s = s + u'xbx'
- s = s + u'xcx'
- s = s + u'xdx'
- s = s + u'xex'
-
- s = s + u'xax'
- s = s + u'xbx'
- s = s + u'xcx'
- s = s + u'xdx'
- s = s + u'xex'
-
- s = s + u'xax'
- s = s + u'xbx'
- s = s + u'xcx'
- s = s + u'xdx'
- s = s + u'xex'
-
- s = s + u'xax'
- s = s + u'xbx'
- s = s + u'xcx'
- s = s + u'xdx'
- s = s + u'xex'
-
- s = s + u'xax'
- s = s + u'xbx'
- s = s + u'xcx'
- s = s + u'xdx'
- s = s + u'xex'
-
- def calibrate(self):
-
- for i in range(self.rounds):
- pass
-
-
-class UnicodeSlicing(Test):
-
- version = 2.0
- operations = 5 * 7
- rounds = 140000
-
- def test(self):
-
- s = unicode(u''.join(map(str,range(100))))
-
- for i in range(self.rounds):
-
- s[50:]
- s[:25]
- s[50:55]
- s[-1:]
- s[:1]
- s[2:]
- s[11:-11]
-
- s[50:]
- s[:25]
- s[50:55]
- s[-1:]
- s[:1]
- s[2:]
- s[11:-11]
-
- s[50:]
- s[:25]
- s[50:55]
- s[-1:]
- s[:1]
- s[2:]
- s[11:-11]
-
- s[50:]
- s[:25]
- s[50:55]
- s[-1:]
- s[:1]
- s[2:]
- s[11:-11]
-
- s[50:]
- s[:25]
- s[50:55]
- s[-1:]
- s[:1]
- s[2:]
- s[11:-11]
-
- def calibrate(self):
-
- s = unicode(u''.join(map(str,range(100))))
-
- for i in range(self.rounds):
- pass
-
-### String methods
-
-class UnicodeMappings(Test):
-
- version = 2.0
- operations = 3 * (5 + 4 + 2 + 1)
- rounds = 10000
-
- def test(self):
-
- s = u''.join(map(unichr,range(20)))
- t = u''.join(map(unichr,range(100)))
- u = u''.join(map(unichr,range(500)))
- v = u''.join(map(unichr,range(1000)))
-
- for i in range(self.rounds):
-
- s.lower()
- s.lower()
- s.lower()
- s.lower()
- s.lower()
-
- s.upper()
- s.upper()
- s.upper()
- s.upper()
- s.upper()
-
- s.title()
- s.title()
- s.title()
- s.title()
- s.title()
-
- t.lower()
- t.lower()
- t.lower()
- t.lower()
-
- t.upper()
- t.upper()
- t.upper()
- t.upper()
-
- t.title()
- t.title()
- t.title()
- t.title()
-
- u.lower()
- u.lower()
-
- u.upper()
- u.upper()
-
- u.title()
- u.title()
-
- v.lower()
-
- v.upper()
-
- v.title()
-
- def calibrate(self):
-
- s = u''.join(map(unichr,range(20)))
- t = u''.join(map(unichr,range(100)))
- u = u''.join(map(unichr,range(500)))
- v = u''.join(map(unichr,range(1000)))
-
- for i in range(self.rounds):
- pass
-
-class UnicodePredicates(Test):
-
- version = 2.0
- operations = 5 * 9
- rounds = 120000
-
- def test(self):
-
- data = (u'abc', u'123', u' ', u'\u1234\u2345\u3456', u'\uFFFF'*10)
- len_data = len(data)
-
- for i in range(self.rounds):
- s = data[i % len_data]
-
- s.isalnum()
- s.isalpha()
- s.isdecimal()
- s.isdigit()
- s.islower()
- s.isnumeric()
- s.isspace()
- s.istitle()
- s.isupper()
-
- s.isalnum()
- s.isalpha()
- s.isdecimal()
- s.isdigit()
- s.islower()
- s.isnumeric()
- s.isspace()
- s.istitle()
- s.isupper()
-
- s.isalnum()
- s.isalpha()
- s.isdecimal()
- s.isdigit()
- s.islower()
- s.isnumeric()
- s.isspace()
- s.istitle()
- s.isupper()
-
- s.isalnum()
- s.isalpha()
- s.isdecimal()
- s.isdigit()
- s.islower()
- s.isnumeric()
- s.isspace()
- s.istitle()
- s.isupper()
-
- s.isalnum()
- s.isalpha()
- s.isdecimal()
- s.isdigit()
- s.islower()
- s.isnumeric()
- s.isspace()
- s.istitle()
- s.isupper()
-
- def calibrate(self):
-
- data = (u'abc', u'123', u' ', u'\u1234\u2345\u3456', u'\uFFFF'*10)
- len_data = len(data)
-
- for i in range(self.rounds):
- s = data[i % len_data]
-
-try:
- import unicodedata
-except ImportError:
- pass
-else:
- class UnicodeProperties(Test):
-
- version = 2.0
- operations = 5 * 8
- rounds = 100000
-
- def test(self):
-
- data = (u'a', u'1', u' ', u'\u1234', u'\uFFFF')
- len_data = len(data)
- digit = unicodedata.digit
- numeric = unicodedata.numeric
- decimal = unicodedata.decimal
- category = unicodedata.category
- bidirectional = unicodedata.bidirectional
- decomposition = unicodedata.decomposition
- mirrored = unicodedata.mirrored
- combining = unicodedata.combining
-
- for i in range(self.rounds):
-
- c = data[i % len_data]
-
- digit(c, None)
- numeric(c, None)
- decimal(c, None)
- category(c)
- bidirectional(c)
- decomposition(c)
- mirrored(c)
- combining(c)
-
- digit(c, None)
- numeric(c, None)
- decimal(c, None)
- category(c)
- bidirectional(c)
- decomposition(c)
- mirrored(c)
- combining(c)
-
- digit(c, None)
- numeric(c, None)
- decimal(c, None)
- category(c)
- bidirectional(c)
- decomposition(c)
- mirrored(c)
- combining(c)
-
- digit(c, None)
- numeric(c, None)
- decimal(c, None)
- category(c)
- bidirectional(c)
- decomposition(c)
- mirrored(c)
- combining(c)
-
- digit(c, None)
- numeric(c, None)
- decimal(c, None)
- category(c)
- bidirectional(c)
- decomposition(c)
- mirrored(c)
- combining(c)
-
- def calibrate(self):
-
- data = (u'a', u'1', u' ', u'\u1234', u'\uFFFF')
- len_data = len(data)
- digit = unicodedata.digit
- numeric = unicodedata.numeric
- decimal = unicodedata.decimal
- category = unicodedata.category
- bidirectional = unicodedata.bidirectional
- decomposition = unicodedata.decomposition
- mirrored = unicodedata.mirrored
- combining = unicodedata.combining
-
- for i in range(self.rounds):
-
- c = data[i % len_data]
+++ /dev/null
-from pybench import Test
-
-class WithFinally(Test):
-
- version = 2.0
- operations = 20
- rounds = 80000
-
- class ContextManager(object):
- def __enter__(self):
- pass
- def __exit__(self, exc, val, tb):
- pass
-
- def test(self):
-
- cm = self.ContextManager()
-
- for i in range(self.rounds):
- with cm: pass
- with cm: pass
- with cm: pass
- with cm: pass
- with cm: pass
- with cm: pass
- with cm: pass
- with cm: pass
- with cm: pass
- with cm: pass
- with cm: pass
- with cm: pass
- with cm: pass
- with cm: pass
- with cm: pass
- with cm: pass
- with cm: pass
- with cm: pass
- with cm: pass
- with cm: pass
-
- def calibrate(self):
-
- cm = self.ContextManager()
-
- for i in range(self.rounds):
- pass
-
-
-class TryFinally(Test):
-
- version = 2.0
- operations = 20
- rounds = 80000
-
- class ContextManager(object):
- def __enter__(self):
- pass
- def __exit__(self):
- # "Context manager" objects used just for their cleanup
- # actions in finally blocks usually don't have parameters.
- pass
-
- def test(self):
-
- cm = self.ContextManager()
-
- for i in range(self.rounds):
- cm.__enter__()
- try: pass
- finally: cm.__exit__()
-
- cm.__enter__()
- try: pass
- finally: cm.__exit__()
-
- cm.__enter__()
- try: pass
- finally: cm.__exit__()
-
- cm.__enter__()
- try: pass
- finally: cm.__exit__()
-
- cm.__enter__()
- try: pass
- finally: cm.__exit__()
-
- cm.__enter__()
- try: pass
- finally: cm.__exit__()
-
- cm.__enter__()
- try: pass
- finally: cm.__exit__()
-
- cm.__enter__()
- try: pass
- finally: cm.__exit__()
-
- cm.__enter__()
- try: pass
- finally: cm.__exit__()
-
- cm.__enter__()
- try: pass
- finally: cm.__exit__()
-
- cm.__enter__()
- try: pass
- finally: cm.__exit__()
-
- cm.__enter__()
- try: pass
- finally: cm.__exit__()
-
- cm.__enter__()
- try: pass
- finally: cm.__exit__()
-
- cm.__enter__()
- try: pass
- finally: cm.__exit__()
-
- cm.__enter__()
- try: pass
- finally: cm.__exit__()
-
- cm.__enter__()
- try: pass
- finally: cm.__exit__()
-
- cm.__enter__()
- try: pass
- finally: cm.__exit__()
-
- cm.__enter__()
- try: pass
- finally: cm.__exit__()
-
- cm.__enter__()
- try: pass
- finally: cm.__exit__()
-
- cm.__enter__()
- try: pass
- finally: cm.__exit__()
-
- def calibrate(self):
-
- cm = self.ContextManager()
-
- for i in range(self.rounds):
- pass
-
-
-class WithRaiseExcept(Test):
-
- version = 2.0
- operations = 2 + 3 + 3
- rounds = 100000
-
- class BlockExceptions(object):
- def __enter__(self):
- pass
- def __exit__(self, exc, val, tb):
- return True
-
- def test(self):
-
- error = ValueError
- be = self.BlockExceptions()
-
- for i in range(self.rounds):
- with be: raise error
- with be: raise error
- with be: raise error("something")
- with be: raise error("something")
- with be: raise error("something")
- with be: raise error("something")
- with be: raise error("something")
- with be: raise error("something")
-
- def calibrate(self):
-
- error = ValueError
- be = self.BlockExceptions()
-
- for i in range(self.rounds):
- pass
+++ /dev/null
-#!/usr/bin/env python
-
-""" clockres - calculates the resolution in seconds of a given timer.
-
- Copyright (c) 2006, Marc-Andre Lemburg (mal@egenix.com). See the
- documentation for further information on copyrights, or contact
- the author. All Rights Reserved.
-
-"""
-import time
-
-TEST_TIME = 1.0
-
-def clockres(timer):
- d = {}
- wallclock = time.time
- start = wallclock()
- stop = wallclock() + TEST_TIME
- spin_loops = range(1000)
- while 1:
- now = wallclock()
- if now >= stop:
- break
- for i in spin_loops:
- d[timer()] = 1
- values = sorted(d.keys())
- min_diff = TEST_TIME
- for i in range(len(values) - 1):
- diff = values[i+1] - values[i]
- if diff < min_diff:
- min_diff = diff
- return min_diff
-
-if __name__ == '__main__':
- print('Clock resolution of various timer implementations:')
- print('time.clock: %10.3fus' % (clockres(time.clock) * 1e6))
- print('time.time: %10.3fus' % (clockres(time.time) * 1e6))
- try:
- import systimes
- print('systimes.processtime: %10.3fus' % (clockres(systimes.processtime) * 1e6))
- except ImportError:
- pass
+++ /dev/null
-#!/usr/local/bin/python -O
-
-""" A Python Benchmark Suite
-
-"""
-# Note: Please keep this module compatible to Python 2.6.
-#
-# Tests may include features in later Python versions, but these
-# should then be embedded in try-except clauses in the configuration
-# module Setup.py.
-#
-
-from __future__ import print_function
-
-# pybench Copyright
-__copyright__ = """\
-Copyright (c), 1997-2006, Marc-Andre Lemburg (mal@lemburg.com)
-Copyright (c), 2000-2006, eGenix.com Software GmbH (info@egenix.com)
-
- All Rights Reserved.
-
-Permission to use, copy, modify, and distribute this software and its
-documentation for any purpose and without fee or royalty is hereby
-granted, provided that the above copyright notice appear in all copies
-and that both that copyright notice and this permission notice appear
-in supporting documentation or portions thereof, including
-modifications, that you make.
-
-THE AUTHOR MARC-ANDRE LEMBURG DISCLAIMS ALL WARRANTIES WITH REGARD TO
-THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
-FITNESS, IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL,
-INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING
-FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
-NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
-WITH THE USE OR PERFORMANCE OF THIS SOFTWARE !
-"""
-
-import sys
-import time
-import platform
-from CommandLine import *
-
-try:
- import cPickle
- pickle = cPickle
-except ImportError:
- import pickle
-
-# Version number; version history: see README file !
-__version__ = '2.1'
-
-### Constants
-
-# Second fractions
-MILLI_SECONDS = 1e3
-MICRO_SECONDS = 1e6
-
-# Percent unit
-PERCENT = 100
-
-# Horizontal line length
-LINE = 79
-
-# Minimum test run-time
-MIN_TEST_RUNTIME = 1e-3
-
-# Number of calibration runs to use for calibrating the tests
-CALIBRATION_RUNS = 20
-
-# Number of calibration loops to run for each calibration run
-CALIBRATION_LOOPS = 20
-
-# Allow skipping calibration ?
-ALLOW_SKIPPING_CALIBRATION = 1
-
-# Timer types
-TIMER_TIME_TIME = 'time.time'
-TIMER_TIME_PROCESS_TIME = 'time.process_time'
-TIMER_TIME_PERF_COUNTER = 'time.perf_counter'
-TIMER_TIME_CLOCK = 'time.clock'
-TIMER_SYSTIMES_PROCESSTIME = 'systimes.processtime'
-
-# Choose platform default timer
-if hasattr(time, 'perf_counter'):
- TIMER_PLATFORM_DEFAULT = TIMER_TIME_PERF_COUNTER
-elif sys.platform[:3] == 'win':
- # On WinXP this has 2.5ms resolution
- TIMER_PLATFORM_DEFAULT = TIMER_TIME_CLOCK
-else:
- # On Linux this has 1ms resolution
- TIMER_PLATFORM_DEFAULT = TIMER_TIME_TIME
-
-# Print debug information ?
-_debug = 0
-
-### Helpers
-
-def get_timer(timertype):
-
- if timertype == TIMER_TIME_TIME:
- return time.time
- elif timertype == TIMER_TIME_PROCESS_TIME:
- return time.process_time
- elif timertype == TIMER_TIME_PERF_COUNTER:
- return time.perf_counter
- elif timertype == TIMER_TIME_CLOCK:
- return time.clock
- elif timertype == TIMER_SYSTIMES_PROCESSTIME:
- import systimes
- return systimes.processtime
- else:
- raise TypeError('unknown timer type: %s' % timertype)
-
-def get_machine_details():
-
- if _debug:
- print('Getting machine details...')
- buildno, builddate = platform.python_build()
- python = platform.python_version()
- # XXX this is now always UCS4, maybe replace it with 'PEP393' in 3.3+?
- if sys.maxunicode == 65535:
- # UCS2 build (standard)
- unitype = 'UCS2'
- else:
- # UCS4 build (most recent Linux distros)
- unitype = 'UCS4'
- bits, linkage = platform.architecture()
- return {
- 'platform': platform.platform(),
- 'processor': platform.processor(),
- 'executable': sys.executable,
- 'implementation': getattr(platform, 'python_implementation',
- lambda:'n/a')(),
- 'python': platform.python_version(),
- 'compiler': platform.python_compiler(),
- 'buildno': buildno,
- 'builddate': builddate,
- 'unicode': unitype,
- 'bits': bits,
- }
-
-def print_machine_details(d, indent=''):
-
- l = ['Machine Details:',
- ' Platform ID: %s' % d.get('platform', 'n/a'),
- ' Processor: %s' % d.get('processor', 'n/a'),
- '',
- 'Python:',
- ' Implementation: %s' % d.get('implementation', 'n/a'),
- ' Executable: %s' % d.get('executable', 'n/a'),
- ' Version: %s' % d.get('python', 'n/a'),
- ' Compiler: %s' % d.get('compiler', 'n/a'),
- ' Bits: %s' % d.get('bits', 'n/a'),
- ' Build: %s (#%s)' % (d.get('builddate', 'n/a'),
- d.get('buildno', 'n/a')),
- ' Unicode: %s' % d.get('unicode', 'n/a'),
- ]
- joiner = '\n' + indent
- print(indent + joiner.join(l) + '\n')
-
-### Test baseclass
-
-class Test:
-
- """ All test must have this class as baseclass. It provides
- the necessary interface to the benchmark machinery.
-
- The tests must set .rounds to a value high enough to let the
- test run between 20-50 seconds. This is needed because
- clock()-timing only gives rather inaccurate values (on Linux,
- for example, it is accurate to a few hundreths of a
- second). If you don't want to wait that long, use a warp
- factor larger than 1.
-
- It is also important to set the .operations variable to a
- value representing the number of "virtual operations" done per
- call of .run().
-
- If you change a test in some way, don't forget to increase
- its version number.
-
- """
-
- ### Instance variables that each test should override
-
- # Version number of the test as float (x.yy); this is important
- # for comparisons of benchmark runs - tests with unequal version
- # number will not get compared.
- version = 2.1
-
- # The number of abstract operations done in each round of the
- # test. An operation is the basic unit of what you want to
- # measure. The benchmark will output the amount of run-time per
- # operation. Note that in order to raise the measured timings
- # significantly above noise level, it is often required to repeat
- # sets of operations more than once per test round. The measured
- # overhead per test round should be less than 1 second.
- operations = 1
-
- # Number of rounds to execute per test run. This should be
- # adjusted to a figure that results in a test run-time of between
- # 1-2 seconds.
- rounds = 100000
-
- ### Internal variables
-
- # Mark this class as implementing a test
- is_a_test = 1
-
- # Last timing: (real, run, overhead)
- last_timing = (0.0, 0.0, 0.0)
-
- # Warp factor to use for this test
- warp = 1
-
- # Number of calibration runs to use
- calibration_runs = CALIBRATION_RUNS
-
- # List of calibration timings
- overhead_times = None
-
- # List of test run timings
- times = []
-
- # Timer used for the benchmark
- timer = TIMER_PLATFORM_DEFAULT
-
- def __init__(self, warp=None, calibration_runs=None, timer=None):
-
- # Set parameters
- if warp is not None:
- self.rounds = int(self.rounds / warp)
- if self.rounds == 0:
- raise ValueError('warp factor set too high')
- self.warp = warp
- if calibration_runs is not None:
- if (not ALLOW_SKIPPING_CALIBRATION and
- calibration_runs < 1):
- raise ValueError('at least one calibration run is required')
- self.calibration_runs = calibration_runs
- if timer is not None:
- self.timer = timer
-
- # Init variables
- self.times = []
- self.overhead_times = []
-
- # We want these to be in the instance dict, so that pickle
- # saves them
- self.version = self.version
- self.operations = self.operations
- self.rounds = self.rounds
-
- def get_timer(self):
-
- """ Return the timer function to use for the test.
-
- """
- return get_timer(self.timer)
-
- def compatible(self, other):
-
- """ Return 1/0 depending on whether the test is compatible
- with the other Test instance or not.
-
- """
- if self.version != other.version:
- return 0
- if self.rounds != other.rounds:
- return 0
- return 1
-
- def calibrate_test(self):
-
- if self.calibration_runs == 0:
- self.overhead_times = [0.0]
- return
-
- calibrate = self.calibrate
- timer = self.get_timer()
- calibration_loops = range(CALIBRATION_LOOPS)
-
- # Time the calibration loop overhead
- prep_times = []
- for i in range(self.calibration_runs):
- t = timer()
- for i in calibration_loops:
- pass
- t = timer() - t
- prep_times.append(t / CALIBRATION_LOOPS)
- min_prep_time = min(prep_times)
- if _debug:
- print()
- print('Calib. prep time = %.6fms' % (
- min_prep_time * MILLI_SECONDS))
-
- # Time the calibration runs (doing CALIBRATION_LOOPS loops of
- # .calibrate() method calls each)
- for i in range(self.calibration_runs):
- t = timer()
- for i in calibration_loops:
- calibrate()
- t = timer() - t
- self.overhead_times.append(t / CALIBRATION_LOOPS
- - min_prep_time)
-
- # Check the measured times
- min_overhead = min(self.overhead_times)
- max_overhead = max(self.overhead_times)
- if _debug:
- print('Calib. overhead time = %.6fms' % (
- min_overhead * MILLI_SECONDS))
- if min_overhead < 0.0:
- raise ValueError('calibration setup did not work')
- if max_overhead - min_overhead > 0.1:
- raise ValueError(
- 'overhead calibration timing range too inaccurate: '
- '%r - %r' % (min_overhead, max_overhead))
-
- def run(self):
-
- """ Run the test in two phases: first calibrate, then
- do the actual test. Be careful to keep the calibration
- timing low w/r to the test timing.
-
- """
- test = self.test
- timer = self.get_timer()
-
- # Get calibration
- min_overhead = min(self.overhead_times)
-
- # Test run
- t = timer()
- test()
- t = timer() - t
- if t < MIN_TEST_RUNTIME:
- raise ValueError('warp factor too high: '
- 'test times are < 10ms')
- eff_time = t - min_overhead
- if eff_time < 0:
- raise ValueError('wrong calibration')
- self.last_timing = (eff_time, t, min_overhead)
- self.times.append(eff_time)
-
- def calibrate(self):
-
- """ Calibrate the test.
-
- This method should execute everything that is needed to
- setup and run the test - except for the actual operations
- that you intend to measure. pybench uses this method to
- measure the test implementation overhead.
-
- """
- return
-
- def test(self):
-
- """ Run the test.
-
- The test needs to run self.rounds executing
- self.operations number of operations each.
-
- """
- return
-
- def stat(self):
-
- """ Return test run statistics as tuple:
-
- (minimum run time,
- average run time,
- total run time,
- average time per operation,
- minimum overhead time)
-
- """
- runs = len(self.times)
- if runs == 0:
- return 0.0, 0.0, 0.0, 0.0
- min_time = min(self.times)
- total_time = sum(self.times)
- avg_time = total_time / float(runs)
- operation_avg = total_time / float(runs
- * self.rounds
- * self.operations)
- if self.overhead_times:
- min_overhead = min(self.overhead_times)
- else:
- min_overhead = self.last_timing[2]
- return min_time, avg_time, total_time, operation_avg, min_overhead
-
-### Load Setup
-
-# This has to be done after the definition of the Test class, since
-# the Setup module will import subclasses using this class.
-
-import Setup
-
-### Benchmark base class
-
-class Benchmark:
-
- # Name of the benchmark
- name = ''
-
- # Number of benchmark rounds to run
- rounds = 1
-
- # Warp factor use to run the tests
- warp = 1 # Warp factor
-
- # Average benchmark round time
- roundtime = 0
-
- # Benchmark version number as float x.yy
- version = 2.1
-
- # Produce verbose output ?
- verbose = 0
-
- # Dictionary with the machine details
- machine_details = None
-
- # Timer used for the benchmark
- timer = TIMER_PLATFORM_DEFAULT
-
- def __init__(self, name, verbose=None, timer=None, warp=None,
- calibration_runs=None):
-
- if name:
- self.name = name
- else:
- self.name = '%04i-%02i-%02i %02i:%02i:%02i' % \
- (time.localtime(time.time())[:6])
- if verbose is not None:
- self.verbose = verbose
- if timer is not None:
- self.timer = timer
- if warp is not None:
- self.warp = warp
- if calibration_runs is not None:
- self.calibration_runs = calibration_runs
-
- # Init vars
- self.tests = {}
- if _debug:
- print('Getting machine details...')
- self.machine_details = get_machine_details()
-
- # Make .version an instance attribute to have it saved in the
- # Benchmark pickle
- self.version = self.version
-
- def get_timer(self):
-
- """ Return the timer function to use for the test.
-
- """
- return get_timer(self.timer)
-
- def compatible(self, other):
-
- """ Return 1/0 depending on whether the benchmark is
- compatible with the other Benchmark instance or not.
-
- """
- if self.version != other.version:
- return 0
- if (self.machine_details == other.machine_details and
- self.timer != other.timer):
- return 0
- if (self.calibration_runs == 0 and
- other.calibration_runs != 0):
- return 0
- if (self.calibration_runs != 0 and
- other.calibration_runs == 0):
- return 0
- return 1
-
- def load_tests(self, setupmod, limitnames=None):
-
- # Add tests
- if self.verbose:
- print('Searching for tests ...')
- print('--------------------------------------')
- for testclass in setupmod.__dict__.values():
- if not hasattr(testclass, 'is_a_test'):
- continue
- name = testclass.__name__
- if name == 'Test':
- continue
- if (limitnames is not None and
- limitnames.search(name) is None):
- continue
- self.tests[name] = testclass(
- warp=self.warp,
- calibration_runs=self.calibration_runs,
- timer=self.timer)
- l = sorted(self.tests)
- if self.verbose:
- for name in l:
- print(' %s' % name)
- print('--------------------------------------')
- print(' %i tests found' % len(l))
- print()
-
- def calibrate(self):
-
- print('Calibrating tests. Please wait...', end=' ')
- sys.stdout.flush()
- if self.verbose:
- print()
- print()
- print('Test min max')
- print('-' * LINE)
- tests = sorted(self.tests.items())
- for i in range(len(tests)):
- name, test = tests[i]
- test.calibrate_test()
- if self.verbose:
- print('%30s: %6.3fms %6.3fms' % \
- (name,
- min(test.overhead_times) * MILLI_SECONDS,
- max(test.overhead_times) * MILLI_SECONDS))
- if self.verbose:
- print()
- print('Done with the calibration.')
- else:
- print('done.')
- print()
-
- def run(self):
-
- tests = sorted(self.tests.items())
- timer = self.get_timer()
- print('Running %i round(s) of the suite at warp factor %i:' % \
- (self.rounds, self.warp))
- print()
- self.roundtimes = []
- for i in range(self.rounds):
- if self.verbose:
- print(' Round %-25i effective absolute overhead' % (i+1))
- total_eff_time = 0.0
- for j in range(len(tests)):
- name, test = tests[j]
- if self.verbose:
- print('%30s:' % name, end=' ')
- test.run()
- (eff_time, abs_time, min_overhead) = test.last_timing
- total_eff_time = total_eff_time + eff_time
- if self.verbose:
- print(' %5.0fms %5.0fms %7.3fms' % \
- (eff_time * MILLI_SECONDS,
- abs_time * MILLI_SECONDS,
- min_overhead * MILLI_SECONDS))
- self.roundtimes.append(total_eff_time)
- if self.verbose:
- print(' '
- ' ------------------------------')
- print(' '
- ' Totals: %6.0fms' %
- (total_eff_time * MILLI_SECONDS))
- print()
- else:
- print('* Round %i done in %.3f seconds.' % (i+1,
- total_eff_time))
- print()
-
- def stat(self):
-
- """ Return benchmark run statistics as tuple:
-
- (minimum round time,
- average round time,
- maximum round time)
-
- XXX Currently not used, since the benchmark does test
- statistics across all rounds.
-
- """
- runs = len(self.roundtimes)
- if runs == 0:
- return 0.0, 0.0
- min_time = min(self.roundtimes)
- total_time = sum(self.roundtimes)
- avg_time = total_time / float(runs)
- max_time = max(self.roundtimes)
- return (min_time, avg_time, max_time)
-
- def print_header(self, title='Benchmark'):
-
- print('-' * LINE)
- print('%s: %s' % (title, self.name))
- print('-' * LINE)
- print()
- print(' Rounds: %s' % self.rounds)
- print(' Warp: %s' % self.warp)
- print(' Timer: %s' % self.timer)
- print()
- if self.machine_details:
- print_machine_details(self.machine_details, indent=' ')
- print()
-
- def print_benchmark(self, hidenoise=0, limitnames=None):
-
- print('Test '
- ' minimum average operation overhead')
- print('-' * LINE)
- tests = sorted(self.tests.items())
- total_min_time = 0.0
- total_avg_time = 0.0
- for name, test in tests:
- if (limitnames is not None and
- limitnames.search(name) is None):
- continue
- (min_time,
- avg_time,
- total_time,
- op_avg,
- min_overhead) = test.stat()
- total_min_time = total_min_time + min_time
- total_avg_time = total_avg_time + avg_time
- print('%30s: %5.0fms %5.0fms %6.2fus %7.3fms' % \
- (name,
- min_time * MILLI_SECONDS,
- avg_time * MILLI_SECONDS,
- op_avg * MICRO_SECONDS,
- min_overhead *MILLI_SECONDS))
- print('-' * LINE)
- print('Totals: '
- ' %6.0fms %6.0fms' %
- (total_min_time * MILLI_SECONDS,
- total_avg_time * MILLI_SECONDS,
- ))
- print()
-
- def print_comparison(self, compare_to, hidenoise=0, limitnames=None):
-
- # Check benchmark versions
- if compare_to.version != self.version:
- print('* Benchmark versions differ: '
- 'cannot compare this benchmark to "%s" !' %
- compare_to.name)
- print()
- self.print_benchmark(hidenoise=hidenoise,
- limitnames=limitnames)
- return
-
- # Print header
- compare_to.print_header('Comparing with')
- print('Test '
- ' minimum run-time average run-time')
- print(' '
- ' this other diff this other diff')
- print('-' * LINE)
-
- # Print test comparisons
- tests = sorted(self.tests.items())
- total_min_time = other_total_min_time = 0.0
- total_avg_time = other_total_avg_time = 0.0
- benchmarks_compatible = self.compatible(compare_to)
- tests_compatible = 1
- for name, test in tests:
- if (limitnames is not None and
- limitnames.search(name) is None):
- continue
- (min_time,
- avg_time,
- total_time,
- op_avg,
- min_overhead) = test.stat()
- total_min_time = total_min_time + min_time
- total_avg_time = total_avg_time + avg_time
- try:
- other = compare_to.tests[name]
- except KeyError:
- other = None
- if other is None:
- # Other benchmark doesn't include the given test
- min_diff, avg_diff = 'n/a', 'n/a'
- other_min_time = 0.0
- other_avg_time = 0.0
- tests_compatible = 0
- else:
- (other_min_time,
- other_avg_time,
- other_total_time,
- other_op_avg,
- other_min_overhead) = other.stat()
- other_total_min_time = other_total_min_time + other_min_time
- other_total_avg_time = other_total_avg_time + other_avg_time
- if (benchmarks_compatible and
- test.compatible(other)):
- # Both benchmark and tests are comparable
- min_diff = ((min_time * self.warp) /
- (other_min_time * other.warp) - 1.0)
- avg_diff = ((avg_time * self.warp) /
- (other_avg_time * other.warp) - 1.0)
- if hidenoise and abs(min_diff) < 10.0:
- min_diff = ''
- else:
- min_diff = '%+5.1f%%' % (min_diff * PERCENT)
- if hidenoise and abs(avg_diff) < 10.0:
- avg_diff = ''
- else:
- avg_diff = '%+5.1f%%' % (avg_diff * PERCENT)
- else:
- # Benchmark or tests are not comparable
- min_diff, avg_diff = 'n/a', 'n/a'
- tests_compatible = 0
- print('%30s: %5.0fms %5.0fms %7s %5.0fms %5.0fms %7s' % \
- (name,
- min_time * MILLI_SECONDS,
- other_min_time * MILLI_SECONDS * compare_to.warp / self.warp,
- min_diff,
- avg_time * MILLI_SECONDS,
- other_avg_time * MILLI_SECONDS * compare_to.warp / self.warp,
- avg_diff))
- print('-' * LINE)
-
- # Summarise test results
- if not benchmarks_compatible or not tests_compatible:
- min_diff, avg_diff = 'n/a', 'n/a'
- else:
- if other_total_min_time != 0.0:
- min_diff = '%+5.1f%%' % (
- ((total_min_time * self.warp) /
- (other_total_min_time * compare_to.warp) - 1.0) * PERCENT)
- else:
- min_diff = 'n/a'
- if other_total_avg_time != 0.0:
- avg_diff = '%+5.1f%%' % (
- ((total_avg_time * self.warp) /
- (other_total_avg_time * compare_to.warp) - 1.0) * PERCENT)
- else:
- avg_diff = 'n/a'
- print('Totals: '
- ' %5.0fms %5.0fms %7s %5.0fms %5.0fms %7s' %
- (total_min_time * MILLI_SECONDS,
- (other_total_min_time * compare_to.warp/self.warp
- * MILLI_SECONDS),
- min_diff,
- total_avg_time * MILLI_SECONDS,
- (other_total_avg_time * compare_to.warp/self.warp
- * MILLI_SECONDS),
- avg_diff
- ))
- print()
- print('(this=%s, other=%s)' % (self.name,
- compare_to.name))
- print()
-
-class PyBenchCmdline(Application):
-
- header = ("PYBENCH - a benchmark test suite for Python "
- "interpreters/compilers.")
-
- version = __version__
-
- debug = _debug
-
- options = [ArgumentOption('-n',
- 'number of rounds',
- Setup.Number_of_rounds),
- ArgumentOption('-f',
- 'save benchmark to file arg',
- ''),
- ArgumentOption('-c',
- 'compare benchmark with the one in file arg',
- ''),
- ArgumentOption('-s',
- 'show benchmark in file arg, then exit',
- ''),
- ArgumentOption('-w',
- 'set warp factor to arg',
- Setup.Warp_factor),
- ArgumentOption('-t',
- 'run only tests with names matching arg',
- ''),
- ArgumentOption('-C',
- 'set the number of calibration runs to arg',
- CALIBRATION_RUNS),
- SwitchOption('-d',
- 'hide noise in comparisons',
- 0),
- SwitchOption('-v',
- 'verbose output (not recommended)',
- 0),
- SwitchOption('--with-gc',
- 'enable garbage collection',
- 0),
- SwitchOption('--with-syscheck',
- 'use default sys check interval',
- 0),
- ArgumentOption('--timer',
- 'use given timer',
- TIMER_PLATFORM_DEFAULT),
- ]
-
- about = """\
-The normal operation is to run the suite and display the
-results. Use -f to save them for later reuse or comparisons.
-
-Available timers:
-
- time.time
- time.clock
- systimes.processtime
-
-Examples:
-
-python2.1 pybench.py -f p21.pybench
-python2.5 pybench.py -f p25.pybench
-python pybench.py -s p25.pybench -c p21.pybench
-"""
- copyright = __copyright__
-
- def main(self):
-
- rounds = self.values['-n']
- reportfile = self.values['-f']
- show_bench = self.values['-s']
- compare_to = self.values['-c']
- hidenoise = self.values['-d']
- warp = int(self.values['-w'])
- withgc = self.values['--with-gc']
- limitnames = self.values['-t']
- if limitnames:
- if _debug:
- print('* limiting test names to one with substring "%s"' % \
- limitnames)
- limitnames = re.compile(limitnames, re.I)
- else:
- limitnames = None
- verbose = self.verbose
- withsyscheck = self.values['--with-syscheck']
- calibration_runs = self.values['-C']
- timer = self.values['--timer']
-
- print('-' * LINE)
- print('PYBENCH %s' % __version__)
- print('-' * LINE)
- print('* using %s %s' % (
- getattr(platform, 'python_implementation', lambda:'Python')(),
- ' '.join(sys.version.split())))
-
- # Switch off garbage collection
- if not withgc:
- try:
- import gc
- except ImportError:
- print('* Python version doesn\'t support garbage collection')
- else:
- try:
- gc.disable()
- except NotImplementedError:
- print('* Python version doesn\'t support gc.disable')
- else:
- print('* disabled garbage collection')
-
- # "Disable" sys check interval
- if not withsyscheck:
- # Too bad the check interval uses an int instead of a long...
- value = 2147483647
- try:
- sys.setcheckinterval(value)
- except (AttributeError, NotImplementedError):
- print('* Python version doesn\'t support sys.setcheckinterval')
- else:
- print('* system check interval set to maximum: %s' % value)
-
- if timer == TIMER_SYSTIMES_PROCESSTIME:
- import systimes
- print('* using timer: systimes.processtime (%s)' % \
- systimes.SYSTIMES_IMPLEMENTATION)
- else:
- # Check that the clock function does exist
- try:
- get_timer(timer)
- except TypeError:
- print("* Error: Unknown timer: %s" % timer)
- return
-
- print('* using timer: %s' % timer)
- if hasattr(time, 'get_clock_info'):
- info = time.get_clock_info(timer[5:])
- print('* timer: resolution=%s, implementation=%s'
- % (info.resolution, info.implementation))
-
- print()
-
- if compare_to:
- try:
- f = open(compare_to,'rb')
- bench = pickle.load(f)
- bench.name = compare_to
- f.close()
- compare_to = bench
- except IOError as reason:
- print('* Error opening/reading file %s: %s' % (
- repr(compare_to),
- reason))
- compare_to = None
-
- if show_bench:
- try:
- f = open(show_bench,'rb')
- bench = pickle.load(f)
- bench.name = show_bench
- f.close()
- bench.print_header()
- if compare_to:
- bench.print_comparison(compare_to,
- hidenoise=hidenoise,
- limitnames=limitnames)
- else:
- bench.print_benchmark(hidenoise=hidenoise,
- limitnames=limitnames)
- except IOError as reason:
- print('* Error opening/reading file %s: %s' % (
- repr(show_bench),
- reason))
- print()
- return
-
- if reportfile:
- print('Creating benchmark: %s (rounds=%i, warp=%i)' % \
- (reportfile, rounds, warp))
- print()
-
- # Create benchmark object
- bench = Benchmark(reportfile,
- verbose=verbose,
- timer=timer,
- warp=warp,
- calibration_runs=calibration_runs)
- bench.rounds = rounds
- bench.load_tests(Setup, limitnames=limitnames)
- try:
- bench.calibrate()
- bench.run()
- except KeyboardInterrupt:
- print()
- print('*** KeyboardInterrupt -- Aborting')
- print()
- return
- bench.print_header()
- if compare_to:
- bench.print_comparison(compare_to,
- hidenoise=hidenoise,
- limitnames=limitnames)
- else:
- bench.print_benchmark(hidenoise=hidenoise,
- limitnames=limitnames)
-
- # Ring bell
- sys.stderr.write('\007')
-
- if reportfile:
- try:
- f = open(reportfile,'wb')
- bench.name = reportfile
- pickle.dump(bench,f)
- f.close()
- except IOError as reason:
- print('* Error opening/writing reportfile %s: %s' % (
- reportfile,
- reason))
- print()
-
-if __name__ == '__main__':
- PyBenchCmdline()
+++ /dev/null
-#!/usr/bin/env python
-
-""" systimes() user and system timer implementations for use by
- pybench.
-
- This module implements various different strategies for measuring
- performance timings. It tries to choose the best available method
- based on the platform and available tools.
-
- On Windows, it is recommended to have the Mark Hammond win32
- package installed. Alternatively, the Thomas Heller ctypes
- packages can also be used.
-
- On Unix systems, the standard resource module provides the highest
- resolution timings. Unfortunately, it is not available on all Unix
- platforms.
-
- If no supported timing methods based on process time can be found,
- the module reverts to the highest resolution wall-clock timer
- instead. The system time part will then always be 0.0.
-
- The module exports one public API:
-
- def systimes():
-
- Return the current timer values for measuring user and system
- time as tuple of seconds (user_time, system_time).
-
- Copyright (c) 2006, Marc-Andre Lemburg (mal@egenix.com). See the
- documentation for further information on copyrights, or contact
- the author. All Rights Reserved.
-
-"""
-
-from __future__ import print_function
-
-import time, sys
-
-#
-# Note: Please keep this module compatible to Python 1.5.2.
-#
-# TODOs:
-#
-# * Add ctypes wrapper for new clock_gettime() real-time POSIX APIs;
-# these will then provide nano-second resolution where available.
-#
-# * Add a function that returns the resolution of systimes()
-# values, ie. systimesres().
-#
-
-### Choose an implementation
-
-SYSTIMES_IMPLEMENTATION = None
-USE_CTYPES_GETPROCESSTIMES = 'ctypes GetProcessTimes() wrapper'
-USE_WIN32PROCESS_GETPROCESSTIMES = 'win32process.GetProcessTimes()'
-USE_RESOURCE_GETRUSAGE = 'resource.getrusage()'
-USE_PROCESS_TIME_CLOCK = 'time.clock() (process time)'
-USE_WALL_TIME_CLOCK = 'time.clock() (wall-clock)'
-USE_WALL_TIME_TIME = 'time.time() (wall-clock)'
-
-if sys.platform[:3] == 'win':
- # Windows platform
- try:
- import win32process
- except ImportError:
- try:
- import ctypes
- except ImportError:
- # Use the wall-clock implementation time.clock(), since this
- # is the highest resolution clock available on Windows
- SYSTIMES_IMPLEMENTATION = USE_WALL_TIME_CLOCK
- else:
- SYSTIMES_IMPLEMENTATION = USE_CTYPES_GETPROCESSTIMES
- else:
- SYSTIMES_IMPLEMENTATION = USE_WIN32PROCESS_GETPROCESSTIMES
-else:
- # All other platforms
- try:
- import resource
- except ImportError:
- pass
- else:
- SYSTIMES_IMPLEMENTATION = USE_RESOURCE_GETRUSAGE
-
-# Fall-back solution
-if SYSTIMES_IMPLEMENTATION is None:
- # Check whether we can use time.clock() as approximation
- # for systimes()
- start = time.clock()
- time.sleep(0.1)
- stop = time.clock()
- if stop - start < 0.001:
- # Looks like time.clock() is usable (and measures process
- # time)
- SYSTIMES_IMPLEMENTATION = USE_PROCESS_TIME_CLOCK
- else:
- # Use wall-clock implementation time.time() since this provides
- # the highest resolution clock on most systems
- SYSTIMES_IMPLEMENTATION = USE_WALL_TIME_TIME
-
-### Implementations
-
-def getrusage_systimes():
- return resource.getrusage(resource.RUSAGE_SELF)[:2]
-
-def process_time_clock_systimes():
- return (time.clock(), 0.0)
-
-def wall_clock_clock_systimes():
- return (time.clock(), 0.0)
-
-def wall_clock_time_systimes():
- return (time.time(), 0.0)
-
-# Number of clock ticks per second for the values returned
-# by GetProcessTimes() on Windows.
-#
-# Note: Ticks returned by GetProcessTimes() are 100ns intervals on
-# Windows XP. However, the process times are only updated with every
-# clock tick and the frequency of these is somewhat lower: depending
-# on the OS version between 10ms and 15ms. Even worse, the process
-# time seems to be allocated to process currently running when the
-# clock interrupt arrives, ie. it is possible that the current time
-# slice gets accounted to a different process.
-
-WIN32_PROCESS_TIMES_TICKS_PER_SECOND = 1e7
-
-def win32process_getprocesstimes_systimes():
- d = win32process.GetProcessTimes(win32process.GetCurrentProcess())
- return (d['UserTime'] / WIN32_PROCESS_TIMES_TICKS_PER_SECOND,
- d['KernelTime'] / WIN32_PROCESS_TIMES_TICKS_PER_SECOND)
-
-def ctypes_getprocesstimes_systimes():
- creationtime = ctypes.c_ulonglong()
- exittime = ctypes.c_ulonglong()
- kerneltime = ctypes.c_ulonglong()
- usertime = ctypes.c_ulonglong()
- rc = ctypes.windll.kernel32.GetProcessTimes(
- ctypes.windll.kernel32.GetCurrentProcess(),
- ctypes.byref(creationtime),
- ctypes.byref(exittime),
- ctypes.byref(kerneltime),
- ctypes.byref(usertime))
- if not rc:
- raise TypeError('GetProcessTimes() returned an error')
- return (usertime.value / WIN32_PROCESS_TIMES_TICKS_PER_SECOND,
- kerneltime.value / WIN32_PROCESS_TIMES_TICKS_PER_SECOND)
-
-# Select the default for the systimes() function
-
-if SYSTIMES_IMPLEMENTATION is USE_RESOURCE_GETRUSAGE:
- systimes = getrusage_systimes
-
-elif SYSTIMES_IMPLEMENTATION is USE_PROCESS_TIME_CLOCK:
- systimes = process_time_clock_systimes
-
-elif SYSTIMES_IMPLEMENTATION is USE_WALL_TIME_CLOCK:
- systimes = wall_clock_clock_systimes
-
-elif SYSTIMES_IMPLEMENTATION is USE_WALL_TIME_TIME:
- systimes = wall_clock_time_systimes
-
-elif SYSTIMES_IMPLEMENTATION is USE_WIN32PROCESS_GETPROCESSTIMES:
- systimes = win32process_getprocesstimes_systimes
-
-elif SYSTIMES_IMPLEMENTATION is USE_CTYPES_GETPROCESSTIMES:
- systimes = ctypes_getprocesstimes_systimes
-
-else:
- raise TypeError('no suitable systimes() implementation found')
-
-def processtime():
-
- """ Return the total time spent on the process.
-
- This is the sum of user and system time as returned by
- systimes().
-
- """
- user, system = systimes()
- return user + system
-
-### Testing
-
-def some_workload():
- x = 0
- for i in range(10000000):
- x = x + 1
-
-def test_workload():
- print('Testing systimes() under load conditions')
- t0 = systimes()
- some_workload()
- t1 = systimes()
- print('before:', t0)
- print('after:', t1)
- print('differences:', (t1[0] - t0[0], t1[1] - t0[1]))
- print()
-
-def test_idle():
- print('Testing systimes() under idle conditions')
- t0 = systimes()
- time.sleep(1)
- t1 = systimes()
- print('before:', t0)
- print('after:', t1)
- print('differences:', (t1[0] - t0[0], t1[1] - t0[1]))
- print()
-
-if __name__ == '__main__':
- print('Using %s as timer' % SYSTIMES_IMPLEMENTATION)
- print()
- test_workload()
- test_idle()
projects / python / commitdiff