XhprofData.php

Go to the documentation of this file.

<?php
use Wikimedia\RunningStat;
 
class XhprofData {
 
    protected $config;
 
    protected $hieraData;
 
    protected $inclusive;
 
    protected $complete;
 
    public function __construct( array $data, array $config = [] ) {
        $this->config = array_merge( [
            'include' => null,
            'sort' => 'wt',
        ], $config );
 
        $this->hieraData = $this->pruneData( $data );
    }
 
    public function getRawData() {
        return $this->hieraData;
    }
 
    public static function splitKey( $key ) {
        return array_pad( explode( '==>', $key, 2 ), -2, null );
    }
 
    protected function pruneData( $data ) {
        if ( !$this->config['include'] ) {
            return $data;
        }
 
        $want = array_fill_keys( $this->config['include'], true );
        $want['main()'] = true;
 
        $keep = [];
        foreach ( $data as $key => $stats ) {
            [ $parent, $child ] = self::splitKey( $key );
            if ( isset( $want[$parent] ) || isset( $want[$child] ) ) {
                $keep[$key] = $stats;
            }
        }
        return $keep;
    }
 
    public function getInclusiveMetrics() {
        if ( $this->inclusive === null ) {
            $main = $this->hieraData['main()'];
            $hasCpu = isset( $main['cpu'] );
            $hasMu = isset( $main['mu'] );
            $hasAlloc = isset( $main['alloc'] );
 
            $inclusive = [];
            foreach ( $this->hieraData as $key => $stats ) {
                [ , $child ] = self::splitKey( $key );
                if ( !isset( $inclusive[$child] ) ) {
                    $inclusive[$child] = [
                        'ct' => 0,
                        'wt' => new RunningStat(),
                    ];
                    if ( $hasCpu ) {
                        $inclusive[$child]['cpu'] = new RunningStat();
                    }
                    if ( $hasMu ) {
                        $inclusive[$child]['mu'] = new RunningStat();
                        $inclusive[$child]['pmu'] = new RunningStat();
                    }
                    if ( $hasAlloc ) {
                        $inclusive[$child]['alloc'] = new RunningStat();
                        $inclusive[$child]['free'] = new RunningStat();
                    }
                }
 
                $inclusive[$child]['ct'] += $stats['ct'];
                foreach ( $stats as $stat => $value ) {
                    if ( $stat === 'ct' ) {
                        continue;
                    }
 
                    if ( !isset( $inclusive[$child][$stat] ) ) {
                        // Ignore unknown stats
                        continue;
                    }
 
                    for ( $i = 0; $i < $stats['ct']; $i++ ) {
                        $inclusive[$child][$stat]->addObservation(
                            $value / $stats['ct']
                        );
                    }
                }
            }
 
            // Convert RunningStat instances to static arrays and add
            // percentage stats.
            foreach ( $inclusive as $func => $stats ) {
                foreach ( $stats as $name => $value ) {
                    if ( $value instanceof RunningStat ) {
                        $total = $value->getMean() * $value->getCount();
                        $percent = ( isset( $main[$name] ) && $main[$name] )
                            ? 100 * $total / $main[$name]
                            : 0;
                        $inclusive[$func][$name] = [
                            'total' => $total,
                            'min' => $value->min,
                            'mean' => $value->getMean(),
                            'max' => $value->max,
                            'variance' => $value->m2,
                            'percent' => $percent,
                        ];
                    }
                }
            }
 
            uasort( $inclusive, self::makeSortFunction(
                $this->config['sort'], 'total'
            ) );
            $this->inclusive = $inclusive;
        }
        return $this->inclusive;
    }
 
    public function getCompleteMetrics() {
        if ( $this->complete === null ) {
            // Start with inclusive data
            $this->complete = $this->getInclusiveMetrics();
 
            foreach ( $this->complete as $func => $stats ) {
                foreach ( $stats as $stat => $value ) {
                    if ( $stat === 'ct' ) {
                        continue;
                    }
                    // Initialize exclusive data with inclusive totals
                    $this->complete[$func][$stat]['exclusive'] = $value['total'];
                }
                // Add space for call tree information to be filled in later
                $this->complete[$func]['calls'] = [];
                $this->complete[$func]['subcalls'] = [];
            }
 
            foreach ( $this->hieraData as $key => $stats ) {
                [ $parent, $child ] = self::splitKey( $key );
                if ( $parent !== null ) {
                    // Track call tree information
                    $this->complete[$child]['calls'][$parent] = $stats;
                    $this->complete[$parent]['subcalls'][$child] = $stats;
                }
 
                if ( isset( $this->complete[$parent] ) ) {
                    // Deduct child inclusive data from exclusive data
                    foreach ( $stats as $stat => $value ) {
                        if ( $stat === 'ct' ) {
                            continue;
                        }
 
                        if ( !isset( $this->complete[$parent][$stat] ) ) {
                            // Ignore unknown stats
                            continue;
                        }
 
                        $this->complete[$parent][$stat]['exclusive'] -= $value;
                    }
                }
            }
 
            uasort( $this->complete, self::makeSortFunction(
                $this->config['sort'], 'exclusive'
            ) );
        }
        return $this->complete;
    }
 
    public function getCallers( $function ) {
        $edges = $this->getCompleteMetrics();
        if ( isset( $edges[$function]['calls'] ) ) {
            return array_keys( $edges[$function]['calls'] );
        } else {
            return [];
        }
    }
 
    public function getCallees( $function ) {
        $edges = $this->getCompleteMetrics();
        if ( isset( $edges[$function]['subcalls'] ) ) {
            return array_keys( $edges[$function]['subcalls'] );
        } else {
            return [];
        }
    }
 
    public function getCriticalPath( $metric = 'wt' ) {
        $func = 'main()';
        $path = [
            $func => $this->hieraData[$func],
        ];
        while ( $func ) {
            $callees = $this->getCallees( $func );
            $maxCallee = null;
            $maxCall = null;
            foreach ( $callees as $callee ) {
                $call = "{$func}==>{$callee}";
                if ( $maxCall === null ||
                    $this->hieraData[$call][$metric] >
                        $this->hieraData[$maxCall][$metric]
                ) {
                    $maxCallee = $callee;
                    $maxCall = $call;
                }
            }
            if ( $maxCall !== null ) {
                $path[$maxCall] = $this->hieraData[$maxCall];
            }
            $func = $maxCallee;
        }
        return $path;
    }
 
    public static function makeSortFunction( $key, $sub ) {
        return static function ( $a, $b ) use ( $key, $sub ) {
            if ( isset( $a[$key] ) && isset( $b[$key] ) ) {
                // Descending sort: larger values will be first in result.
                // Values for 'main()' will not have sub keys
                $valA = is_array( $a[$key] ) ? $a[$key][$sub] : $a[$key];
                $valB = is_array( $b[$key] ) ? $b[$key][$sub] : $b[$key];
                return $valB <=> $valA;
            } else {
                // Sort datum with the key before those without
                return isset( $a[$key] ) ? -1 : 1;
            }
        };
    }
}