This project has moved and is read-only. For the latest updates, please go here.

IronPython Performance Report

An automated, lightweight comparison between 'IronPython 2.6' and 'Python26'
on 02/08/2010 12:23:10.

Machine Setup

  • PC
    • Manufacturer - Dell Computer Corporation
    • Model - PowerEdge 860
    • Name - MERLIN-14
  • Software
    • Operating System - Microsoft Windows NT 6.0.6002 Service Pack 2
    • CLR Version - 2.0.50727.4200
  • CPU
    • Full Name - Intel(R) Pentium(R) D CPU 2.80GHz
    • Speed - 2800
    • Number of Cores - 2
  • RAM - 2146070528
  • Disk Drive - WDC WD1600JS-75NCB3 ATA Device


HelloWorld is a typical hello world program we've written and is used to evaluate
the startup time of a Python interpreter. Lower startup times indicate better

  • No command-line flags are passed to the Python interpreters

Best Python26 HelloWorld run (out of 5 attempts): 0.0667508 seconds
Best IronPython 2.6 HelloWorld run (out of 5 attempts): 1.7442184 seconds

PyStone 1.1

PyStone is an extremely high-level benchmark distributed with CPython. In
short, running under various implementations of Python will emit
the number of PyStones (i.e., iterations) per second that can be run on a given
machine. A higher PyStone result indicates better overall performance of a Python
interpreter. The latest copy of PyStone can be found in lib\test\
(relative to CPython installation locations).

  • By default runs 50,000 passes to determine PyStones per second. The results below were generated using this default
  • Due to site caching in the Dynamic Language Runtime, IronPython performs better with more PyStone passes than the default value

Best Python26 PyStone run (out of 5 attempts): 39166.8 PyStones/second
Best IronPython 2.6 PyStone run (out of 5 attempts): 55120.5 PyStones/second

PyBench 2.0

