Merge "Perform a permission check on the title when changing the page language"

[lhc/web/wiklou.git] / maintenance / benchmarks / Benchmarker.php

diff --git a/maintenance/benchmarks/Benchmarker.php b/maintenance/benchmarks/Benchmarker.php
index 70dc1f4..832da4d 100644 (file)
--- a/maintenance/benchmarks/Benchmarker.php
+++ b/maintenance/benchmarks/Benchmarker.php
@@ -34,67 +34,136 @@ require_once __DIR__ . '/../Maintenance.php';
  * @ingroup Benchmark
  */
 abstract class Benchmarker extends Maintenance {
-       private $results;
+       protected $defaultCount = 100;
+       private $lang;
 
        public function __construct() {
                parent::__construct();
                $this->addOption( 'count', 'How many times to run a benchmark', false, true );
+               $this->addOption( 'verbose', 'Verbose logging of resource usage', false, false, 'v' );
        }
 
        public function bench( array $benchs ) {
-               $bench_number = 0;
-               $count = $this->getOption( 'count', 100 );
+               $this->lang = Language::factory( 'en' );
 
-               foreach ( $benchs as $bench ) {
-                       // handle empty args
-                       if ( !array_key_exists( 'args', $bench ) ) {
+               $this->startBench();
+               $count = $this->getOption( 'count', $this->defaultCount );
+               $verbose = $this->hasOption( 'verbose' );
+               foreach ( $benchs as $key => $bench ) {
+                       // Shortcut for simple functions
+                       if ( is_callable( $bench ) ) {
+                               $bench = [ 'function' => $bench ];
+                       }
+
+                       // Default to no arguments
+                       if ( !isset( $bench['args'] ) ) {
                                $bench['args'] = [];
                        }
 
-                       $bench_number++;
-                       $start = microtime( true );
+                       // Optional setup called outside time measure
+                       if ( isset( $bench['setup'] ) ) {
+                               call_user_func( $bench['setup'] );
+                       }
+
+                       // Run benchmarks
+                       $times = [];
                        for ( $i = 0; $i < $count; $i++ ) {
+                               $t = microtime( true );
                                call_user_func_array( $bench['function'], $bench['args'] );
+                               $t = ( microtime( true ) - $t ) * 1000;
+                               if ( $verbose ) {
+                                       $this->verboseRun( $i );
+                               }
+                               $times[] = $t;
                        }
-                       $delta = microtime( true ) - $start;
 
-                       // function passed as a callback
-                       if ( is_array( $bench['function'] ) ) {
-                               $ret = get_class( $bench['function'][0] ) . '->' . $bench['function'][1];
-                               $bench['function'] = $ret;
+                       // Collect metrics
+                       sort( $times, SORT_NUMERIC );
+                       $min = $times[0];
+                       $max = end( $times );
+                       if ( $count % 2 ) {
+                               $median = $times[ ( $count - 1 ) / 2 ];
+                       } else {
+                               $median = ( $times[$count / 2] + $times[$count / 2 - 1] ) / 2;
                        }
+                       $total = array_sum( $times );
+                       $mean = $total / $count;
 
-                       $this->results[$bench_number] = [
-                               'function' => $bench['function'],
-                               'arguments' => $bench['args'],
+                       // Name defaults to name of called function
+                       if ( is_string( $key ) ) {
+                               $name = $key;
+                       } else {
+                               if ( is_array( $bench['function'] ) ) {
+                                       $name = get_class( $bench['function'][0] ) . '::' . $bench['function'][1];
+                               } else {
+                                       $name = strval( $bench['function'] );
+                               }
+                               $name = sprintf( "%s(%s)",
+                                       $name,
+                                       implode( ', ', $bench['args'] )
+                               );
+                       }
+
+                       $this->addResult( [
+                               'name' => $name,
                                'count' => $count,
-                               'total' => $delta,
-                               'average' => $delta / $count,
-                       ];
+                               'total' => $total,
+                               'min' => $min,
+                               'median' => $median,
+                               'mean' => $mean,
+                               'max' => $max,
+                               'usage' => [
+                                       'mem' => memory_get_usage( true ),
+                                       'mempeak' => memory_get_peak_usage( true ),
+                               ],
+                       ] );
                }
        }
 
-       public function getFormattedResults() {
-               $ret = sprintf( "Running PHP version %s (%s) on %s %s %s\n\n",
-                       phpversion(),
-                       php_uname( 'm' ),
-                       php_uname( 's' ),
-                       php_uname( 'r' ),
-                       php_uname( 'v' )
+       public function startBench() {
+               $this->output(
+                       sprintf( "Running PHP version %s (%s) on %s %s %s\n\n",
+                               phpversion(),
+                               php_uname( 'm' ),
+                               php_uname( 's' ),
+                               php_uname( 'r' ),
+                               php_uname( 'v' )
+                       )
+               );
+       }
+
+       public function addResult( $res ) {
+               $ret = sprintf( "%s\n  %' 6s: %d\n",
+                       $res['name'],
+                       'times',
+                       $res['count']
                );
-               foreach ( $this->results as $res ) {
-                       // show function with args
-                       $ret .= sprintf( "%s times: function %s(%s) :\n",
-                               $res['count'],
-                               $res['function'],
-                               implode( ', ', $res['arguments'] )
+
+               foreach ( [ 'total', 'min', 'median', 'mean', 'max' ] as $metric ) {
+                       $ret .= sprintf( "  %' 6s: %6.2fms\n",
+                               $metric,
+                               $res[$metric]
                        );
-                       $ret .= sprintf( "   %6.2fms (%6.4fms each)\n",
-                               $res['total'] * 1e3,
-                               $res['average'] * 1e3
+               }
+
+               foreach ( [
+                       'mem' => 'Current memory usage',
+                       'mempeak' => 'Peak memory usage'
+               ] as $key => $label ) {
+                       $ret .= sprintf( "%' 20s: %s\n",
+                               $label,
+                               $this->lang->formatSize( $res['usage'][$key] )
                        );
                }
 
-               return $ret;
+               $this->output( "$ret\n" );
+       }
+
+       protected function verboseRun( $iteration ) {
+               $this->output( sprintf( "#%3d - memory: %-10s - peak: %-10s\n",
+                       $iteration,
+                       $this->lang->formatSize( memory_get_usage( true ) ),
+                       $this->lang->formatSize( memory_get_peak_usage( true ) )
+               ) );
        }
 }