maintenance/benchmarks/Benchmarker.php

   1 <?php
   2 /**
   3  * @defgroup Benchmark Benchmark
   4  * @ingroup  Maintenance
   5  */
   6
   7 /**
   8  * Base code for benchmark scripts.
   9  *
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License as published by
  12  * the Free Software Foundation; either version 2 of the License, or
  13  * (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  18  * GNU General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License along
  21  * with this program; if not, write to the Free Software Foundation, Inc.,
  22  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  23  * http://www.gnu.org/copyleft/gpl.html
  24  *
  25  * @file
  26  * @ingroup Benchmark
  27  */
  28
  29 use Wikimedia\RunningStat;
  30
  31 // @codeCoverageIgnoreStart
  32 require_once __DIR__ . '/../Maintenance.php';
  33 // @codeCoverageIgnoreEnd
  34
  35 /**
  36  * Base class for benchmark scripts.
  37  *
  38  * @ingroup Benchmark
  39  */
  40 abstract class Benchmarker extends Maintenance {
  41         protected $defaultCount = 100;
  42         private $lang;
  43
  44         public function __construct() {
  45                 parent::__construct();
  46                 $this->addOption( 'count', 'How many times to run a benchmark', false, true );
  47                 $this->addOption( 'verbose', 'Verbose logging of resource usage', false, false, 'v' );
  48         }
  49
  50         public function bench( array $benchs ) {
  51                 $this->lang = Language::factory( 'en' );
  52
  53                 $this->startBench();
  54                 $count = $this->getOption( 'count', $this->defaultCount );
  55                 $verbose = $this->hasOption( 'verbose' );
  56                 foreach ( $benchs as $key => $bench ) {
  57                         // Shortcut for simple functions
  58                         if ( is_callable( $bench ) ) {
  59                                 $bench = [ 'function' => $bench ];
  60                         }
  61
  62                         // Default to no arguments
  63                         if ( !isset( $bench['args'] ) ) {
  64                                 $bench['args'] = [];
  65                         }
  66
  67                         // Optional setup called outside time measure
  68                         if ( isset( $bench['setup'] ) ) {
  69                                 call_user_func( $bench['setup'] );
  70                         }
  71
  72                         // Run benchmarks
  73                         $stat = new RunningStat();
  74                         for ( $i = 0; $i < $count; $i++ ) {
  75                                 $t = microtime( true );
  76                                 call_user_func_array( $bench['function'], $bench['args'] );
  77                                 $t = ( microtime( true ) - $t ) * 1000;
  78                                 if ( $verbose ) {
  79                                         $this->verboseRun( $i );
  80                                 }
  81                                 $stat->addObservation( $t );
  82                         }
  83
  84                         // Name defaults to name of called function
  85                         if ( is_string( $key ) ) {
  86                                 $name = $key;
  87                         } else {
  88                                 if ( is_array( $bench['function'] ) ) {
  89                                         $name = get_class( $bench['function'][0] ) . '::' . $bench['function'][1];
  90                                 } else {
  91                                         $name = strval( $bench['function'] );
  92                                 }
  93                                 $name = sprintf( "%s(%s)",
  94                                         $name,
  95                                         implode( ', ', $bench['args'] )
  96                                 );
  97                         }
  98
  99                         $this->addResult( [
 100                                 'name' => $name,
 101                                 'count' => $stat->getCount(),
 102                                 // Get rate per second from mean (in ms)
 103                                 'rate' => $stat->getMean() == 0 ? INF : ( 1.0 / ( $stat->getMean() / 1000.0 ) ),
 104                                 'total' => $stat->getMean() * $stat->getCount(),
 105                                 'mean' => $stat->getMean(),
 106                                 'max' => $stat->max,
 107                                 'stddev' => $stat->getStdDev(),
 108                                 'usage' => [
 109                                         'mem' => memory_get_usage( true ),
 110                                         'mempeak' => memory_get_peak_usage( true ),
 111                                 ],
 112                         ] );
 113                 }
 114         }
 115
 116         public function startBench() {
 117                 $this->output(
 118                         sprintf( "Running PHP version %s (%s) on %s %s %s\n\n",
 119                                 phpversion(),
 120                                 php_uname( 'm' ),
 121                                 php_uname( 's' ),
 122                                 php_uname( 'r' ),
 123                                 php_uname( 'v' )
 124                         )
 125                 );
 126         }
 127
 128         public function addResult( $res ) {
 129                 $ret = sprintf( "%s\n  %' 6s: %d\n",
 130                         $res['name'],
 131                         'count',
 132                         $res['count']
 133                 );
 134                 $ret .= sprintf( "  %' 6s: %8.1f/s\n",
 135                         'rate',
 136                         $res['rate']
 137                 );
 138                 foreach ( [ 'total', 'mean', 'max', 'stddev' ] as $metric ) {
 139                         $ret .= sprintf( "  %' 6s: %8.2fms\n",
 140                                 $metric,
 141                                 $res[$metric]
 142                         );
 143                 }
 144
 145                 foreach ( [
 146                         'mem' => 'Current memory usage',
 147                         'mempeak' => 'Peak memory usage'
 148                 ] as $key => $label ) {
 149                         $ret .= sprintf( "%' 20s: %s\n",
 150                                 $label,
 151                                 $this->lang->formatSize( $res['usage'][$key] )
 152                         );
 153                 }
 154
 155                 $this->output( "$ret\n" );
 156         }
 157
 158         protected function verboseRun( $iteration ) {
 159                 $this->output( sprintf( "#%3d - memory: %-10s - peak: %-10s\n",
 160                         $iteration,
 161                         $this->lang->formatSize( memory_get_usage( true ) ),
 162                         $this->lang->formatSize( memory_get_peak_usage( true ) )
 163                 ) );
 164         }
 165 }