Subversion-Projekte lars-tiefland.php_share

<?php

if ( $argc <= 1 || $argc > 4 )

{

	showUsage();

}

$fileName = $argv[1];

$sortKey  = 'time-own';

$elements = 25;

if ( $argc > 2 )

{

	$sortKey = $argv[2];

	if ( !in_array( $sortKey, array( 'calls', 'time-inclusive', 'memory-inclusive', 'time-own', 'memory-own' ) ) )

	{

		showUsage();

	}

}

if ( $argc > 3 )

{

	$elements = (int) $argv[3];

}

$o = new drXdebugTraceFileParser( $argv[1] );

$o->parse();

$functions = $o->getFunctions( $sortKey );

// find longest function name

$maxLen = 0;

foreach( $functions as $name => $f )

{

	if ( strlen( $name ) > $maxLen )

	{

		$maxLen = strlen( $name );

	}

}

echo "Showing the {$elements} most costly calls sorted by '{$sortKey}'.\n\n";

echo "        ", str_repeat( ' ', $maxLen - 8 ), "        Inclusive        Own\n";

echo "function", str_repeat( ' ', $maxLen - 8 ), "#calls  time     memory  time     memory\n";

echo "--------", str_repeat( '-', $maxLen - 8 ), "----------------------------------------\n";

// display functions

$c = 0;

foreach( $functions as $name => $f )

{

	$c++;

	if ( $c > $elements )

	{

		break;

	}

	printf( "%-{$maxLen}s %5d  %3.4f %8d  %3.4f %8d\n",

		$name, $f['calls'],

		$f['time-inclusive'], $f['memory-inclusive'],

		$f['time-own'], $f['memory-own'] );

}

function showUsage()

{

	echo "usage:\n\tphp run-cli tracefile [sortkey] [elements]\n\n";

	echo "Allowed sortkeys:\n\tcalls, time-inclusive, memory-inclusive, time-own, memory-own\n";

	die();

}

class drXdebugTraceFileParser

{

	protected $handle;

	/**

	 * Stores the last function, time and memory for the entry point per

	 * stack depth. int=>array(string, float, int).

	 */

	protected $stack;

	/**

	 * Stores per function the total time and memory increases and calls

	 * string=>array(float, int, int)

	 */

	protected $functions;

	/**

	 * Stores which functions are on the stack

	 */

	protected $stackFunctions;

	public function __construct( $fileName )

	{

		$this->handle = fopen( $fileName, 'r' );

		if ( !$this->handle )

		{

			throw new Exception( "Can't open '$fileName'" );

		}

		$this->stack[-1] = array( '', 0, 0, 0, 0 );

		$this->stack[ 0] = array( '', 0, 0, 0, 0 );

		$this->stackFunctions = array();

	}

	public function parse()

	{

		echo "\nparsing...\n";

		$c = 0;

		$size = fstat( $this->handle );

		$size = $size['size'];

		$read = 0;

		while ( !feof( $this->handle ) )

		{

			$buffer = fgets( $this->handle, 4096 );

			$read += strlen( $buffer );

			$this->parseLine( $buffer );

			$c++;

			if ( $c % 25000 === 0 )

			{

				printf( " (%5.2f%%)\n", ( $read / $size ) * 100 );

			}

		}

		echo "\nDone.\n\n";

	}

	private function parseLine( $line )

	{

	/*

		if ( preg_match( '@^Version: (.*)@', $line, $matches ) )

		{

		}

		else if ( preg_match( '@^File format: (.*)@', $line, $matches ) )

		{

		}

		else if ( preg_match( '@^TRACE.*@', $line, $matches ) )

		{

		}

		else // assume a normal line

		*/

		{

			$parts = explode( "\t", $line );

			if ( count( $parts ) < 5 )

			{

				return;

			}

			$depth = $parts[0];

			$funcNr = $parts[1];

			$time = $parts[3];

			$memory = $parts[4];

			if ( $parts[2] == '0' ) // function entry

			{

				$funcName = $parts[5];

				$intFunc = $parts[6];

				$this->stack[$depth] = array( $funcName, $time, $memory, 0, 0 );

				array_push( $this->stackFunctions, $funcName );

			}

			else if ( $parts[2] == '1' ) // function exit

			{

				list( $funcName, $prevTime, $prevMem, $nestedTime, $nestedMemory ) = $this->stack[$depth];

				// collapse data onto functions array

				$dTime   = $time   - $prevTime;

				$dMemory = $memory - $prevMem;

				$this->stack[$depth - 1][3] += $dTime;

				$this->stack[$depth - 1][4] += $dMemory;

				array_pop( $this->stackFunctions );

				$this->addToFunction( $funcName, $dTime, $dMemory, $nestedTime, $nestedMemory );

			}

		}

	}

	protected function addToFunction( $function, $time, $memory, $nestedTime, $nestedMemory )

	{

		if ( !isset( $this->functions[$function] ) )

		{

			$this->functions[$function] = array( 0, 0, 0, 0, 0 );

		}

		$elem = &$this->functions[$function];

		$elem[0]++;

		if ( !in_array( $function, $this->stackFunctions ) ) {

			$elem[1] += $time;

			$elem[2] += $memory;

			$elem[3] += $nestedTime;

			$elem[4] += $nestedMemory;

		}

	}

	public function getFunctions( $sortKey = null )

	{

		$result = array();

		foreach ( $this->functions as $name => $function )

		{

			$result[$name] = array(

				'calls'                 => $function[0],

				'time-inclusive'        => $function[1],

				'memory-inclusive'      => $function[2],

				'time-children'         => $function[3],

				'memory-children'       => $function[4],

				'time-own'              => $function[1] - $function[3],

				'memory-own'            => $function[2] - $function[4]

			);

		}

		if ( $sortKey !== null )

		{

			uasort( $result,

				function( $a, $b ) use ( $sortKey )

				{

					return ( $a[$sortKey] > $b[$sortKey] ) ? -1 : ( $a[$sortKey] < $b[$sortKey] ? 1 : 0 );

				}

			);

		}

		return $result;

	}

}

?>