Page Menu
Home
c4science
Search
Configure Global Search
Log In
Files
F78257035
xhprof_lib.php
No One
Temporary
Actions
Download File
Edit File
Delete File
View Transforms
Subscribe
Mute Notifications
Award Token
Subscribers
None
File Metadata
Details
File Info
Storage
Attached
Created
Mon, Aug 19, 11:08
Size
23 KB
Mime Type
text/x-php
Expires
Wed, Aug 21, 11:08 (2 d)
Engine
blob
Format
Raw Data
Handle
20016640
Attached To
rPH Phabricator
xhprof_lib.php
View Options
<?php
// Copyright (c) 2009 Facebook
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
//
// This file contains various XHProf library (utility) functions.
// Do not add any display specific code here.
//
function
xhprof_error
(
$message
)
{
error_log
(
$message
);
}
/*
* The list of possible metrics collected as part of XHProf that
* require inclusive/exclusive handling while reporting.
*
* @author Kannan
*/
function
xhprof_get_possible_metrics
()
{
static
$possible_metrics
=
array
(
"wt"
=>
array
(
"Wall"
,
"microsecs"
,
"walltime"
),
"ut"
=>
array
(
"User"
,
"microsecs"
,
"user cpu time"
),
"st"
=>
array
(
"Sys"
,
"microsecs"
,
"system cpu time"
),
"cpu"
=>
array
(
"Cpu"
,
"microsecs"
,
"cpu time"
),
"mu"
=>
array
(
"MUse"
,
"bytes"
,
"memory usage"
),
"pmu"
=>
array
(
"PMUse"
,
"bytes"
,
"peak memory usage"
),
"samples"
=>
array
(
"Samples"
,
"samples"
,
"cpu time"
));
return
$possible_metrics
;
}
/*
* Get the list of metrics present in $xhprof_data as an array.
*
* @author Kannan
*/
function
xhprof_get_metrics
(
$xhprof_data
)
{
// get list of valid metrics
$possible_metrics
=
xhprof_get_possible_metrics
();
// return those that are present in the raw data.
// We'll just look at the root of the subtree for this.
$metrics
=
array
();
foreach
(
$possible_metrics
as
$metric
=>
$desc
)
{
if
(
isset
(
$xhprof_data
[
"main()"
][
$metric
]))
{
$metrics
[]
=
$metric
;
}
}
return
$metrics
;
}
/**
* Takes a parent/child function name encoded as
* "a==>b" and returns array("a", "b").
*
* @author Kannan
*/
function
xhprof_parse_parent_child
(
$parent_child
)
{
$ret
=
explode
(
"==>"
,
$parent_child
);
// Return if both parent and child are set
if
(
isset
(
$ret
[
1
]))
{
return
$ret
;
}
return
array
(
null
,
$ret
[
0
]);
}
/**
* Given parent & child function name, composes the key
* in the format present in the raw data.
*
* @author Kannan
*/
function
xhprof_build_parent_child_key
(
$parent
,
$child
)
{
if
(
$parent
)
{
return
$parent
.
"==>"
.
$child
;
}
else
{
return
$child
;
}
}
/**
* Checks if XHProf raw data appears to be valid and not corrupted.
*
* @param int $run_id Run id of run to be pruned.
* [Used only for reporting errors.]
* @param array $raw_data XHProf raw data to be pruned
* & validated.
*
* @return bool true on success, false on failure
*
* @author Kannan
*/
function
xhprof_valid_run
(
$run_id
,
$raw_data
)
{
$main_info
=
$raw_data
[
"main()"
];
if
(
empty
(
$main_info
))
{
xhprof_error
(
"XHProf: main() missing in raw data for Run ID: $run_id"
);
return
false
;
}
// raw data should contain either wall time or samples information...
if
(
isset
(
$main_info
[
"wt"
]))
{
$metric
=
"wt"
;
}
else
if
(
isset
(
$main_info
[
"samples"
]))
{
$metric
=
"samples"
;
}
else
{
xhprof_error
(
"XHProf: Wall Time information missing from Run ID: $run_id"
);
return
false
;
}
foreach
(
$raw_data
as
$info
)
{
$val
=
$info
[
$metric
];
// basic sanity checks...
if
(
$val
<
0
)
{
xhprof_error
(
"XHProf: $metric should not be negative: Run ID $run_id"
.
serialize
(
$info
));
return
false
;
}
if
(
$val
>
(
86400000000
))
{
xhprof_error
(
"XHProf: $metric > 1 day found in Run ID: $run_id "
.
serialize
(
$info
));
return
false
;
}
}
return
true
;
}
/**
* Return a trimmed version of the XHProf raw data. Note that the raw
* data contains one entry for each unique parent/child function
* combination.The trimmed version of raw data will only contain
* entries where either the parent or child function is in the list
* of $functions_to_keep.
*
* Note: Function main() is also always kept so that overall totals
* can still be obtained from the trimmed version.
*
* @param array XHProf raw data
* @param array array of function names
*
* @return array Trimmed XHProf Report
*
* @author Kannan
*/
function
xhprof_trim_run
(
$raw_data
,
$functions_to_keep
)
{
// convert list of functions to a hash with function as the key
$function_map
=
array_fill_keys
(
$functions_to_keep
,
1
);
// always keep main() as well so that overall totals can still
// be computed if need be.
$function_map
[
'main()'
]
=
1
;
$new_raw_data
=
array
();
foreach
(
$raw_data
as
$parent_child
=>
$info
)
{
list
(
$parent
,
$child
)
=
xhprof_parse_parent_child
(
$parent_child
);
if
(
isset
(
$function_map
[
$parent
])
||
isset
(
$function_map
[
$child
]))
{
$new_raw_data
[
$parent_child
]
=
$info
;
}
}
return
$new_raw_data
;
}
/**
* Takes raw XHProf data that was aggregated over "$num_runs" number
* of runs averages/nomalizes the data. Essentially the various metrics
* collected are divided by $num_runs.
*
* @author Kannan
*/
function
xhprof_normalize_metrics
(
$raw_data
,
$num_runs
)
{
if
(
empty
(
$raw_data
)
||
(
$num_runs
==
0
))
{
return
$raw_data
;
}
$raw_data_total
=
array
();
if
(
isset
(
$raw_data
[
"==>main()"
])
&&
isset
(
$raw_data
[
"main()"
]))
{
xhprof_error
(
"XHProf Error: both ==>main() and main() set in raw data..."
);
}
foreach
(
$raw_data
as
$parent_child
=>
$info
)
{
foreach
(
$info
as
$metric
=>
$value
)
{
$raw_data_total
[
$parent_child
][
$metric
]
=
(
$value
/
$num_runs
);
}
}
return
$raw_data_total
;
}
/**
* Get raw data corresponding to specified array of runs
* aggregated by certain weightage.
*
* Suppose you have run:5 corresponding to page1.php,
* run:6 corresponding to page2.php,
* and run:7 corresponding to page3.php
*
* and you want to accumulate these runs in a 2:4:1 ratio. You
* can do so by calling:
*
* xhprof_aggregate_runs(array(5, 6, 7), array(2, 4, 1));
*
* The above will return raw data for the runs aggregated
* in 2:4:1 ratio.
*
* @param object $xhprof_runs_impl An object that implements
* the iXHProfRuns interface
* @param array $runs run ids of the XHProf runs..
* @param array $wts integral (ideally) weights for $runs
* @param string $source source to fetch raw data for run from
* @param bool $use_script_name If true, a fake edge from main() to
* to __script::<scriptname> is introduced
* in the raw data so that after aggregations
* the script name is still preserved.
*
* @return array Return aggregated raw data
*
* @author Kannan
*/
function
xhprof_aggregate_runs
(
$xhprof_runs_impl
,
$runs
,
$wts
,
$source
=
"phprof"
,
$use_script_name
=
false
)
{
$raw_data_total
=
null
;
$raw_data
=
null
;
$metrics
=
array
();
$run_count
=
count
(
$runs
);
$wts_count
=
count
(
$wts
);
if
((
$run_count
==
0
)
||
((
$wts_count
>
0
)
&&
(
$run_count
!=
$wts_count
)))
{
return
array
(
'description'
=>
'Invalid input..'
,
'raw'
=>
null
);
}
$bad_runs
=
array
();
foreach
(
$runs
as
$idx
=>
$run_id
)
{
$raw_data
=
$xhprof_runs_impl
->
get_run
(
$run_id
,
$source
,
'?'
);
// use the first run to derive what metrics to aggregate on.
if
(
$idx
==
0
)
{
foreach
(
$raw_data
[
"main()"
]
as
$metric
=>
$val
)
{
if
(
$metric
!=
"pmu"
)
{
// for now, just to keep data size small, skip "peak" memory usage
// data while aggregating.
// The "regular" memory usage data will still be tracked.
if
(
isset
(
$val
))
{
$metrics
[]
=
$metric
;
}
}
}
}
if
(!
xhprof_valid_run
(
$run_id
,
$raw_data
))
{
$bad_runs
[]
=
$run_id
;
continue
;
}
if
(
$use_script_name
)
{
$page
=
'?'
;
// create a fake function '__script::$page', and have and edge from
// main() to '__script::$page'. We will also need edges to transfer
// all edges originating from main() to now originate from
// '__script::$page' to all function called from main().
//
// We also weight main() ever so slightly higher so that
// it shows up above the new entry in reports sorted by
// inclusive metrics or call counts.
if
(
$page
)
{
foreach
(
$raw_data
[
"main()"
]
as
$metric
=>
$val
)
{
$fake_edge
[
$metric
]
=
$val
;
$new_main
[
$metric
]
=
$val
+
0.00001
;
}
$raw_data
[
"main()"
]
=
$new_main
;
$raw_data
[
xhprof_build_parent_child_key
(
"main()"
,
"__script::$page"
)]
=
$fake_edge
;
}
else
{
$use_script_name
=
false
;
}
}
// if no weights specified, use 1 as the default weightage..
$wt
=
(
$wts_count
==
0
)
?
1
:
$wts
[
$idx
];
// aggregate $raw_data into $raw_data_total with appropriate weight ($wt)
foreach
(
$raw_data
as
$parent_child
=>
$info
)
{
if
(
$use_script_name
)
{
// if this is an old edge originating from main(), it now
// needs to be from '__script::$page'
if
(
substr
(
$parent_child
,
0
,
9
)
==
"main()==>"
)
{
$child
=
substr
(
$parent_child
,
9
);
// ignore the newly added edge from main()
if
(
substr
(
$child
,
0
,
10
)
!=
"__script::"
)
{
$parent_child
=
xhprof_build_parent_child_key
(
"__script::$page"
,
$child
);
}
}
}
if
(!
isset
(
$raw_data_total
[
$parent_child
]))
{
foreach
(
$metrics
as
$metric
)
{
$raw_data_total
[
$parent_child
][
$metric
]
=
(
$wt
*
$info
[
$metric
]);
}
}
else
{
foreach
(
$metrics
as
$metric
)
{
$raw_data_total
[
$parent_child
][
$metric
]
+=
(
$wt
*
$info
[
$metric
]);
}
}
}
}
$runs_string
=
implode
(
","
,
$runs
);
if
(
isset
(
$wts
))
{
$wts_string
=
"in the ratio ("
.
implode
(
":"
,
$wts
)
.
")"
;
$normalization_count
=
array_sum
(
$wts
);
}
else
{
$wts_string
=
""
;
$normalization_count
=
$run_count
;
}
$run_count
=
$run_count
-
count
(
$bad_runs
);
$data
[
'description'
]
=
"Aggregated Report for $run_count runs: "
.
"$runs_string $wts_string
\n
"
;
$data
[
'raw'
]
=
xhprof_normalize_metrics
(
$raw_data_total
,
$normalization_count
);
$data
[
'bad_runs'
]
=
$bad_runs
;
return
$data
;
}
/**
* Analyze hierarchical raw data, and compute per-function (flat)
* inclusive and exclusive metrics.
*
* Also, store overall totals in the 2nd argument.
*
* @param array $raw_data XHProf format raw profiler data.
* @param array &$overall_totals OUT argument for returning
* overall totals for various
* metrics.
* @return array Returns a map from function name to its
* call count and inclusive & exclusive metrics
* (such as wall time, etc.).
*
* @author Kannan Muthukkaruppan
*/
function
xhprof_compute_flat_info
(
$raw_data
,
&
$overall_totals
)
{
global
$display_calls
;
$metrics
=
xhprof_get_metrics
(
$raw_data
);
$overall_totals
=
array
(
"ct"
=>
0
,
"wt"
=>
0
,
"ut"
=>
0
,
"st"
=>
0
,
"cpu"
=>
0
,
"mu"
=>
0
,
"pmu"
=>
0
,
"samples"
=>
0
);
// compute inclusive times for each function
$symbol_tab
=
xhprof_compute_inclusive_times
(
$raw_data
);
/* total metric value is the metric value for "main()" */
foreach
(
$metrics
as
$metric
)
{
$overall_totals
[
$metric
]
=
$symbol_tab
[
"main()"
][
$metric
];
}
/*
* initialize exclusive (self) metric value to inclusive metric value
* to start with.
* In the same pass, also add up the total number of function calls.
*/
foreach
(
$symbol_tab
as
$symbol
=>
$info
)
{
foreach
(
$metrics
as
$metric
)
{
$symbol_tab
[
$symbol
][
"excl_"
.
$metric
]
=
$symbol_tab
[
$symbol
][
$metric
];
}
if
(
$display_calls
)
{
/* keep track of total number of calls */
$overall_totals
[
"ct"
]
+=
$info
[
"ct"
];
}
}
/* adjust exclusive times by deducting inclusive time of children */
foreach
(
$raw_data
as
$parent_child
=>
$info
)
{
list
(
$parent
,
$child
)
=
xhprof_parse_parent_child
(
$parent_child
);
if
(
$parent
)
{
foreach
(
$metrics
as
$metric
)
{
// make sure the parent exists hasn't been pruned.
if
(
isset
(
$symbol_tab
[
$parent
]))
{
$symbol_tab
[
$parent
][
"excl_"
.
$metric
]
-=
$info
[
$metric
];
}
}
}
}
return
$symbol_tab
;
}
/**
* Hierarchical diff:
* Compute and return difference of two call graphs: Run2 - Run1.
*
* @author Kannan
*/
function
xhprof_compute_diff
(
$xhprof_data1
,
$xhprof_data2
)
{
global
$display_calls
;
// use the second run to decide what metrics we will do the diff on
$metrics
=
xhprof_get_metrics
(
$xhprof_data2
);
$xhprof_delta
=
$xhprof_data2
;
foreach
(
$xhprof_data1
as
$parent_child
=>
$info
)
{
if
(!
isset
(
$xhprof_delta
[
$parent_child
]))
{
// this pc combination was not present in run1;
// initialize all values to zero.
if
(
$display_calls
)
{
$xhprof_delta
[
$parent_child
]
=
array
(
"ct"
=>
0
);
}
else
{
$xhprof_delta
[
$parent_child
]
=
array
();
}
foreach
(
$metrics
as
$metric
)
{
$xhprof_delta
[
$parent_child
][
$metric
]
=
0
;
}
}
if
(
$display_calls
)
{
$xhprof_delta
[
$parent_child
][
"ct"
]
-=
$info
[
"ct"
];
}
foreach
(
$metrics
as
$metric
)
{
$xhprof_delta
[
$parent_child
][
$metric
]
-=
$info
[
$metric
];
}
}
return
$xhprof_delta
;
}
/**
* Compute inclusive metrics for function. This code was factored out
* of xhprof_compute_flat_info().
*
* The raw data contains inclusive metrics of a function for each
* unique parent function it is called from. The total inclusive metrics
* for a function is therefore the sum of inclusive metrics for the
* function across all parents.
*
* @return array Returns a map of function name to total (across all parents)
* inclusive metrics for the function.
*
* @author Kannan
*/
function
xhprof_compute_inclusive_times
(
$raw_data
)
{
global
$display_calls
;
$metrics
=
xhprof_get_metrics
(
$raw_data
);
$symbol_tab
=
array
();
/*
* First compute inclusive time for each function and total
* call count for each function across all parents the
* function is called from.
*/
foreach
(
$raw_data
as
$parent_child
=>
$info
)
{
list
(
$parent
,
$child
)
=
xhprof_parse_parent_child
(
$parent_child
);
if
(
$parent
==
$child
)
{
/*
* XHProf PHP extension should never trigger this situation any more.
* Recursion is handled in the XHProf PHP extension by giving nested
* calls a unique recursion-depth appended name (for example, foo@1).
*/
xhprof_error
(
"Error in Raw Data: parent & child are both: $parent"
);
return
;
}
if
(!
isset
(
$symbol_tab
[
$child
]))
{
if
(
$display_calls
)
{
$symbol_tab
[
$child
]
=
array
(
"ct"
=>
$info
[
"ct"
]);
}
else
{
$symbol_tab
[
$child
]
=
array
();
}
foreach
(
$metrics
as
$metric
)
{
$symbol_tab
[
$child
][
$metric
]
=
$info
[
$metric
];
}
}
else
{
if
(
$display_calls
)
{
/* increment call count for this child */
$symbol_tab
[
$child
][
"ct"
]
+=
$info
[
"ct"
];
}
/* update inclusive times/metric for this child */
foreach
(
$metrics
as
$metric
)
{
$symbol_tab
[
$child
][
$metric
]
+=
$info
[
$metric
];
}
}
}
return
$symbol_tab
;
}
/*
* Prunes XHProf raw data:
*
* Any node whose inclusive walltime accounts for less than $prune_percent
* of total walltime is pruned. [It is possible that a child function isn't
* pruned, but one or more of its parents get pruned. In such cases, when
* viewing the child function's hierarchical information, the cost due to
* the pruned parent(s) will be attributed to a special function/symbol
* "__pruned__()".]
*
* @param array $raw_data XHProf raw data to be pruned & validated.
* @param double $prune_percent Any edges that account for less than
* $prune_percent of time will be pruned
* from the raw data.
*
* @return array Returns the pruned raw data.
*
* @author Kannan
*/
function
xhprof_prune_run
(
$raw_data
,
$prune_percent
)
{
$main_info
=
$raw_data
[
"main()"
];
if
(
empty
(
$main_info
))
{
xhprof_error
(
"XHProf: main() missing in raw data"
);
return
false
;
}
// raw data should contain either wall time or samples information...
if
(
isset
(
$main_info
[
"wt"
]))
{
$prune_metric
=
"wt"
;
}
else
if
(
isset
(
$main_info
[
"samples"
]))
{
$prune_metric
=
"samples"
;
}
else
{
xhprof_error
(
"XHProf: for main() we must have either wt "
.
"or samples attribute set"
);
return
false
;
}
// determine the metrics present in the raw data..
$metrics
=
array
();
foreach
(
$main_info
as
$metric
=>
$val
)
{
if
(
isset
(
$val
))
{
$metrics
[]
=
$metric
;
}
}
$prune_threshold
=
((
$main_info
[
$prune_metric
]
*
$prune_percent
)
/
100.0
);
// init_metrics($raw_data, null, null, false);
$flat_info
=
xhprof_compute_inclusive_times
(
$raw_data
);
foreach
(
$raw_data
as
$parent_child
=>
$info
)
{
list
(
$parent
,
$child
)
=
xhprof_parse_parent_child
(
$parent_child
);
// is this child's overall total from all parents less than threshold?
if
(
$flat_info
[
$child
][
$prune_metric
]
<
$prune_threshold
)
{
unset
(
$raw_data
[
$parent_child
]);
// prune the edge
}
else
if
(
$parent
&&
(
$parent
!=
"__pruned__()"
)
&&
(
$flat_info
[
$parent
][
$prune_metric
]
<
$prune_threshold
))
{
// Parent's overall inclusive metric is less than a threshold.
// All edges to the parent node will get nuked, and this child will
// be a dangling child.
// So instead change its parent to be a special function __pruned__().
$pruned_edge
=
xhprof_build_parent_child_key
(
"__pruned__()"
,
$child
);
if
(
isset
(
$raw_data
[
$pruned_edge
]))
{
foreach
(
$metrics
as
$metric
)
{
$raw_data
[
$pruned_edge
][
$metric
]+=
$raw_data
[
$parent_child
][
$metric
];
}
}
else
{
$raw_data
[
$pruned_edge
]
=
$raw_data
[
$parent_child
];
}
unset
(
$raw_data
[
$parent_child
]);
// prune the edge
}
}
return
$raw_data
;
}
/**
* Set one key in an array and return the array
*
* @author Kannan
*/
function
xhprof_array_set
(
$arr
,
$k
,
$v
)
{
$arr
[
$k
]
=
$v
;
return
$arr
;
}
/**
* Removes/unsets one key in an array and return the array
*
* @author Kannan
*/
function
xhprof_array_unset
(
$arr
,
$k
)
{
unset
(
$arr
[
$k
]);
return
$arr
;
}
/**
* Type definitions for URL params
*/
define
(
'XHPROF_STRING_PARAM'
,
1
);
define
(
'XHPROF_UINT_PARAM'
,
2
);
define
(
'XHPROF_FLOAT_PARAM'
,
3
);
define
(
'XHPROF_BOOL_PARAM'
,
4
);
/**
* Internal helper function used by various
* xhprof_get_param* flavors for various
* types of parameters.
*
* @param string name of the URL query string param
*
* @author Kannan
*/
function
xhprof_get_param_helper
(
$param
)
{
$val
=
null
;
if
(
isset
(
$_GET
[
$param
]))
$val
=
$_GET
[
$param
];
else
if
(
isset
(
$_POST
[
$param
]))
{
$val
=
$_POST
[
$param
];
}
return
$val
;
}
/**
* Extracts value for string param $param from query
* string. If param is not specified, return the
* $default value.
*
* @author Kannan
*/
function
xhprof_get_string_param
(
$param
,
$default
=
''
)
{
$val
=
xhprof_get_param_helper
(
$param
);
if
(
$val
===
null
)
return
$default
;
return
$val
;
}
/**
* Extracts value for unsigned integer param $param from
* query string. If param is not specified, return the
* $default value.
*
* If value is not a valid unsigned integer, logs error
* and returns null.
*
* @author Kannan
*/
function
xhprof_get_uint_param
(
$param
,
$default
=
0
)
{
$val
=
xhprof_get_param_helper
(
$param
);
if
(
$val
===
null
)
$val
=
$default
;
// trim leading/trailing whitespace
$val
=
trim
(
$val
);
// if it only contains digits, then ok..
if
(
ctype_digit
(
$val
))
{
return
$val
;
}
xhprof_error
(
"$param is $val. It must be an unsigned integer."
);
return
null
;
}
/**
* Extracts value for a float param $param from
* query string. If param is not specified, return
* the $default value.
*
* If value is not a valid unsigned integer, logs error
* and returns null.
*
* @author Kannan
*/
function
xhprof_get_float_param
(
$param
,
$default
=
0
)
{
$val
=
xhprof_get_param_helper
(
$param
);
if
(
$val
===
null
)
$val
=
$default
;
// trim leading/trailing whitespace
$val
=
trim
(
$val
);
// TBD: confirm the value is indeed a float.
if
(
true
)
// for now..
return
(
float
)
$val
;
xhprof_error
(
"$param is $val. It must be a float."
);
return
null
;
}
/**
* Extracts value for a boolean param $param from
* query string. If param is not specified, return
* the $default value.
*
* If value is not a valid unsigned integer, logs error
* and returns null.
*
* @author Kannan
*/
function
xhprof_get_bool_param
(
$param
,
$default
=
false
)
{
$val
=
xhprof_get_param_helper
(
$param
);
if
(
$val
===
null
)
$val
=
$default
;
// trim leading/trailing whitespace
$val
=
trim
(
$val
);
switch
(
strtolower
(
$val
))
{
case
'0'
:
case
'1'
:
$val
=
(
bool
)
$val
;
break
;
case
'true'
:
case
'on'
:
case
'yes'
:
$val
=
true
;
break
;
case
'false'
:
case
'off'
:
case
'no'
:
$val
=
false
;
break
;
default
:
xhprof_error
(
"$param is $val. It must be a valid boolean string."
);
return
null
;
}
return
$val
;
}
/**
* Initialize params from URL query string. The function
* creates globals variables for each of the params
* and if the URL query string doesn't specify a particular
* param initializes them with the corresponding default
* value specified in the input.
*
* @params array $params An array whose keys are the names
* of URL params who value needs to
* be retrieved from the URL query
* string. PHP globals are created
* with these names. The value is
* itself an array with 2-elems (the
* param type, and its default value).
* If a param is not specified in the
* query string the default value is
* used.
* @author Kannan
*/
function
xhprof_param_init
(
$params
)
{
/* Create variables specified in $params keys, init defaults */
foreach
(
$params
as
$k
=>
$v
)
{
switch
(
$v
[
0
])
{
case
XHPROF_STRING_PARAM
:
$p
=
xhprof_get_string_param
(
$k
,
$v
[
1
]);
break
;
case
XHPROF_UINT_PARAM
:
$p
=
xhprof_get_uint_param
(
$k
,
$v
[
1
]);
break
;
case
XHPROF_FLOAT_PARAM
:
$p
=
xhprof_get_float_param
(
$k
,
$v
[
1
]);
break
;
case
XHPROF_BOOL_PARAM
:
$p
=
xhprof_get_bool_param
(
$k
,
$v
[
1
]);
break
;
default
:
xhprof_error
(
"Invalid param type passed to xhprof_param_init: "
.
$v
[
0
]);
exit
();
}
// create a global variable using the parameter name.
$GLOBALS
[
$k
]
=
$p
;
}
}
/**
* Given a partial query string $q return matching function names in
* specified XHProf run. This is used for the type ahead function
* selector.
*
* @author Kannan
*/
function
xhprof_get_matching_functions
(
$q
,
$xhprof_data
)
{
$matches
=
array
();
foreach
(
$xhprof_data
as
$parent_child
=>
$info
)
{
list
(
$parent
,
$child
)
=
xhprof_parse_parent_child
(
$parent_child
);
if
(
stripos
(
$parent
,
$q
)
!==
false
)
{
$matches
[
$parent
]
=
1
;
}
if
(
stripos
(
$child
,
$q
)
!==
false
)
{
$matches
[
$child
]
=
1
;
}
}
$res
=
array_keys
(
$matches
);
// sort it so the answers are in some reliable order...
asort
(
$res
);
return
(
$res
);
}
Event Timeline
Log In to Comment