1#!/usr/local/bin/python -O 2 3""" A Python Benchmark Suite 4 5""" 6# 7# Note: Please keep this module compatible to Python 1.5.2. 8# 9# Tests may include features in later Python versions, but these 10# should then be embedded in try-except clauses in the configuration 11# module Setup.py. 12# 13 14# pybench Copyright 15__copyright__ = """\ 16Copyright (c), 1997-2006, Marc-Andre Lemburg (mal@lemburg.com) 17Copyright (c), 2000-2006, eGenix.com Software GmbH (info@egenix.com) 18 19 All Rights Reserved. 20 21Permission to use, copy, modify, and distribute this software and its 22documentation for any purpose and without fee or royalty is hereby 23granted, provided that the above copyright notice appear in all copies 24and that both that copyright notice and this permission notice appear 25in supporting documentation or portions thereof, including 26modifications, that you make. 27 28THE AUTHOR MARC-ANDRE LEMBURG DISCLAIMS ALL WARRANTIES WITH REGARD TO 29THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND 30FITNESS, IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, 31INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING 32FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, 33NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION 34WITH THE USE OR PERFORMANCE OF THIS SOFTWARE ! 35""" 36 37import sys, time, operator, string, platform 38from CommandLine import * 39 40try: 41 import cPickle 42 pickle = cPickle 43except ImportError: 44 import pickle 45 46# Version number; version history: see README file ! 47__version__ = '2.0' 48 49### Constants 50 51# Second fractions 52MILLI_SECONDS = 1e3 53MICRO_SECONDS = 1e6 54 55# Percent unit 56PERCENT = 100 57 58# Horizontal line length 59LINE = 79 60 61# Minimum test run-time 62MIN_TEST_RUNTIME = 1e-3 63 64# Number of calibration runs to use for calibrating the tests 65CALIBRATION_RUNS = 20 66 67# Number of calibration loops to run for each calibration run 68CALIBRATION_LOOPS = 20 69 70# Allow skipping calibration ? 71ALLOW_SKIPPING_CALIBRATION = 1 72 73# Timer types 74TIMER_TIME_TIME = 'time.time' 75TIMER_TIME_CLOCK = 'time.clock' 76TIMER_SYSTIMES_PROCESSTIME = 'systimes.processtime' 77 78# Choose platform default timer 79if sys.platform[:3] == 'win': 80 # On WinXP this has 2.5ms resolution 81 TIMER_PLATFORM_DEFAULT = TIMER_TIME_CLOCK 82else: 83 # On Linux this has 1ms resolution 84 TIMER_PLATFORM_DEFAULT = TIMER_TIME_TIME 85 86# Print debug information ? 87_debug = 0 88 89### Helpers 90 91def get_timer(timertype): 92 93 if timertype == TIMER_TIME_TIME: 94 return time.time 95 elif timertype == TIMER_TIME_CLOCK: 96 return time.clock 97 elif timertype == TIMER_SYSTIMES_PROCESSTIME: 98 import systimes 99 return systimes.processtime 100 else: 101 raise TypeError('unknown timer type: %s' % timertype) 102 103def get_machine_details(): 104 105 if _debug: 106 print 'Getting machine details...' 107 buildno, builddate = platform.python_build() 108 python = platform.python_version() 109 try: 110 unichr(100000) 111 except ValueError: 112 # UCS2 build (standard) 113 unicode = 'UCS2' 114 except NameError: 115 unicode = None 116 else: 117 # UCS4 build (most recent Linux distros) 118 unicode = 'UCS4' 119 bits, linkage = platform.architecture() 120 return { 121 'platform': platform.platform(), 122 'processor': platform.processor(), 123 'executable': sys.executable, 124 'implementation': getattr(platform, 'python_implementation', 125 lambda:'n/a')(), 126 'python': platform.python_version(), 127 'compiler': platform.python_compiler(), 128 'buildno': buildno, 129 'builddate': builddate, 130 'unicode': unicode, 131 'bits': bits, 132 } 133 134def print_machine_details(d, indent=''): 135 136 l = ['Machine Details:', 137 ' Platform ID: %s' % d.get('platform', 'n/a'), 138 ' Processor: %s' % d.get('processor', 'n/a'), 139 '', 140 'Python:', 141 ' Implementation: %s' % d.get('implementation', 'n/a'), 142 ' Executable: %s' % d.get('executable', 'n/a'), 143 ' Version: %s' % d.get('python', 'n/a'), 144 ' Compiler: %s' % d.get('compiler', 'n/a'), 145 ' Bits: %s' % d.get('bits', 'n/a'), 146 ' Build: %s (#%s)' % (d.get('builddate', 'n/a'), 147 d.get('buildno', 'n/a')), 148 ' Unicode: %s' % d.get('unicode', 'n/a'), 149 ] 150 print indent + string.join(l, '\n' + indent) + '\n' 151 152### Test baseclass 153 154class Test: 155 156 """ All test must have this class as baseclass. It provides 157 the necessary interface to the benchmark machinery. 158 159 The tests must set .rounds to a value high enough to let the 160 test run between 20-50 seconds. This is needed because 161 clock()-timing only gives rather inaccurate values (on Linux, 162 for example, it is accurate to a few hundreths of a 163 second). If you don't want to wait that long, use a warp 164 factor larger than 1. 165 166 It is also important to set the .operations variable to a 167 value representing the number of "virtual operations" done per 168 call of .run(). 169 170 If you change a test in some way, don't forget to increase 171 its version number. 172 173 """ 174 175 ### Instance variables that each test should override 176 177 # Version number of the test as float (x.yy); this is important 178 # for comparisons of benchmark runs - tests with unequal version 179 # number will not get compared. 180 version = 2.0 181 182 # The number of abstract operations done in each round of the 183 # test. An operation is the basic unit of what you want to 184 # measure. The benchmark will output the amount of run-time per 185 # operation. Note that in order to raise the measured timings 186 # significantly above noise level, it is often required to repeat 187 # sets of operations more than once per test round. The measured 188 # overhead per test round should be less than 1 second. 189 operations = 1 190 191 # Number of rounds to execute per test run. This should be 192 # adjusted to a figure that results in a test run-time of between 193 # 1-2 seconds. 194 rounds = 100000 195 196 ### Internal variables 197 198 # Mark this class as implementing a test 199 is_a_test = 1 200 201 # Last timing: (real, run, overhead) 202 last_timing = (0.0, 0.0, 0.0) 203 204 # Warp factor to use for this test 205 warp = 1 206 207 # Number of calibration runs to use 208 calibration_runs = CALIBRATION_RUNS 209 210 # List of calibration timings 211 overhead_times = None 212 213 # List of test run timings 214 times = [] 215 216 # Timer used for the benchmark 217 timer = TIMER_PLATFORM_DEFAULT 218 219 def __init__(self, warp=None, calibration_runs=None, timer=None): 220 221 # Set parameters 222 if warp is not None: 223 self.rounds = int(self.rounds / warp) 224 if self.rounds == 0: 225 raise ValueError('warp factor set too high') 226 self.warp = warp 227 if calibration_runs is not None: 228 if (not ALLOW_SKIPPING_CALIBRATION and 229 calibration_runs < 1): 230 raise ValueError('at least one calibration run is required') 231 self.calibration_runs = calibration_runs 232 if timer is not None: 233 self.timer = timer 234 235 # Init variables 236 self.times = [] 237 self.overhead_times = [] 238 239 # We want these to be in the instance dict, so that pickle 240 # saves them 241 self.version = self.version 242 self.operations = self.operations 243 self.rounds = self.rounds 244 245 def get_timer(self): 246 247 """ Return the timer function to use for the test. 248 249 """ 250 return get_timer(self.timer) 251 252 def compatible(self, other): 253 254 """ Return 1/0 depending on whether the test is compatible 255 with the other Test instance or not. 256 257 """ 258 if self.version != other.version: 259 return 0 260 if self.rounds != other.rounds: 261 return 0 262 return 1 263 264 def calibrate_test(self): 265 266 if self.calibration_runs == 0: 267 self.overhead_times = [0.0] 268 return 269 270 calibrate = self.calibrate 271 timer = self.get_timer() 272 calibration_loops = range(CALIBRATION_LOOPS) 273 274 # Time the calibration loop overhead 275 prep_times = [] 276 for i in range(self.calibration_runs): 277 t = timer() 278 for i in calibration_loops: 279 pass 280 t = timer() - t 281 prep_times.append(t / CALIBRATION_LOOPS) 282 min_prep_time = min(prep_times) 283 if _debug: 284 print 285 print 'Calib. prep time = %.6fms' % ( 286 min_prep_time * MILLI_SECONDS) 287 288 # Time the calibration runs (doing CALIBRATION_LOOPS loops of 289 # .calibrate() method calls each) 290 for i in range(self.calibration_runs): 291 t = timer() 292 for i in calibration_loops: 293 calibrate() 294 t = timer() - t 295 self.overhead_times.append(t / CALIBRATION_LOOPS 296 - min_prep_time) 297 298 # Check the measured times 299 min_overhead = min(self.overhead_times) 300 max_overhead = max(self.overhead_times) 301 if _debug: 302 print 'Calib. overhead time = %.6fms' % ( 303 min_overhead * MILLI_SECONDS) 304 if min_overhead < 0.0: 305 raise ValueError('calibration setup did not work') 306 if max_overhead - min_overhead > 0.1: 307 raise ValueError( 308 'overhead calibration timing range too inaccurate: ' 309 '%r - %r' % (min_overhead, max_overhead)) 310 311 def run(self): 312 313 """ Run the test in two phases: first calibrate, then 314 do the actual test. Be careful to keep the calibration 315 timing low w/r to the test timing. 316 317 """ 318 test = self.test 319 timer = self.get_timer() 320 321 # Get calibration 322 min_overhead = min(self.overhead_times) 323 324 # Test run 325 t = timer() 326 test() 327 t = timer() - t 328 if t < MIN_TEST_RUNTIME: 329 raise ValueError('warp factor too high: ' 330 'test times are < 10ms') 331 eff_time = t - min_overhead 332 if eff_time < 0: 333 raise ValueError('wrong calibration') 334 self.last_timing = (eff_time, t, min_overhead) 335 self.times.append(eff_time) 336 337 def calibrate(self): 338 339 """ Calibrate the test. 340 341 This method should execute everything that is needed to 342 setup and run the test - except for the actual operations 343 that you intend to measure. pybench uses this method to 344 measure the test implementation overhead. 345 346 """ 347 return 348 349 def test(self): 350 351 """ Run the test. 352 353 The test needs to run self.rounds executing 354 self.operations number of operations each. 355 356 """ 357 return 358 359 def stat(self): 360 361 """ Return test run statistics as tuple: 362 363 (minimum run time, 364 average run time, 365 total run time, 366 average time per operation, 367 minimum overhead time) 368 369 """ 370 runs = len(self.times) 371 if runs == 0: 372 return 0.0, 0.0, 0.0, 0.0 373 min_time = min(self.times) 374 total_time = reduce(operator.add, self.times, 0.0) 375 avg_time = total_time / float(runs) 376 operation_avg = total_time / float(runs 377 * self.rounds 378 * self.operations) 379 if self.overhead_times: 380 min_overhead = min(self.overhead_times) 381 else: 382 min_overhead = self.last_timing[2] 383 return min_time, avg_time, total_time, operation_avg, min_overhead 384 385### Load Setup 386 387# This has to be done after the definition of the Test class, since 388# the Setup module will import subclasses using this class. 389 390import Setup 391 392### Benchmark base class 393 394class Benchmark: 395 396 # Name of the benchmark 397 name = '' 398 399 # Number of benchmark rounds to run 400 rounds = 1 401 402 # Warp factor use to run the tests 403 warp = 1 # Warp factor 404 405 # Average benchmark round time 406 roundtime = 0 407 408 # Benchmark version number as float x.yy 409 version = 2.0 410 411 # Produce verbose output ? 412 verbose = 0 413 414 # Dictionary with the machine details 415 machine_details = None 416 417 # Timer used for the benchmark 418 timer = TIMER_PLATFORM_DEFAULT 419 420 def __init__(self, name, verbose=None, timer=None, warp=None, 421 calibration_runs=None): 422 423 if name: 424 self.name = name 425 else: 426 self.name = '%04i-%02i-%02i %02i:%02i:%02i' % \ 427 (time.localtime(time.time())[:6]) 428 if verbose is not None: 429 self.verbose = verbose 430 if timer is not None: 431 self.timer = timer 432 if warp is not None: 433 self.warp = warp 434 if calibration_runs is not None: 435 self.calibration_runs = calibration_runs 436 437 # Init vars 438 self.tests = {} 439 if _debug: 440 print 'Getting machine details...' 441 self.machine_details = get_machine_details() 442 443 # Make .version an instance attribute to have it saved in the 444 # Benchmark pickle 445 self.version = self.version 446 447 def get_timer(self): 448 449 """ Return the timer function to use for the test. 450 451 """ 452 return get_timer(self.timer) 453 454 def compatible(self, other): 455 456 """ Return 1/0 depending on whether the benchmark is 457 compatible with the other Benchmark instance or not. 458 459 """ 460 if self.version != other.version: 461 return 0 462 if (self.machine_details == other.machine_details and 463 self.timer != other.timer): 464 return 0 465 if (self.calibration_runs == 0 and 466 other.calibration_runs != 0): 467 return 0 468 if (self.calibration_runs != 0 and 469 other.calibration_runs == 0): 470 return 0 471 return 1 472 473 def load_tests(self, setupmod, limitnames=None): 474 475 # Add tests 476 if self.verbose: 477 print 'Searching for tests ...' 478 print '--------------------------------------' 479 for testclass in setupmod.__dict__.values(): 480 if not hasattr(testclass, 'is_a_test'): 481 continue 482 name = testclass.__name__ 483 if name == 'Test': 484 continue 485 if (limitnames is not None and 486 limitnames.search(name) is None): 487 continue 488 self.tests[name] = testclass( 489 warp=self.warp, 490 calibration_runs=self.calibration_runs, 491 timer=self.timer) 492 l = self.tests.keys() 493 l.sort() 494 if self.verbose: 495 for name in l: 496 print ' %s' % name 497 print '--------------------------------------' 498 print ' %i tests found' % len(l) 499 print 500 501 def calibrate(self): 502 503 print 'Calibrating tests. Please wait...', 504 sys.stdout.flush() 505 if self.verbose: 506 print 507 print 508 print 'Test min max' 509 print '-' * LINE 510 tests = self.tests.items() 511 tests.sort() 512 for i in range(len(tests)): 513 name, test = tests[i] 514 test.calibrate_test() 515 if self.verbose: 516 print '%30s: %6.3fms %6.3fms' % \ 517 (name, 518 min(test.overhead_times) * MILLI_SECONDS, 519 max(test.overhead_times) * MILLI_SECONDS) 520 if self.verbose: 521 print 522 print 'Done with the calibration.' 523 else: 524 print 'done.' 525 print 526 527 def run(self): 528 529 tests = self.tests.items() 530 tests.sort() 531 timer = self.get_timer() 532 print 'Running %i round(s) of the suite at warp factor %i:' % \ 533 (self.rounds, self.warp) 534 print 535 self.roundtimes = [] 536 for i in range(self.rounds): 537 if self.verbose: 538 print ' Round %-25i effective absolute overhead' % (i+1) 539 total_eff_time = 0.0 540 for j in range(len(tests)): 541 name, test = tests[j] 542 if self.verbose: 543 print '%30s:' % name, 544 test.run() 545 (eff_time, abs_time, min_overhead) = test.last_timing 546 total_eff_time = total_eff_time + eff_time 547 if self.verbose: 548 print ' %5.0fms %5.0fms %7.3fms' % \ 549 (eff_time * MILLI_SECONDS, 550 abs_time * MILLI_SECONDS, 551 min_overhead * MILLI_SECONDS) 552 self.roundtimes.append(total_eff_time) 553 if self.verbose: 554 print (' ' 555 ' ------------------------------') 556 print (' ' 557 ' Totals: %6.0fms' % 558 (total_eff_time * MILLI_SECONDS)) 559 print 560 else: 561 print '* Round %i done in %.3f seconds.' % (i+1, 562 total_eff_time) 563 print 564 565 def stat(self): 566 567 """ Return benchmark run statistics as tuple: 568 569 (minimum round time, 570 average round time, 571 maximum round time) 572 573 XXX Currently not used, since the benchmark does test 574 statistics across all rounds. 575 576 """ 577 runs = len(self.roundtimes) 578 if runs == 0: 579 return 0.0, 0.0 580 min_time = min(self.roundtimes) 581 total_time = reduce(operator.add, self.roundtimes, 0.0) 582 avg_time = total_time / float(runs) 583 max_time = max(self.roundtimes) 584 return (min_time, avg_time, max_time) 585 586 def print_header(self, title='Benchmark'): 587 588 print '-' * LINE 589 print '%s: %s' % (title, self.name) 590 print '-' * LINE 591 print 592 print ' Rounds: %s' % self.rounds 593 print ' Warp: %s' % self.warp 594 print ' Timer: %s' % self.timer 595 print 596 if self.machine_details: 597 print_machine_details(self.machine_details, indent=' ') 598 print 599 600 def print_benchmark(self, hidenoise=0, limitnames=None): 601 602 print ('Test ' 603 ' minimum average operation overhead') 604 print '-' * LINE 605 tests = self.tests.items() 606 tests.sort() 607 total_min_time = 0.0 608 total_avg_time = 0.0 609 for name, test in tests: 610 if (limitnames is not None and 611 limitnames.search(name) is None): 612 continue 613 (min_time, 614 avg_time, 615 total_time, 616 op_avg, 617 min_overhead) = test.stat() 618 total_min_time = total_min_time + min_time 619 total_avg_time = total_avg_time + avg_time 620 print '%30s: %5.0fms %5.0fms %6.2fus %7.3fms' % \ 621 (name, 622 min_time * MILLI_SECONDS, 623 avg_time * MILLI_SECONDS, 624 op_avg * MICRO_SECONDS, 625 min_overhead *MILLI_SECONDS) 626 print '-' * LINE 627 print ('Totals: ' 628 ' %6.0fms %6.0fms' % 629 (total_min_time * MILLI_SECONDS, 630 total_avg_time * MILLI_SECONDS, 631 )) 632 print 633 634 def print_comparison(self, compare_to, hidenoise=0, limitnames=None): 635 636 # Check benchmark versions 637 if compare_to.version != self.version: 638 print ('* Benchmark versions differ: ' 639 'cannot compare this benchmark to "%s" !' % 640 compare_to.name) 641 print 642 self.print_benchmark(hidenoise=hidenoise, 643 limitnames=limitnames) 644 return 645 646 # Print header 647 compare_to.print_header('Comparing with') 648 print ('Test ' 649 ' minimum run-time average run-time') 650 print (' ' 651 ' this other diff this other diff') 652 print '-' * LINE 653 654 # Print test comparisons 655 tests = self.tests.items() 656 tests.sort() 657 total_min_time = other_total_min_time = 0.0 658 total_avg_time = other_total_avg_time = 0.0 659 benchmarks_compatible = self.compatible(compare_to) 660 tests_compatible = 1 661 for name, test in tests: 662 if (limitnames is not None and 663 limitnames.search(name) is None): 664 continue 665 (min_time, 666 avg_time, 667 total_time, 668 op_avg, 669 min_overhead) = test.stat() 670 total_min_time = total_min_time + min_time 671 total_avg_time = total_avg_time + avg_time 672 try: 673 other = compare_to.tests[name] 674 except KeyError: 675 other = None 676 if other is None: 677 # Other benchmark doesn't include the given test 678 min_diff, avg_diff = 'n/a', 'n/a' 679 other_min_time = 0.0 680 other_avg_time = 0.0 681 tests_compatible = 0 682 else: 683 (other_min_time, 684 other_avg_time, 685 other_total_time, 686 other_op_avg, 687 other_min_overhead) = other.stat() 688 other_total_min_time = other_total_min_time + other_min_time 689 other_total_avg_time = other_total_avg_time + other_avg_time 690 if (benchmarks_compatible and 691 test.compatible(other)): 692 # Both benchmark and tests are comparable 693 min_diff = ((min_time * self.warp) / 694 (other_min_time * other.warp) - 1.0) 695 avg_diff = ((avg_time * self.warp) / 696 (other_avg_time * other.warp) - 1.0) 697 if hidenoise and abs(min_diff) < 10.0: 698 min_diff = '' 699 else: 700 min_diff = '%+5.1f%%' % (min_diff * PERCENT) 701 if hidenoise and abs(avg_diff) < 10.0: 702 avg_diff = '' 703 else: 704 avg_diff = '%+5.1f%%' % (avg_diff * PERCENT) 705 else: 706 # Benchmark or tests are not comparable 707 min_diff, avg_diff = 'n/a', 'n/a' 708 tests_compatible = 0 709 print '%30s: %5.0fms %5.0fms %7s %5.0fms %5.0fms %7s' % \ 710 (name, 711 min_time * MILLI_SECONDS, 712 other_min_time * MILLI_SECONDS * compare_to.warp / self.warp, 713 min_diff, 714 avg_time * MILLI_SECONDS, 715 other_avg_time * MILLI_SECONDS * compare_to.warp / self.warp, 716 avg_diff) 717 print '-' * LINE 718 719 # Summarise test results 720 if not benchmarks_compatible or not tests_compatible: 721 min_diff, avg_diff = 'n/a', 'n/a' 722 else: 723 if other_total_min_time != 0.0: 724 min_diff = '%+5.1f%%' % ( 725 ((total_min_time * self.warp) / 726 (other_total_min_time * compare_to.warp) - 1.0) * PERCENT) 727 else: 728 min_diff = 'n/a' 729 if other_total_avg_time != 0.0: 730 avg_diff = '%+5.1f%%' % ( 731 ((total_avg_time * self.warp) / 732 (other_total_avg_time * compare_to.warp) - 1.0) * PERCENT) 733 else: 734 avg_diff = 'n/a' 735 print ('Totals: ' 736 ' %5.0fms %5.0fms %7s %5.0fms %5.0fms %7s' % 737 (total_min_time * MILLI_SECONDS, 738 (other_total_min_time * compare_to.warp/self.warp 739 * MILLI_SECONDS), 740 min_diff, 741 total_avg_time * MILLI_SECONDS, 742 (other_total_avg_time * compare_to.warp/self.warp 743 * MILLI_SECONDS), 744 avg_diff 745 )) 746 print 747 print '(this=%s, other=%s)' % (self.name, 748 compare_to.name) 749 print 750 751class PyBenchCmdline(Application): 752 753 header = ("PYBENCH - a benchmark test suite for Python " 754 "interpreters/compilers.") 755 756 version = __version__ 757 758 debug = _debug 759 760 options = [ArgumentOption('-n', 761 'number of rounds', 762 Setup.Number_of_rounds), 763 ArgumentOption('-f', 764 'save benchmark to file arg', 765 ''), 766 ArgumentOption('-c', 767 'compare benchmark with the one in file arg', 768 ''), 769 ArgumentOption('-s', 770 'show benchmark in file arg, then exit', 771 ''), 772 ArgumentOption('-w', 773 'set warp factor to arg', 774 Setup.Warp_factor), 775 ArgumentOption('-t', 776 'run only tests with names matching arg', 777 ''), 778 ArgumentOption('-C', 779 'set the number of calibration runs to arg', 780 CALIBRATION_RUNS), 781 SwitchOption('-d', 782 'hide noise in comparisons', 783 0), 784 SwitchOption('-v', 785 'verbose output (not recommended)', 786 0), 787 SwitchOption('--with-gc', 788 'enable garbage collection', 789 0), 790 SwitchOption('--with-syscheck', 791 'use default sys check interval', 792 0), 793 ArgumentOption('--timer', 794 'use given timer', 795 TIMER_PLATFORM_DEFAULT), 796 ] 797 798 about = """\ 799The normal operation is to run the suite and display the 800results. Use -f to save them for later reuse or comparisons. 801 802Available timers: 803 804 time.time 805 time.clock 806 systimes.processtime 807 808Examples: 809 810python2.1 pybench.py -f p21.pybench 811python2.5 pybench.py -f p25.pybench 812python pybench.py -s p25.pybench -c p21.pybench 813""" 814 copyright = __copyright__ 815 816 def main(self): 817 818 rounds = self.values['-n'] 819 reportfile = self.values['-f'] 820 show_bench = self.values['-s'] 821 compare_to = self.values['-c'] 822 hidenoise = self.values['-d'] 823 warp = int(self.values['-w']) 824 withgc = self.values['--with-gc'] 825 limitnames = self.values['-t'] 826 if limitnames: 827 if _debug: 828 print '* limiting test names to one with substring "%s"' % \ 829 limitnames 830 limitnames = re.compile(limitnames, re.I) 831 else: 832 limitnames = None 833 verbose = self.verbose 834 withsyscheck = self.values['--with-syscheck'] 835 calibration_runs = self.values['-C'] 836 timer = self.values['--timer'] 837 838 print '-' * LINE 839 print 'PYBENCH %s' % __version__ 840 print '-' * LINE 841 print '* using %s %s' % ( 842 getattr(platform, 'python_implementation', lambda:'Python')(), 843 string.join(string.split(sys.version), ' ')) 844 845 # Switch off garbage collection 846 if not withgc: 847 try: 848 import gc 849 except ImportError: 850 print '* Python version doesn\'t support garbage collection' 851 else: 852 try: 853 gc.disable() 854 except NotImplementedError: 855 print '* Python version doesn\'t support gc.disable' 856 else: 857 print '* disabled garbage collection' 858 859 # "Disable" sys check interval 860 if not withsyscheck: 861 # Too bad the check interval uses an int instead of a long... 862 value = 2147483647 863 try: 864 sys.setcheckinterval(value) 865 except (AttributeError, NotImplementedError): 866 print '* Python version doesn\'t support sys.setcheckinterval' 867 else: 868 print '* system check interval set to maximum: %s' % value 869 870 if timer == TIMER_SYSTIMES_PROCESSTIME: 871 import systimes 872 print '* using timer: systimes.processtime (%s)' % \ 873 systimes.SYSTIMES_IMPLEMENTATION 874 else: 875 print '* using timer: %s' % timer 876 877 print 878 879 if compare_to: 880 try: 881 f = open(compare_to,'rb') 882 bench = pickle.load(f) 883 bench.name = compare_to 884 f.close() 885 compare_to = bench 886 except IOError, reason: 887 print '* Error opening/reading file %s: %s' % ( 888 repr(compare_to), 889 reason) 890 compare_to = None 891 892 if show_bench: 893 try: 894 f = open(show_bench,'rb') 895 bench = pickle.load(f) 896 bench.name = show_bench 897 f.close() 898 bench.print_header() 899 if compare_to: 900 bench.print_comparison(compare_to, 901 hidenoise=hidenoise, 902 limitnames=limitnames) 903 else: 904 bench.print_benchmark(hidenoise=hidenoise, 905 limitnames=limitnames) 906 except IOError, reason: 907 print '* Error opening/reading file %s: %s' % ( 908 repr(show_bench), 909 reason) 910 print 911 return 912 913 if reportfile: 914 print 'Creating benchmark: %s (rounds=%i, warp=%i)' % \ 915 (reportfile, rounds, warp) 916 print 917 918 # Create benchmark object 919 bench = Benchmark(reportfile, 920 verbose=verbose, 921 timer=timer, 922 warp=warp, 923 calibration_runs=calibration_runs) 924 bench.rounds = rounds 925 bench.load_tests(Setup, limitnames=limitnames) 926 try: 927 bench.calibrate() 928 bench.run() 929 except KeyboardInterrupt: 930 print 931 print '*** KeyboardInterrupt -- Aborting' 932 print 933 return 934 bench.print_header() 935 if compare_to: 936 bench.print_comparison(compare_to, 937 hidenoise=hidenoise, 938 limitnames=limitnames) 939 else: 940 bench.print_benchmark(hidenoise=hidenoise, 941 limitnames=limitnames) 942 943 # Ring bell 944 sys.stderr.write('\007') 945 946 if reportfile: 947 try: 948 f = open(reportfile,'wb') 949 bench.name = reportfile 950 pickle.dump(bench,f) 951 f.close() 952 except IOError, reason: 953 print '* Error opening/writing reportfile' 954 except IOError, reason: 955 print '* Error opening/writing reportfile %s: %s' % ( 956 reportfile, 957 reason) 958 print 959 960if __name__ == '__main__': 961 PyBenchCmdline() 962