Merge branch 'w42_MDL-29881_m22_profiling' of git://github.com/skodak/moodle
This commit is contained in:
Eloy Lafuente (stronk7)
@@ -9827,11 +9827,6 @@ function get_performance_info() {
|
||||
$info['html'] .= '<span class="dbqueries">DB reads/writes: '.$info['dbqueries'].'</span> ';
|
||||
$info['txt'] .= 'db reads/writes: '.$info['dbqueries'].' ';
|
||||
|
||||
if (!empty($PERF->profiling) && $PERF->profiling) {
|
||||
require_once($CFG->dirroot .'/lib/profilerlib.php');
|
||||
$info['html'] .= '<span class="profilinginfo">'.Profiler::get_profiling(array('-R')).'</span>';
|
||||
}
|
||||
|
||||
if (function_exists('posix_times')) {
|
||||
$ptimes = posix_times();
|
||||
if (is_array($ptimes)) {
|
||||
|
||||
@@ -1,290 +0,0 @@
|
||||
<?php
|
||||
/* vim: set expandtab tabstop=4 shiftwidth=4: */
|
||||
// +----------------------------------------------------------------------+
|
||||
// | PHP Version 5 |
|
||||
// +----------------------------------------------------------------------+
|
||||
// | Copyright (c) 1997-2004 The PHP Group |
|
||||
// +----------------------------------------------------------------------+
|
||||
// | This source file is subject to version 3.0 of the PHP license, |
|
||||
// | that is bundled with this package in the file LICENSE, and is |
|
||||
// | available through the world-wide-web at the following url: |
|
||||
// | http://www.php.net/license/3_0.txt. |
|
||||
// | If you did not receive a copy of the PHP license and are unable to |
|
||||
// | obtain it through the world-wide-web, please send a note to |
|
||||
// | [email protected] so we can mail you a copy immediately. |
|
||||
// +----------------------------------------------------------------------+
|
||||
// | Author: Andrei Zmievski <[email protected]> |
|
||||
// +----------------------------------------------------------------------+
|
||||
//
|
||||
// $Id$
|
||||
|
||||
require_once 'PEAR.php';
|
||||
|
||||
/**
|
||||
* Command-line options parsing class.
|
||||
*
|
||||
* @author Andrei Zmievski <[email protected]>
|
||||
*
|
||||
*/
|
||||
class Console_Getopt {
|
||||
/**
|
||||
* Parses the command-line options.
|
||||
*
|
||||
* The first parameter to this function should be the list of command-line
|
||||
* arguments without the leading reference to the running program.
|
||||
*
|
||||
* The second parameter is a string of allowed short options. Each of the
|
||||
* option letters can be followed by a colon ':' to specify that the option
|
||||
* requires an argument, or a double colon '::' to specify that the option
|
||||
* takes an optional argument.
|
||||
*
|
||||
* The third argument is an optional array of allowed long options. The
|
||||
* leading '--' should not be included in the option name. Options that
|
||||
* require an argument should be followed by '=', and options that take an
|
||||
* option argument should be followed by '=='.
|
||||
*
|
||||
* The return value is an array of two elements: the list of parsed
|
||||
* options and the list of non-option command-line arguments. Each entry in
|
||||
* the list of parsed options is a pair of elements - the first one
|
||||
* specifies the option, and the second one specifies the option argument,
|
||||
* if there was one.
|
||||
*
|
||||
* Long and short options can be mixed.
|
||||
*
|
||||
* Most of the semantics of this function are based on GNU getopt_long().
|
||||
*
|
||||
* @param array $args an array of command-line arguments
|
||||
* @param string $short_options specifies the list of allowed short options
|
||||
* @param array $long_options specifies the list of allowed long options
|
||||
*
|
||||
* @return array two-element array containing the list of parsed options and
|
||||
* the non-option arguments
|
||||
*
|
||||
* @access public
|
||||
*
|
||||
*/
|
||||
function getopt2($args, $short_options, $long_options = null)
|
||||
{
|
||||
return Console_Getopt::doGetopt(2, $args, $short_options, $long_options);
|
||||
}
|
||||
|
||||
/**
|
||||
* This function expects $args to start with the script name (POSIX-style).
|
||||
* Preserved for backwards compatibility.
|
||||
* @see getopt2()
|
||||
*/
|
||||
function getopt($args, $short_options, $long_options = null)
|
||||
{
|
||||
return Console_Getopt::doGetopt(1, $args, $short_options, $long_options);
|
||||
}
|
||||
|
||||
/**
|
||||
* The actual implementation of the argument parsing code.
|
||||
*/
|
||||
function doGetopt($version, $args, $short_options, $long_options = null)
|
||||
{
|
||||
// in case you pass directly readPHPArgv() as the first arg
|
||||
if (PEAR::isError($args)) {
|
||||
return $args;
|
||||
}
|
||||
if (empty($args)) {
|
||||
return array(array(), array());
|
||||
}
|
||||
$opts = array();
|
||||
$non_opts = array();
|
||||
|
||||
settype($args, 'array');
|
||||
|
||||
if ($long_options) {
|
||||
sort($long_options);
|
||||
}
|
||||
|
||||
/*
|
||||
* Preserve backwards compatibility with callers that relied on
|
||||
* erroneous POSIX fix.
|
||||
*/
|
||||
if ($version < 2) {
|
||||
if (isset($args[0]{0}) && $args[0]{0} != '-') {
|
||||
array_shift($args);
|
||||
}
|
||||
}
|
||||
|
||||
reset($args);
|
||||
while (list($i, $arg) = each($args)) {
|
||||
|
||||
/* The special element '--' means explicit end of
|
||||
options. Treat the rest of the arguments as non-options
|
||||
and end the loop. */
|
||||
if ($arg == '--') {
|
||||
$non_opts = array_merge($non_opts, array_slice($args, $i + 1));
|
||||
break;
|
||||
}
|
||||
|
||||
if ($arg{0} != '-' || (strlen($arg) > 1 && $arg{1} == '-' && !$long_options)) {
|
||||
$non_opts = array_merge($non_opts, array_slice($args, $i));
|
||||
break;
|
||||
} elseif (strlen($arg) > 1 && $arg{1} == '-') {
|
||||
$error = Console_Getopt::_parseLongOption(substr($arg, 2), $long_options, $opts, $args);
|
||||
if (PEAR::isError($error))
|
||||
return $error;
|
||||
} elseif ($arg == '-') {
|
||||
// - is stdin
|
||||
$non_opts = array_merge($non_opts, array_slice($args, $i));
|
||||
break;
|
||||
} else {
|
||||
$error = Console_Getopt::_parseShortOption(substr($arg, 1), $short_options, $opts, $args);
|
||||
if (PEAR::isError($error))
|
||||
return $error;
|
||||
}
|
||||
}
|
||||
|
||||
return array($opts, $non_opts);
|
||||
}
|
||||
|
||||
/**
|
||||
* @access private
|
||||
*
|
||||
*/
|
||||
function _parseShortOption($arg, $short_options, &$opts, &$args)
|
||||
{
|
||||
for ($i = 0; $i < strlen($arg); $i++) {
|
||||
$opt = $arg{$i};
|
||||
$opt_arg = null;
|
||||
|
||||
/* Try to find the short option in the specifier string. */
|
||||
if (($spec = strstr($short_options, $opt)) === false || $arg{$i} == ':')
|
||||
{
|
||||
return PEAR::raiseError("Console_Getopt: unrecognized option -- $opt");
|
||||
}
|
||||
|
||||
if (strlen($spec) > 1 && $spec{1} == ':') {
|
||||
if (strlen($spec) > 2 && $spec{2} == ':') {
|
||||
if ($i + 1 < strlen($arg)) {
|
||||
/* Option takes an optional argument. Use the remainder of
|
||||
the arg string if there is anything left. */
|
||||
$opts[] = array($opt, substr($arg, $i + 1));
|
||||
break;
|
||||
}
|
||||
} else {
|
||||
/* Option requires an argument. Use the remainder of the arg
|
||||
string if there is anything left. */
|
||||
if ($i + 1 < strlen($arg)) {
|
||||
$opts[] = array($opt, substr($arg, $i + 1));
|
||||
break;
|
||||
} else if (list(, $opt_arg) = each($args)) {
|
||||
/* Else use the next argument. */;
|
||||
if (Console_Getopt::_isShortOpt($opt_arg) || Console_Getopt::_isLongOpt($opt_arg)) {
|
||||
return PEAR::raiseError("Console_Getopt: option requires an argument -- $opt");
|
||||
}
|
||||
} else {
|
||||
return PEAR::raiseError("Console_Getopt: option requires an argument -- $opt");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
$opts[] = array($opt, $opt_arg);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @access private
|
||||
*
|
||||
*/
|
||||
function _isShortOpt($arg)
|
||||
{
|
||||
return strlen($arg) == 2 && $arg[0] == '-' && preg_match('/[a-zA-Z]/', $arg[1]);
|
||||
}
|
||||
|
||||
/**
|
||||
* @access private
|
||||
*
|
||||
*/
|
||||
function _isLongOpt($arg)
|
||||
{
|
||||
return strlen($arg) > 2 && $arg[0] == '-' && $arg[1] == '-' &&
|
||||
preg_match('/[a-zA-Z]+$/', substr($arg, 2));
|
||||
}
|
||||
|
||||
/**
|
||||
* @access private
|
||||
*
|
||||
*/
|
||||
function _parseLongOption($arg, $long_options, &$opts, &$args)
|
||||
{
|
||||
@list($opt, $opt_arg) = explode('=', $arg, 2);
|
||||
$opt_len = strlen($opt);
|
||||
|
||||
for ($i = 0; $i < count($long_options); $i++) {
|
||||
$long_opt = $long_options[$i];
|
||||
$opt_start = substr($long_opt, 0, $opt_len);
|
||||
$long_opt_name = str_replace('=', '', $long_opt);
|
||||
|
||||
/* Option doesn't match. Go on to the next one. */
|
||||
if ($long_opt_name != $opt) {
|
||||
continue;
|
||||
}
|
||||
|
||||
$opt_rest = substr($long_opt, $opt_len);
|
||||
|
||||
/* Check that the options uniquely matches one of the allowed
|
||||
options. */
|
||||
if ($i + 1 < count($long_options)) {
|
||||
$next_option_rest = substr($long_options[$i + 1], $opt_len);
|
||||
} else {
|
||||
$next_option_rest = '';
|
||||
}
|
||||
if ($opt_rest != '' && $opt{0} != '=' &&
|
||||
$i + 1 < count($long_options) &&
|
||||
$opt == substr($long_options[$i+1], 0, $opt_len) &&
|
||||
$next_option_rest != '' &&
|
||||
$next_option_rest{0} != '=') {
|
||||
return PEAR::raiseError("Console_Getopt: option --$opt is ambiguous");
|
||||
}
|
||||
|
||||
if (substr($long_opt, -1) == '=') {
|
||||
if (substr($long_opt, -2) != '==') {
|
||||
/* Long option requires an argument.
|
||||
Take the next argument if one wasn't specified. */;
|
||||
if (!strlen($opt_arg) && !(list(, $opt_arg) = each($args))) {
|
||||
return PEAR::raiseError("Console_Getopt: option --$opt requires an argument");
|
||||
}
|
||||
if (Console_Getopt::_isShortOpt($opt_arg) || Console_Getopt::_isLongOpt($opt_arg)) {
|
||||
return PEAR::raiseError("Console_Getopt: option requires an argument --$opt");
|
||||
}
|
||||
}
|
||||
} else if ($opt_arg) {
|
||||
return PEAR::raiseError("Console_Getopt: option --$opt doesn't allow an argument");
|
||||
}
|
||||
|
||||
$opts[] = array('--' . $opt, $opt_arg);
|
||||
return;
|
||||
}
|
||||
|
||||
return PEAR::raiseError("Console_Getopt: unrecognized option --$opt");
|
||||
}
|
||||
|
||||
/**
|
||||
* Safely read the $argv PHP array across different PHP configurations.
|
||||
* Will take care on register_globals and register_argc_argv ini directives
|
||||
*
|
||||
* @access public
|
||||
* @return mixed the $argv PHP array or PEAR error if not registered
|
||||
*/
|
||||
function readPHPArgv()
|
||||
{
|
||||
global $argv;
|
||||
if (!is_array($argv)) {
|
||||
if (!@is_array($_SERVER['argv'])) {
|
||||
if (!@is_array($GLOBALS['HTTP_SERVER_VARS']['argv'])) {
|
||||
return PEAR::raiseError("Console_Getopt: Could not read cmd args (register_argc_argv=Off?)");
|
||||
}
|
||||
return $GLOBALS['HTTP_SERVER_VARS']['argv'];
|
||||
}
|
||||
return $_SERVER['argv'];
|
||||
}
|
||||
return $argv;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
?>
|
||||
@@ -1,5 +0,0 @@
|
||||
This is licensed originally under the PHP license which is incompatible with the GPL. However, I got explicit permission from the author (Andrei Zmievski <[email protected]>) on 18/12/07 to dual license it:
|
||||
|
||||
"I am fine with my library to be distributed under the GPL by Moodle project (which basically means that it's dual-licensed, as far as I can tell)."
|
||||
|
||||
-- Penny
|
||||
@@ -1,477 +0,0 @@
|
||||
<?php
|
||||
|
||||
// This file is part of Moodle - http://moodle.org/
|
||||
//
|
||||
// Moodle 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 3 of the License, or
|
||||
// (at your option) any later version.
|
||||
//
|
||||
// Moodle 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 Moodle. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
/**
|
||||
* @package moodlecore
|
||||
* @copyright 1999 onwards Martin Dougiamas {@link http://moodle.com}
|
||||
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
|
||||
*/
|
||||
|
||||
/** Includes */
|
||||
require_once('Console/Getopt.php');
|
||||
|
||||
/**
|
||||
* Profiler adapted from Pear::APD's pprofp script. Not quite there yet, I need
|
||||
* to get this to accept a similar list of arguments as the script does,
|
||||
* and process them the same way. Also make sure that the file being loaded
|
||||
* is the right one. Also support multiple pids used in one page load (up to 4 so far).
|
||||
* Then output all this in a nicely formatted table.
|
||||
*
|
||||
* @package moodlecore
|
||||
* @copyright 1999 onwards Martin Dougiamas {@link http://moodle.com}
|
||||
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
|
||||
*/
|
||||
class Profiler
|
||||
{
|
||||
var $stimes;
|
||||
var $utimes;
|
||||
var $calls;
|
||||
var $c_stimes;
|
||||
var $c_utimes;
|
||||
var $mem;
|
||||
|
||||
/**
|
||||
* Concatenates all the pprof files generated by apd_set_pprof_trace()
|
||||
* and returns the resulting string, which can then be processed by
|
||||
* get_profiling();
|
||||
* It also deletes these files once finished, in order to limit
|
||||
* cluttering of the filesystem. This can be switched off by
|
||||
* providing "false" as the only argument to this function.
|
||||
*
|
||||
* WARNING: If you switch cleanup off, profiling data will
|
||||
* accumulate from one pageload to the next.
|
||||
*
|
||||
* @global object
|
||||
* @global object
|
||||
* @param boolean $cleanup Whether to delete pprof files or not.
|
||||
* @return String Profiling raw data
|
||||
*/
|
||||
function _get_pprofp($cleanup = true)
|
||||
{
|
||||
global $CFG, $USER;
|
||||
// List all files under our temporary directory
|
||||
$tempdir = $CFG->tempdir . '/profile/' . $USER->id;
|
||||
if ($files = scandir($tempdir)) {
|
||||
// Concatenate the files
|
||||
print_r($files);
|
||||
} else {
|
||||
print "Error: Profiler could not read the directory $tempdir.";
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
// Return a handle to the resulting file
|
||||
|
||||
|
||||
if(($DATA = fopen($dataFile, "r")) == FALSE) {
|
||||
return "Failed to open $dataFile for reading\n";
|
||||
}
|
||||
return $handle;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Returns profiling information gathered using APD functions.
|
||||
* Accepts a numerical array of command-line arguments.
|
||||
*
|
||||
* Profiler::get_profiling($args)
|
||||
* Sort options
|
||||
* -a Sort by alphabetic names of subroutines.
|
||||
* -l Sort by number of calls to subroutines
|
||||
* -m Sort by memory used in a function call.
|
||||
* -r Sort by real time spent in subroutines.
|
||||
* -R Sort by real time spent in subroutines (inclusive of child calls).
|
||||
* -s Sort by system time spent in subroutines.
|
||||
* -S Sort by system time spent in subroutines (inclusive of child calls).
|
||||
* -u Sort by user time spent in subroutines.
|
||||
* -U Sort by user time spent in subroutines (inclusive of child calls).
|
||||
* -v Sort by average amount of time spent in subroutines.
|
||||
* -z Sort by user+system time spent in subroutines. (default)
|
||||
*
|
||||
* Display options
|
||||
* -c Display Real time elapsed alongside call tree.
|
||||
* -i Suppress reporting for php builtin functions
|
||||
* -O <cnt> Specifies maximum number of subroutines to display. (default 15)
|
||||
* -t Display compressed call tree.
|
||||
* -T Display uncompressed call tree.
|
||||
*
|
||||
* Example array: array('-a', '-l');
|
||||
*
|
||||
* @param Array $args
|
||||
* @return String Profiling info
|
||||
*/
|
||||
function get_profiling($args)
|
||||
{
|
||||
$con = new Console_Getopt;
|
||||
array_shift($args);
|
||||
|
||||
$shortoptions = 'acg:hiIlmMrRsStTuUO:vzZ';
|
||||
$retval = $con->getopt( $args, $shortoptions);
|
||||
if(is_object($retval)) {
|
||||
usage();
|
||||
}
|
||||
|
||||
$opt['O'] = 20;
|
||||
foreach ($retval[0] as $kv_array) {
|
||||
$opt[$kv_array[0]] = $kv_array[1];
|
||||
}
|
||||
|
||||
$DATA = Profiler::_get_pprofp();
|
||||
|
||||
$cfg = array();
|
||||
$this->parse_info('HEADER', $DATA, $cfg);
|
||||
|
||||
$callstack = array();
|
||||
$calls = array();
|
||||
$indent_cur = 0;
|
||||
$file_hash = array();
|
||||
$this->mem = array();
|
||||
$t_rtime = 0;
|
||||
$t_stime = 0;
|
||||
$t_utime = 0;
|
||||
$c_rtimes = array();
|
||||
$this->c_stimes = array();
|
||||
$this->c_utimes = array();
|
||||
$rtimes = array();
|
||||
$this->stimes = array();
|
||||
$this->utimes = array();
|
||||
$rtotal = 0;
|
||||
$stotal = 0;
|
||||
$utotal = 0;
|
||||
$last_memory = 0;
|
||||
|
||||
$symbol_hash = array();
|
||||
$symbol_type = array();
|
||||
|
||||
while($line = fgets($DATA)) {
|
||||
$line = rtrim($line);
|
||||
if(preg_match("/^END_TRACE/", $line)){
|
||||
break;
|
||||
}
|
||||
list($token, $data) = preg_split("/ /",$line, 2);
|
||||
if($token == '!') {
|
||||
list ($index, $file) = preg_split("/ /", $data, 2);
|
||||
$file_hash[$index] = $file;
|
||||
continue;
|
||||
}
|
||||
if( $token == '&') {
|
||||
list ($index, $name, $type) = preg_split("/ /", $data, 3);
|
||||
$symbol_hash[$index] = $name;
|
||||
$symbol_type[$index] = $type;
|
||||
continue;
|
||||
}
|
||||
if( $token == '+') {
|
||||
list($index, $file, $line) = preg_split("/ /",$data, 3);
|
||||
if(array_key_exists('i',$opt) && $symbol_type[$index] == 1) {
|
||||
continue;
|
||||
}
|
||||
$index_cur = $index;
|
||||
$calls[$index_cur]++;
|
||||
array_push($callstack, $index_cur);
|
||||
if(array_key_exists('T', $opt)) {
|
||||
if(array_key_exists('c', $opt)) {
|
||||
$retstring .= sprintf("%2.02f ", $rtotal/1000000);
|
||||
}
|
||||
$retstring .= str_repeat(" ", $indent_cur).$symbol_hash[$index_cur]."\n";
|
||||
if(array_key_exists('m', $opt)) {
|
||||
$retstring .= str_repeat(" ", $indent_cur)."C: $file_hash[$file]:$line M: $memory\n";
|
||||
}
|
||||
}
|
||||
elseif(array_key_exists('t', $opt)) {
|
||||
if ( $indent_last == $indent_cur && $index_last == $index_cur ) {
|
||||
$repcnt++;
|
||||
}
|
||||
else {
|
||||
if ( $repcnt ) {
|
||||
$repstr = ' ('.++$repcnt.'x)';
|
||||
}
|
||||
if(array_key_exists('c', $opt)) {
|
||||
$retstring .= sprintf("%2.02f ", $rtotal/1000000);
|
||||
}
|
||||
$retstring .= str_repeat(" ", $indent_last).$symbol_hash[$index_last].$repstr."\n";
|
||||
if(array_key_exists('m', $opt)) {
|
||||
$retstring .= str_repeat(" ", $indent_cur)."C: $file_hash[$file_last]:$line_last M: $memory\n";
|
||||
}
|
||||
$repstr = '';
|
||||
$repcnt = 0;
|
||||
$index_last = $index_cur;
|
||||
$indent_last = $indent_cur;
|
||||
$file_last = $file;
|
||||
$line_last = $line;
|
||||
}
|
||||
}
|
||||
$indent_cur++;
|
||||
continue;
|
||||
}
|
||||
if( $token == '@') {
|
||||
list($file_no, $line_no, $ut, $st, $rt) = preg_split("/ /", $data);
|
||||
$top = array_pop($callstack);
|
||||
$this->utimes[$top] += $ut;
|
||||
$utotal += $ut;
|
||||
$this->stimes[$top] += $st;
|
||||
$stotal += $st;
|
||||
$rtimes[$top] += $rt;
|
||||
$rtotal += $rt;
|
||||
array_push($callstack, $top);
|
||||
foreach ($callstack as $stack_element) {
|
||||
$this->c_utimes[$stack_element] += $ut;
|
||||
$this->c_stimes[$stack_element] += $st;
|
||||
$c_rtimes[$stack_element] += $rt;
|
||||
}
|
||||
continue;
|
||||
}
|
||||
if ($token == '-') {
|
||||
list ($index, $memory) = preg_split("/ /", $data, 2);
|
||||
if(array_key_exists('i',$opt) && $symbol_type[$index] == 1)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
$this->mem[$index] += ($memory - $last_memory);
|
||||
$last_memory = $memory;
|
||||
$indent_cur--;
|
||||
$tmp = array_pop($callstack);
|
||||
continue;
|
||||
}
|
||||
}
|
||||
$this->parse_info('FOOTER', $DATA, $cfg);
|
||||
$sort = 'by_time';
|
||||
if(array_key_exists('l', $opt)) { $sort = 'by_calls'; }
|
||||
if(array_key_exists('m', $opt)) { $sort = 'by_mem'; }
|
||||
if(array_key_exists('a', $opt)) { $sort = 'by_name'; }
|
||||
if(array_key_exists('v', $opt)) { $sort = 'by_avgcpu'; }
|
||||
if(array_key_exists('r', $opt)) { $sort = 'by_rtime'; }
|
||||
if(array_key_exists('R', $opt)) { $sort = 'by_c_rtime'; }
|
||||
if(array_key_exists('s', $opt)) { $sort = 'by_stime'; }
|
||||
if(array_key_exists('S', $opt)) { $sort = 'by_c_stime'; }
|
||||
if(array_key_exists('u', $opt)) { $sort = 'by_utime'; }
|
||||
if(array_key_exists('U', $opt)) { $sort = 'by_c_utime'; }
|
||||
if(array_key_exists('Z', $opt)) { $sort = 'by_c_time'; }
|
||||
if( !count($symbol_hash)) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
$retstring .= sprintf("
|
||||
Trace for %s
|
||||
Total Elapsed Time = %4.2f
|
||||
Total System Time = %4.2f
|
||||
Total User Time = %4.2f
|
||||
", $cfg['caller'], $rtotal/1000000, $stotal/1000000, $utotal/1000000);
|
||||
|
||||
$retstring .= "\n
|
||||
Real User System secs/ cumm
|
||||
%Time (excl/cumm) (excl/cumm) (excl/cumm) Calls call s/call Memory Usage Name
|
||||
--------------------------------------------------------------------------------------\n";
|
||||
$l = 0;
|
||||
$itotal = 0;
|
||||
$percall = 0;
|
||||
$cpercall = 0;
|
||||
|
||||
uksort($symbol_hash, $sort);
|
||||
foreach (array_keys($symbol_hash) as $j) {
|
||||
if(array_key_exists('i', $opt) && $symbol_type[$j] == 1) {
|
||||
continue;
|
||||
}
|
||||
if ($l++ < $opt['O']) {
|
||||
$pcnt = 100*($this->stimes[$j] + $this->utimes[$j])/($utotal + $stotal + $itotal);
|
||||
$c_pcnt = 100* ($this->c_stimes[$j] + $this->c_utimes[$j])/($utotal + $stotal + $itotal);
|
||||
$rsecs = $rtimes[$j]/1000000;
|
||||
$ssecs = $this->stimes[$j]/1000000;
|
||||
$usecs = $this->utimes[$j]/1000000;
|
||||
$c_rsecs = $c_rtimes[$j]/1000000;
|
||||
$c_ssecs = $this->c_stimes[$j]/1000000;
|
||||
$c_usecs = $this->c_utimes[$j]/1000000;
|
||||
$ncalls = $calls[$j];
|
||||
if(array_key_exists('z', $opt)) {
|
||||
$percall = ($usecs + $ssecs)/$ncalls;
|
||||
$cpercall = ($c_usecs + $c_ssecs)/$ncalls;
|
||||
if($utotal + $stotal) {
|
||||
$pcnt = 100*($this->stimes[$j] + $this->utimes[$j])/($utotal + $stotal);
|
||||
}
|
||||
else {
|
||||
$pcnt = 100;
|
||||
}
|
||||
}
|
||||
if(array_key_exists('Z', $opt)) {
|
||||
$percall = ($usecs + $ssecs)/$ncalls;
|
||||
$cpercall = ($c_usecs + $c_ssecs)/$ncalls;
|
||||
if($utotal + $stotal) {
|
||||
$pcnt = 100*($this->c_stimes[$j] + $this->c_utimes[$j])/($utotal + $stotal);
|
||||
}
|
||||
else {
|
||||
$pcnt = 100;
|
||||
}
|
||||
}
|
||||
if(array_key_exists('r', $opt)) {
|
||||
$percall = ($rsecs)/$ncalls;
|
||||
$cpercall = ($c_rsecs)/$ncalls;
|
||||
if($rtotal) {
|
||||
$pcnt = 100*$rtimes[$j]/$rtotal;
|
||||
}
|
||||
else {
|
||||
$pcnt = 100;
|
||||
}
|
||||
}
|
||||
if(array_key_exists('R', $opt)) {
|
||||
$percall = ($rsecs)/$ncalls;
|
||||
$cpercall = ($c_rsecs)/$ncalls;
|
||||
if($rtotal) {
|
||||
$pcnt = 100*$c_rtimes[$j]/$rtotal;
|
||||
}
|
||||
else {
|
||||
$pcnt = 100;
|
||||
}
|
||||
}
|
||||
if(array_key_exists('u', $opt)) {
|
||||
$percall = ($usecs)/$ncalls;
|
||||
$cpercall = ($c_usecs)/$ncalls;
|
||||
if($utotal) {
|
||||
$pcnt = 100*$this->utimes[$j]/$utotal;
|
||||
}
|
||||
else {
|
||||
$pcnt = 100;
|
||||
}
|
||||
}
|
||||
if(array_key_exists('U', $opt)) {
|
||||
$percall = ($usecs)/$ncalls;
|
||||
$cpercall = ($c_usecs)/$ncalls;
|
||||
if($utotal) {
|
||||
$pcnt = 100*$this->c_utimes[$j]/$utotal;
|
||||
}
|
||||
else {
|
||||
$pcnt = 100;
|
||||
}
|
||||
}
|
||||
if(array_key_exists('s', $opt)) {
|
||||
$percall = ($ssecs)/$ncalls;
|
||||
$cpercall = ($c_ssecs)/$ncalls;
|
||||
if($stotal) {
|
||||
$pcnt = 100*$this->stimes[$j]/$stotal;
|
||||
}
|
||||
else {
|
||||
$pcnt = 100;
|
||||
}
|
||||
}
|
||||
if(array_key_exists('S', $opt)) {
|
||||
$percall = ($ssecs)/$ncalls;
|
||||
$cpercall = ($c_ssecs)/$ncalls;
|
||||
if($stotal) {
|
||||
$pcnt = 100*$this->c_stimes[$j]/$stotal;
|
||||
}
|
||||
else {
|
||||
$pcnt = 100;
|
||||
}
|
||||
}
|
||||
// $cpercall = ($c_usecs + $c_ssecs)/$ncalls;
|
||||
$mem_usage = $this->mem[$j];
|
||||
$name = $symbol_hash[$j];
|
||||
$retstring .= sprintf("%3.01f %2.02f %2.02f %2.02f %2.02f %2.02f %2.02f %4d %2.04f %2.04f %12d %s\n",
|
||||
$pcnt, $rsecs, $c_rsecs, $usecs, $c_usecs, $ssecs, $c_ssecs, $ncalls, $percall, $cpercall, $mem_usage, $name);
|
||||
return $retstring;
|
||||
}
|
||||
}
|
||||
return $retstring;
|
||||
}
|
||||
|
||||
function usage() {
|
||||
return <<<EOD
|
||||
Profiler::get_profiling(\$args)
|
||||
Sort options
|
||||
-a Sort by alphabetic names of subroutines.
|
||||
-l Sort by number of calls to subroutines
|
||||
-m Sort by memory used in a function call.
|
||||
-r Sort by real time spent in subroutines.
|
||||
-R Sort by real time spent in subroutines (inclusive of child calls).
|
||||
-s Sort by system time spent in subroutines.
|
||||
-S Sort by system time spent in subroutines (inclusive of child calls).
|
||||
-u Sort by user time spent in subroutines.
|
||||
-U Sort by user time spent in subroutines (inclusive of child calls).
|
||||
-v Sort by average amount of time spent in subroutines.
|
||||
-z Sort by user+system time spent in subroutines. (default)
|
||||
|
||||
Display options
|
||||
-c Display Real time elapsed alongside call tree.
|
||||
-i Suppress reporting for php builtin functions
|
||||
-O <cnt> Specifies maximum number of subroutines to display. (default 15)
|
||||
-t Display compressed call tree.
|
||||
-T Display uncompressed call tree.
|
||||
|
||||
EOD;
|
||||
exit(1);
|
||||
}
|
||||
|
||||
function parse_info($tag, $datasource, &$cfg) {
|
||||
while($line = fgets($datasource)) {
|
||||
$line = rtrim($line);
|
||||
if(preg_match("/^END_$tag$/", $line)) {
|
||||
break;
|
||||
}
|
||||
if(preg_match("/(\w+)=(.*)/", $line, $matches)) {
|
||||
$cfg[$matches[1]] = $matches[2];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function num_cmp($a, $b) {
|
||||
if (intval($a) > intval($b)) { return 1;}
|
||||
elseif(intval($a) < intval($b)) { return -1;}
|
||||
else {return 0;}
|
||||
}
|
||||
|
||||
function by_time($a,$b) {
|
||||
return $this->num_cmp(($this->stimes[$b] + $this->utimes[$b]),($this->stimes[$a] + $this->utimes[$a]));
|
||||
}
|
||||
|
||||
function by_c_time($a,$b) {
|
||||
return $this->num_cmp(($this->c_stimes[$b] + $this->c_utimes[$b]),($this->c_stimes[$a] + $this->c_utimes[$a]));
|
||||
}
|
||||
|
||||
function by_avgcpu($a,$b) {
|
||||
return $this->num_cmp(($this->stimes[$b] + $this->utimes[$b])/$this->calls[$b],($this->stimes[$a] + $this->utimes[$a])/$this->calls[$a]);
|
||||
}
|
||||
|
||||
function by_calls($a, $b) {
|
||||
return $this->num_cmp($this->calls[$b], $this->calls[$a]);
|
||||
}
|
||||
|
||||
function by_rtime($a,$b) {
|
||||
return $this->num_cmp($this->rtimes[$b], $this->rtimes[$a]);
|
||||
}
|
||||
|
||||
function by_c_rtime($a,$b) {
|
||||
return $this->num_cmp($this->c_rtimes[$b], $this->c_rtimes[$a]);
|
||||
}
|
||||
|
||||
function by_stime($a,$b) {
|
||||
return $this->num_cmp($this->stimes[$b], $this->stimes[$a]);
|
||||
}
|
||||
|
||||
function by_c_stime($a,$b) {
|
||||
return $this->num_cmp($this->c_stimes[$b], $this->c_stimes[$a]);
|
||||
}
|
||||
|
||||
function by_utime($a,$b) {
|
||||
return $this->num_cmp($this->utimes[$b], $this->utimes[$a]);
|
||||
}
|
||||
|
||||
function by_c_utime($a,$b) {
|
||||
return $this->num_cmp($this->c_utimes[$b], $this->c_utimes[$a]);
|
||||
}
|
||||
|
||||
function by_mem($a, $b) {
|
||||
return $this->num_cmp($this->mem[$b], $this->mem[$a]);
|
||||
}
|
||||
}
|
||||
@@ -862,15 +862,6 @@ function init_performance_info() {
|
||||
if (function_exists('posix_times')) {
|
||||
$PERF->startposixtimes = posix_times();
|
||||
}
|
||||
if (function_exists('apd_set_pprof_trace')) {
|
||||
// APD profiling
|
||||
if ($USER->id > 0 && $CFG->perfdebug >= 15) {
|
||||
$tempdir = $CFG->tempdir . '/profile/' . $USER->id;
|
||||
mkdir($tempdir);
|
||||
apd_set_pprof_trace($tempdir);
|
||||
$PERF->profiling = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
|
||||
@@ -98,13 +98,6 @@
|
||||
<version>1.1</version>
|
||||
<licenseversion></licenseversion>
|
||||
</library>
|
||||
<library>
|
||||
<location>pear/Console/Getopt.php</location>
|
||||
<name>Pear_Console_Getopt</name>
|
||||
<license>PHP</license>
|
||||
<version>1.2.3</version>
|
||||
<licenseversion>3.0</licenseversion>
|
||||
</library>
|
||||
<library>
|
||||
<location>pear/Crypt/CHAP.php</location>
|
||||
<name>Pear_Crypt_CHAP</name>
|
||||
|
||||
Reference in New Issue
Block a user