PyBench is a collection of low-level benchmarks distributed with CPython. Whereas
PyStone can be used to discover the overall performance of the Python interpreter,
PyBench targets specific areas (e.g., the amount of time it takes to concatenate
two strings). You can find the latest version of PyBench on CPython's Subversion
source control system (e.g.,

Please note the following:
  • Much of the platform module is broken under IPy. As such, build numbers, build dates, etc had to be faked under IPy
  • The IPy garbage collector cannot be disabled. Although this puts IPy at a disadvantage, we kept it turned off for the CPy run
  • sys.setcheckinterval does not function properly under IronPython. This is another optimization CPython gets that IronPython doesn't.
  • 1 rounds and a warp factor of 1 were used.

(this=C:\SnapTemp\IronPython 2.6, other=C:\SnapTemp\Python26)
Test min run-time this min run-time other min run-time diff avg run-time this avg run-time other avg run-time diff
BuiltinFunctionCalls: 403ms 1732ms -76.7% 403ms 1732ms -76.7%
BuiltinMethodLookup: 590ms 1948ms -69.7% 590ms 1948ms -69.7%
CompareFloats: 44ms 1083ms -96.0% 44ms 1083ms -96.0%
CompareFloatsIntegers: 325ms 1346ms -75.8% 325ms 1346ms -75.8%
CompareIntegers: 27ms 859ms -96.9% 27ms 859ms -96.9%
CompareInternedStrings: 348ms 1222ms -71.5% 348ms 1222ms -71.5%
CompareLongs: 29ms 1092ms -97.4% 29ms 1092ms -97.4%
CompareStrings: 492ms 1398ms -64.8% 492ms 1398ms -64.8%
CompareUnicode: 369ms 1125ms -67.2% 369ms 1125ms -67.2%
ComplexPythonFunctionCalls: 2180ms 2401ms -9.2% 2180ms 2401ms -9.2%
ConcatStrings: 3802ms 3957ms -3.9% 3802ms 3957ms -3.9%
ConcatUnicode: 2384ms 2661ms -10.4% 2384ms 2661ms -10.4%
CreateInstances: 808ms 2293ms -64.8% 808ms 2293ms -64.8%
CreateNewInstances: 450ms 1864ms -75.9% 450ms 1864ms -75.9%
CreateStringsWithConcat: 2629ms 1158ms 127.0% 2629ms 1158ms 127.0%
CreateUnicodeWithConcat: 870ms 1296ms -32.8% 870ms 1296ms -32.8%
DictCreation: 2368ms 1116ms 112.1% 2368ms 1116ms 112.1%
DictWithFloatKeys: 1991ms 3063ms -35.0% 1991ms 3063ms -35.0%
DictWithIntegerKeys: 1865ms 931ms 100.3% 1865ms 931ms 100.3%
DictWithStringKeys: 2052ms 1085ms 89.1% 2052ms 1085ms 89.1%
ForLoops: 577ms 671ms -14.0% 577ms 671ms -14.0%
IfThenElse: 322ms 862ms -62.6% 322ms 862ms -62.6%
ListSlicing: 3713ms 1510ms 145.8% 3713ms 1510ms 145.8%
NestedForLoops: 640ms 1139ms -43.8% 640ms 1139ms -43.8%
NormalClassAttribute: 3022ms 1293ms 133.7% 3022ms 1293ms 133.7%
NormalInstanceAttribute: 3725ms 1071ms 247.8% 3725ms 1071ms 247.8%
PythonFunctionCalls: 341ms 1663ms -79.5% 341ms 1663ms -79.5%
PythonMethodCalls: 3572ms 1848ms 93.3% 3572ms 1848ms 93.3%
Recursion: 558ms 2283ms -75.6% 558ms 2283ms -75.6%
SecondImport: 1029ms 1276ms -19.4% 1029ms 1276ms -19.4%
SecondPackageImport: 1091ms 1588ms -31.3% 1091ms 1588ms -31.3%
SecondSubmoduleImport: 1528ms 1745ms -12.4% 1528ms 1745ms -12.4%
SimpleComplexArithmetic: 668ms 1429ms -53.3% 668ms 1429ms -53.3%
SimpleDictManipulation: 2150ms 1167ms 84.1% 2150ms 1167ms 84.1%
SimpleFloatArithmetic: 511ms 1119ms -54.3% 511ms 1119ms -54.3%
SimpleIntFloatArithmetic: 526ms 775ms -32.2% 526ms 775ms -32.2%
SimpleIntegerArithmetic: 542ms 765ms -29.1% 542ms 765ms -29.1%
SimpleListManipulation: 1306ms 958ms 36.2% 1306ms 958ms 36.2%
SimpleLongArithmetic: 1090ms 1264ms -13.8% 1090ms 1264ms -13.8%
SmallLists: 2493ms 1758ms 41.8% 2493ms 1758ms 41.8%
SmallTuples: 870ms 1490ms -41.6% 870ms 1490ms -41.6%
SpecialClassAttribute: 3226ms 1145ms 181.7% 3226ms 1145ms 181.7%
SpecialInstanceAttribute: 3787ms 1261ms 200.3% 3787ms 1261ms 200.3%
StringMappings: 3118ms 2432ms 28.2% 3118ms 2432ms 28.2%
StringPredicates: 1377ms 1844ms -25.3% 1377ms 1844ms -25.3%
StringSlicing: 3067ms 1647ms 86.3% 3067ms 1647ms 86.3%
TryExcept: 322ms 591ms -45.5% 322ms 591ms -45.5%
TryFinally: 995ms 1812ms -45.1% 995ms 1812ms -45.1%
TryRaiseExcept: 65031ms 1109ms 5762.7% 65031ms 1109ms 5762.7%
TupleSlicing: 2886ms 1552ms 86.0% 2886ms 1552ms 86.0%
UnicodeMappings: 2090ms 955ms 119.0% 2090ms 955ms 119.0%
UnicodePredicates: 1437ms 1373ms 4.7% 1437ms 1373ms 4.7%
UnicodeSlicing: 3022ms 1763ms 71.4% 3022ms 1763ms 71.4%
WithFinally: 653ms 2357ms -72.3% 653ms 2357ms -72.3%
WithRaiseExcept: 73689ms 1693ms 4253.4% 73689ms 1693ms 4253.4%
Totals: 219000ms 82839ms 164.4% 219000ms 82839ms 164.4%


Much like PyStone, is a high-level benchmark intended to give the
Python user a single result indicating the overall "goodness" factor of a Python
interpreter. This benchmark is distributed with the PyPy interpreter, although
the original version was written in BCPL by Dr. Martin Richards at Cambridge
University. Lower "Average time per iteration" results indicate better performance.

Best average time per iteration for Python26 (out of 5 attempts): 609.9
Best average time per iteration for IronPython 2.6 (out of 5 attempts): 982.71

Last edited Feb 8, 2010 at 8:39 PM by dfugate, version 1


No comments yet.