Xhprof.php

Go to the documentation of this file.

<?php
use RunningStat\RunningStat;

class Xhprof {

    protected $config;

    protected $hieraData;

    protected $inclusive;

    protected $complete;

    public function __construct( array $config = [] ) {
        $this->config = array_merge(
            [
                'flags' => 0,
                'exclude' => [],
                'include' => null,
                'sort' => 'wt',
            ],
            $config
        );

        xhprof_enable( $this->config['flags'], [
            'ignored_functions' => $this->config['exclude']
        ] );
    }

    public function stop() {
        if ( $this->hieraData === null ) {
            $this->hieraData = $this->pruneData( xhprof_disable() );
        }
        return $this->hieraData;
    }

    public function loadRawData( array $data ) {
        $this->stop();
        $this->inclusive = null;
        $this->complete = null;
        $this->hieraData = $this->pruneData( $data );
    }

    public function getRawData() {
        return $this->stop();
    }

    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 ) {
            list( $parent, $child ) = self::splitKey( $key );
            if ( isset( $want[$parent] ) || isset( $want[$child] ) ) {
                $keep[$key] = $stats;
            }
        }
        return $keep;
    }

    public function getInclusiveMetrics() {
        if ( $this->inclusive === null ) {
            // Make sure we have data to work with
            $this->stop();

            $main = $this->hieraData['main()'];
            $hasCpu = isset( $main['cpu'] );
            $hasMu = isset( $main['mu'] );
            $hasAlloc = isset( $main['alloc'] );

            $this->inclusive = [];
            foreach ( $this->hieraData as $key => $stats ) {
                list( $parent, $child ) = self::splitKey( $key );
                if ( !isset( $this->inclusive[$child] ) ) {
                    $this->inclusive[$child] = [
                        'ct' => 0,
                        'wt' => new RunningStat(),
                    ];
                    if ( $hasCpu ) {
                        $this->inclusive[$child]['cpu'] = new RunningStat();
                    }
                    if ( $hasMu ) {
                        $this->inclusive[$child]['mu'] = new RunningStat();
                        $this->inclusive[$child]['pmu'] = new RunningStat();
                    }
                    if ( $hasAlloc ) {
                        $this->inclusive[$child]['alloc'] = new RunningStat();
                        $this->inclusive[$child]['free'] = new RunningStat();
                    }
                }

                $this->inclusive[$child]['ct'] += $stats['ct'];
                foreach ( $stats as $stat => $value ) {
                    if ( $stat === 'ct' ) {
                        continue;
                    }

                    if ( !isset( $this->inclusive[$child][$stat] ) ) {
                        // Ignore unknown stats
                        continue;
                    }

                    for ( $i = 0; $i < $stats['ct']; $i++ ) {
                        $this->inclusive[$child][$stat]->addObservation(
                            $value / $stats['ct']
                        );
                    }
                }
            }

            // Convert RunningStat instances to static arrays and add
            // percentage stats.
            foreach ( $this->inclusive as $func => $stats ) {
                foreach ( $stats as $name => $value ) {
                    if ( $value instanceof RunningStat ) {
                        $total = $value->m1 * $value->n;
                        $percent = ( isset( $main[$name] ) && $main[$name] )
                            ? 100 * $total / $main[$name]
                            : 0;
                        $this->inclusive[$func][$name] = [
                            'total' => $total,
                            'min' => $value->min,
                            'mean' => $value->m1,
                            'max' => $value->max,
                            'variance' => $value->m2,
                            'percent' => $percent,
                        ];
                    }
                }
            }

            uasort( $this->inclusive, self::makeSortFunction(
                $this->config['sort'], 'total'
            ) );
        }
        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 sapce for call tree information to be filled in later
                $this->complete[$func]['calls'] = [];
                $this->complete[$func]['subcalls'] = [];
            }

            foreach ( $this->hieraData as $key => $stats ) {
                list( $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' ) {
        $this->stop();
        $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 function ( $a, $b ) use ( $key, $sub ) {
            if ( isset( $a[$key] ) && isset( $b[$key] ) ) {
                // Descending sort: larger values will be first in result.
                // Assumes all values are numeric.
                // 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;
            }
        };
    }
}