profile.class.php

<?php
require'profile.class.php'; // should be obvious ;-)
 
// here might be uninteresting code
 
profile::start('overall'); // start a timer and give it a name
// we add this one to get a time
// for the overall runtime
 
// this is the code you want to profile
profile::start('$_SERVER');
$foo=count($_SERVER);
profile::stop(); // stop the last active counter
 
profile::start('$GLOBALS');
$bar=count($GLOBALS);
profile::stop();
 
 
profile::stop(); // stop overall timer
profile::print_results(profile::flush()); // print the results

profile results
--------------------------------------
$GLOBALS      0.000027s        100.00%
$_SERVER      0.000035s        128.07%
overall       0.000212s        779.82%

<?php
require'profile.class.php';
 
$string=file_get_contents('dummy_text.txt');
$iterations=strlen($string);
 
profile::codeblocks(array(
'stristr'=>'if (stristr($string, "loRem")) {}',
'preg_match'=>'if (preg_match("/loRem/i", $string)) {}',
),array(
'string'=>$string,
),$iterations);
 
profile::print_results(profile::flush());

profile results
----------------------------------------
preg_match      0.229575s        100.00%
stristr         2.601574s       1133.21%

<?php
/**
 * profile.class.php - A timer class for qualitative profiling
 *
 * This is a static class which you can use to qualitatively compare and
 * profile parts of your PHP code. It is as simple as
 *
 * <?php ...
 *   require 'profile.class.php';
 *   ...
 *   profile::start('some name');
 *   ...
 *   profile::stop();
 *   ...
 *   profile::print_results(profile::flush());
 * ?>
 *
 * The class itself should be self explaining and well documented. Take a look below!
 *
 *
 *
 * profile.class.php is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * profile.class.php is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with profile.class.php; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 * @author     Milian Wolff <mail@milianw.de>
 * @copyright  (C) 2008 Milian Wolff
 * @license    http://gnu.org/copyleft/gpl.html GNU GPL
 */
 
class profile {
// list of start and end timestamps
staticprivate$start=array();
staticprivate$end=array();
// current names
staticprivate$running_profiles=array();
staticprivate$cur_name;
/**
   * start the profile timer
   *
   * @param $name optional name for this profile
   */
staticpublicfunction start($name=0){
if(!is_null(self::$cur_name)){
// nested timer
// add old name to running profiles
array_push(self::$running_profiles,self::$cur_name);
if(self::$cur_name===$name){
if(is_int($name)){
$name++;
}else{
$name.='-SUB';
}
}
}
if(!isset(self::$start[$name])){
// init
self::$start[$name]=array();
self::$end[$name]=array();
}
self::$cur_name=$name;
// start timer
array_push(self::$start[$name],microtime(true));
}
/**
   * stop the profile timer
   */
staticpublicfunction stop(){
// stop timer
array_push(self::$end[self::$cur_name],microtime(true));
if(!empty(self::$running_profiles)){
// got a parent timer (nested timer)
self::$cur_name=array_pop(self::$running_profiles);
}else{
self::$cur_name=null;
}
}
/**
   * get the results and reset internal result cache
   *
   * @param $reverse boolean; calculate deviation to longest diff, defaults to false (shortest diff)
   * @return array of results
   */
staticpublicfunctionflush($reverse=false){
if(!is_null(self::$cur_name)){
trigger_error('A timer is still running. Stop it before flushing the results by calling profile::stop().',
E_USER_ERROR);
return;
}
if(empty(self::$start)){
returnarray();
}
 
$results=array();
// reset vars
$start=self::$start;
$end=self::$end;
self::$start=array();
self::$end=array();
self::$cur_name=null;
 
$results=array();
$diffs=array();
 
// get runtimes
$names=array_keys($start);
$deviate_key=$names[0];
 
foreach($namesas$key){
$diffs[$key]=array_sum($end[$key])-array_sum($start[$key]);
if(($reverse&&$diffs[$key]>$diffs[$deviate_key])
          || (!$reverse&&$diffs[$key]<$diffs[$deviate_key])){
// remember which run we take as reference point to calculate deviations
$deviate_key=$key;
}
}
 
if($reverse){
arsort($diffs);
}else{
asort($diffs);
}
 
// calculate percental deviations and build up return array
foreach($diffsas$name=>$diff){
array_push($results,array(
'diff'=>$diff,
'start'=>$start[$name],
'end'=>$end[$name],
'name'=>$name,
'deviation'=>($diffs[$name]/$diffs[$deviate_key])*100,
));
}
 
return$results;
}
/**
   * default implementation as to how one could present the results, optimized for CLI usage
   *
   * @param $results an array as returned by profile::flush()
   * @param $dont_print optionally; only return the result and dont print it
   * @return string
   */
staticpublicfunction print_results($results,$dont_print=false){
$output="profile results\n";
if(empty($results)){
$output="no code was profiled, empty resultset\n";
}else{
// get maximum col-width:
$max_col_width=0;
for($key=0,$n=count($results); $key<$n; ++$key){
$max_col_width=max($max_col_width,strlen($results[$key]['name']));
}
$output.=str_repeat('-',$max_col_width+strlen('      0.000000s        100.00%'))."\n";
 
foreach($resultsas$profile){
$output.=sprintf("%-".$max_col_width."s    %10Fs    %10.2F%%\n",
$profile['name'],$profile['diff'],$profile['deviation']);
}
}
if(!$dont_print){
echo$output;
}
return$output;
}
/**
   * define code blocks and run them in random order, profiling each
   * this is great when writing little scripts to see which implementation of a given feature is faster
   *
   * @param $code_blocks an array with strings of php-code (just like eval or create_function accepts).
   *                     don't forget keys to give those codeblocks a name
   * @param $vars assoc array with global values which are used in the code blocks (i.e. varname => value)
   * @param $iterations number of times each block gets run
   * @return void
   */
staticpublicfunction codeblocks($code_blocks,$vars=array(),$iterations=200){
if(!empty($vars)){
$vars_keys='$'.implode(', $',array_keys($vars));
$vars_values=array_values($vars);
}else{
$vars_keys='';
$vars_values=array();
}
$blocks=array();
// pita to get random order
foreach($code_blocksas$name=>$block){
$block=trim($block);
if($block[strlen($block)-1]!=';'){
$block.=';';
}
array_push($blocks,array('name'=>$name,'code'=>$block));
}
unset($code_blocks);
shuffle($blocks);
foreach($blocksas$block){
$func=create_function($vars_keys,$block['code']);
self::start($block['name']);
for($i=0; $i<$iterations; ++$i){
call_user_func_array($func,$vars_values);
}
self::stop();
}
}
}