Benchmark.php CI Explained

I’ve stopped work on this series to start a new one for CI 3.

Introduction

This post is part of a series which explains the CodeIgniter (CI) source code. This post explains the CI 2.1.3 Benchmark class.

./system/core/Benchmark.php

This class enables you to mark points and calculate the time difference between them. Memory consumption can also be displayed.

Code

if ( ! defined('BASEPATH')) exit('No direct script access allowed');
/**
 * CodeIgniter
 *
 * An open source application development framework for PHP 5.1.6 or newer
 *
 * @package		CodeIgniter
 * @author		ExpressionEngine Dev Team
 * @copyright	Copyright (c) 2008 - 2011, EllisLab, Inc.
 * @license		http://codeigniter.com/user_guide/license.html
 * @link		http://codeigniter.com
 * @since		Version 1.0
 * @filesource
 */

// ------------------------------------------------------------------------

/**
 * CodeIgniter Benchmark Class
 *
 * This class enables you to mark points and calculate the time difference
 * between them.  Memory consumption can also be displayed.
 *
 * @package		CodeIgniter
 * @subpackage	Libraries
 * @category	Libraries
 * @author		ExpressionEngine Dev Team
 * @link		http://codeigniter.com/user_guide/libraries/benchmark.html
 */

This is the standard stuff which starts off a CI script like this.

Code: CI_Benchmark

class CI_Benchmark {

The class declaration.

Code: $marker

/**
 * List of all benchmark markers and when they were added
 *
 * @var array
 */
var $marker = array();

Code: mark()

/**
 * Set a benchmark marker
 *
 * Multiple calls to this function can be made so that several
 * execution points can be timed
 *
 * @access	public
 * @param	string	$name	name of the marker
 * @return	void
 */
function mark($name)
{
	$this->marker[$name] = microtime();
}

Store/update a marker. A marker is a name value pair for a point in time in which the mark function is called. The value associated with the marker is a timestamp.

Code: elapsed_time()

	/**
	 * Calculates the time difference between two marked points.
	 *
	 * If the first parameter is empty this function instead returns the
	 * {elapsed_time} pseudo-variable. This permits the full system
	 * execution time to be shown in a template. The output class will
	 * swap the real value for this variable.
	 *
	 * @access	public
	 * @param	string	a particular marked point
	 * @param	string	a particular marked point
	 * @param	integer	the number of decimal places
	 * @return	mixed
	 */
	function elapsed_time($point1 = '', $point2 = '', $decimals = 4)
	{
		if ($point1 == '')
		{
			return '{elapsed_time}';
		}

		if ( ! isset($this->marker[$point1]))
		{
			return '';
		}

		if ( ! isset($this->marker[$point2]))
		{
			$this->marker[$point2] = microtime();
		}

		list($sm, $ss) = explode(' ', $this->marker[$point1]);
		list($em, $es) = explode(' ', $this->marker[$point2]);

		return number_format(($em + $es) - ($sm + $ss), $decimals);
	}

$point1 is the name of a marker. Most likely $point1 is chronologically before $point2.

$point2 is the name of another marker.

$decimals is the number of decimal places you want in the value which is returned by the function call.

If no $point1 was defined in the function call then return the string {elapsed_time} .

If execution made it past the first if statement and yet no marker is set for the name given by $point1 then return an empty string.

If execution made it this far then:
We have a $point1 marker name which is associated with a timestamp.

If the marker for $point2 is not set then set it to microtime().

Q: What is microtime() ?

A: returns the current Unix timestamp with microseconds. The default return type is string. So, in our case, it returns a string in the form "msec sec", where sec is the current time measured in the number of seconds since the Unix epoch (0:00:00 January 1, 1970 GMT), and msec is the “amount” of microseconds that have elapsed since sec expressed in seconds. 0.55512200 1064700291 is an example of a microtime.

list($sm, $ss) = explode(' ', $this->marker[$point1]);
list($em, $es) = explode(' ', $this->marker[$point2]);

$sm — microsecond (string) for $point1

$ss — second (string) for $point1

$em — microsecond (string) for $point2

$es — second (string) for $point2

($em + $es) - ($sm + $ss)

This evaluates to a floating point value correlating to the amount of time which passed between the two markers.

return number_format(($em + $es) - ($sm + $ss), $decimals);

This tells PHP to return a string which is a formatted version of the floating point number for ($em + $es) - ($sm + $ss). The formatting will cause a comma (“,”) to be placed between every group of thousands and will cause it to be formatted with $decimals decimals — with a dot (“.”) in front.

Code: memory_usage()

/**
 * Memory Usage
 *
 * This function returns the {memory_usage} pseudo-variable.
 * This permits it to be put it anywhere in a template
 * without the memory being calculated until the end.
 * The output class will swap the real value for this variable.
 *
 * @access	public
 * @return	string
 */
function memory_usage()
{
	return '{memory_usage}';
}
Advertisements

About samehramzylabib

See About on https://samehramzylabib.wordpress.com
This entry was posted in CI Source Code Explained. Bookmark the permalink.

One Response to Benchmark.php CI Explained

  1. Pingback: Bootstrap Source Code for CI Explained | Sam's PHP

Comment

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s