public static function read_sensor()
{
// Determine current percentage for processor usage
if (phodevi::is_linux() || phodevi::is_bsd()) {
$start_load = self::cpu_load_array(-1);
sleep(1);
$end_load = self::cpu_load_array(-1);
for ($i = 0; $i < count($end_load); $i++) {
$end_load[$i] -= $start_load[$i];
}
$percent = ($sum = array_sum($end_load)) == 0 ? 0 : 100 - $end_load[count($end_load) - 1] * 100 / $sum;
} else {
if (phodevi::is_solaris()) {
// TODO: Add support for monitoring load on a per-core basis (through mpstat maybe?)
$info = explode(' ', pts_strings::trim_spaces(pts_arrays::last_element(explode("\n", trim(shell_exec('sar -u 1 1 2>&1'))))));
$percent = $info[1] + $info[2];
} else {
if (phodevi::is_macosx()) {
// CPU usage for user
$top = shell_exec('top -n 1 -l 1 2>&1');
$top = substr($top, strpos($top, 'CPU usage: ') + 11);
$percent = substr($top, 0, strpos($top, '%'));
} else {
$percent = null;
}
}
}
if (!is_numeric($percent) || $percent < 0 || $percent > 100) {
$percent = -1;
}
return pts_math::set_precision($percent, 2);
}
public static function image_file_to_gd($img_file)
{
$img = false;
switch (strtolower(pts_arrays::last_element(explode('.', $img_file)))) {
case 'tga':
$img = pts_image::imagecreatefromtga($img_file);
break;
case 'png':
$img = imagecreatefrompng($img_file);
break;
case 'jpg':
case 'jpeg':
$img = imagecreatefromjpeg($img_file);
break;
}
return $img;
}
public static function prompt_text_menu($user_string, $options_r, $allow_multi_select = false, $return_index = false, $line_prefix = null)
{
$option_count = count($options_r);
if ($option_count == 1) {
return $return_index ? pts_arrays::last_element(array_keys($options_r)) : array_pop($options_r);
}
$select = array();
do {
echo PHP_EOL;
$key_index = array();
foreach (array_keys($options_r) as $i => $key) {
$key_index[$i + 1] = $key;
echo $line_prefix . ($i + 1) . ': ' . str_repeat(' ', strlen($option_count) - strlen($i + 1)) . $options_r[$key] . PHP_EOL;
}
echo $line_prefix . $user_string . ': ';
$select_choice = pts_user_io::read_user_input();
foreach ($allow_multi_select ? pts_strings::comma_explode($select_choice) : array($select_choice) as $choice) {
if (in_array($choice, $options_r)) {
$select[] = array_search($choice, $options_r);
} else {
if (isset($key_index[$choice])) {
$select[] = $key_index[$choice];
} else {
if ($allow_multi_select && strpos($choice, '-') !== false) {
$choice_range = pts_strings::trim_explode('-', $choice);
if (count($choice_range) == 2 && is_numeric($choice_range[0]) && is_numeric($choice_range[1]) && isset($key_index[$choice_range[0]]) && isset($key_index[$choice_range[1]])) {
for ($i = min($choice_range); $i <= max($choice_range); $i++) {
$select[] = $key_index[$i];
}
}
}
}
}
}
} while (!isset($select[0]));
if ($return_index == false) {
foreach ($select as &$index) {
$index = $options_r[$index];
}
}
return implode(',', $select);
}
protected static function download_test_files(&$test_install_request, $download_location = false, $no_prompts = false)
{
// Download needed files for a test
if ($test_install_request->get_download_object_count() == 0) {
return true;
}
$identifier = $test_install_request->test_profile->get_identifier();
pts_client::$display->test_install_downloads($test_install_request);
if ($download_location == false) {
$download_location = $test_install_request->test_profile->get_install_dir();
}
pts_file_io::mkdir($download_location);
$module_pass = array($identifier, $test_install_request->get_download_objects());
pts_module_manager::module_process('__pre_test_download', $module_pass);
foreach ($test_install_request->get_download_objects() as $download_package) {
$package_filename = $download_package->get_filename();
$download_destination = $download_location . $package_filename;
$download_destination_temp = $download_destination . '.pts';
if ($download_package->get_download_location_type() == null) {
// Attempt a possible last-minute look-aside copy cache in case a previous test in the install queue downloaded this file already
$lookaside_copy = pts_test_install_manager::file_lookaside_test_installations($download_package);
if ($lookaside_copy) {
if ($download_package->get_filesize() == 0) {
$download_package->set_filesize(filesize($lookaside_copy));
}
$download_package->set_download_location('LOOKASIDE_DOWNLOAD_CACHE', array($lookaside_copy));
}
}
switch ($download_package->get_download_location_type()) {
case 'IN_DESTINATION_DIR':
pts_client::$display->test_install_download_file('FILE_FOUND', $download_package);
continue;
case 'REMOTE_DOWNLOAD_CACHE':
$download_tries = 0;
do {
foreach ($download_package->get_download_location_path() as $remote_download_cache_file) {
pts_client::$display->test_install_download_file('DOWNLOAD_FROM_CACHE', $download_package);
pts_network::download_file($remote_download_cache_file, $download_destination_temp);
if (!is_file($download_destination_temp) || filesize($download_destination_temp) == 0) {
self::test_install_error(null, $test_install_request, 'The file failed to download from the cache.');
pts_file_io::unlink($download_destination_temp);
break;
} else {
if ($download_package->check_file_hash($download_destination_temp)) {
rename($download_destination_temp, $download_destination);
break;
} else {
self::test_install_error(null, $test_install_request, 'The check-sum of the downloaded file failed.');
pts_file_io::unlink($download_destination_temp);
}
}
}
$download_tries++;
} while (!is_file($download_destination) && $download_tries < 2);
if (is_file($download_destination)) {
continue;
}
case 'MAIN_DOWNLOAD_CACHE':
case 'LOCAL_DOWNLOAD_CACHE':
case 'LOOKASIDE_DOWNLOAD_CACHE':
$download_cache_file = pts_arrays::last_element($download_package->get_download_location_path());
if (is_file($download_cache_file)) {
if (pts_config::read_bool_config('PhoronixTestSuite/Options/Installation/SymLinkFilesFromCache', 'FALSE') && $download_package->get_download_location_type() != 'LOOKASIDE_DOWNLOAD_CACHE') {
// For look-aside copies never symlink (unless a pre-packaged LiveCD) in case the other test ends up being un-installed
// SymLinkFilesFromCache is disabled by default
pts_client::$display->test_install_download_file('LINK_FROM_CACHE', $download_package);
symlink($download_cache_file, $download_destination);
} else {
// File is to be copied
// Try up to two times to copy a file
$attempted_copies = 0;
do {
pts_client::$display->test_install_download_file('COPY_FROM_CACHE', $download_package);
// $context = stream_context_create();
// stream_context_set_params($context, array('notification' => array('pts_network', 'stream_status_callback')));
// TODO: get the context working correctly for this copy()
copy($download_cache_file, $download_destination_temp);
pts_client::$display->test_install_progress_completed();
// Verify that the file was copied fine
if ($download_package->check_file_hash($download_destination_temp)) {
rename($download_destination_temp, $download_destination);
break;
} else {
self::test_install_error(null, $test_install_request, 'The check-sum of the copied file failed.');
pts_file_io::unlink($download_destination_temp);
}
$attempted_copies++;
} while ($attempted_copies < 2);
}
if (is_file($download_destination)) {
continue;
}
}
default:
$package_urls = $download_package->get_download_url_array();
// Download the file
if (!is_file($download_destination) && count($package_urls) > 0 && $package_urls[0] != null) {
$fail_count = 0;
do {
if (pts_network::internet_support_available()) {
if (!$no_prompts && pts_config::read_bool_config('PhoronixTestSuite/Options/Installation/PromptForDownloadMirror', 'FALSE') && count($package_urls) > 1) {
// Prompt user to select mirror
do {
echo PHP_EOL . 'Available Download Mirrors:' . PHP_EOL . PHP_EOL;
$url = pts_user_io::prompt_text_menu('Select Preferred Mirror', $package_urls, false);
} while (pts_strings::is_url($url) == false);
} else {
// Auto-select mirror
shuffle($package_urls);
do {
$url = array_pop($package_urls);
} while (pts_strings::is_url($url) == false && !empty($package_urls));
}
pts_client::$display->test_install_download_file('DOWNLOAD', $download_package);
$download_start = time();
pts_network::download_file($url, $download_destination_temp);
$download_end = time();
} else {
self::test_install_error(null, $test_install_request, 'Internet support is needed and it\'s disabled or not available.');
return false;
}
if ($download_package->check_file_hash($download_destination_temp)) {
// Download worked
if (is_file($download_destination_temp)) {
rename($download_destination_temp, $download_destination);
}
if ($download_package->get_filesize() > 0 && $download_end != $download_start) {
pts_download_speed_manager::update_download_speed_average($download_package->get_filesize(), $download_end - $download_start);
}
} else {
// Download failed
if (is_file($download_destination_temp) && filesize($download_destination_temp) < 500 && (stripos(file_get_contents($download_destination_temp), 'not found') !== false || strpos(file_get_contents($download_destination_temp), 404) !== false)) {
self::test_install_error(null, $test_install_request, 'File Not Found: ' . $url);
$md5_failed = false;
} else {
if (is_file($download_destination_temp) && filesize($download_destination_temp) > 0) {
self::test_install_error(null, $test_install_request, 'Checksum Failed: ' . $url);
$md5_failed = true;
} else {
self::test_install_error(null, $test_install_request, 'Download Failed: ' . $url);
$md5_failed = false;
}
}
pts_file_io::unlink($download_destination_temp);
$fail_count++;
if ($fail_count > 3) {
$try_again = false;
} else {
if (count($package_urls) > 0 && $package_urls[0] != null) {
self::test_install_error(null, $test_install_request, 'Attempting to download from alternate mirror.');
$try_again = true;
} else {
if ($no_prompts) {
$try_again = false;
} else {
if ($md5_failed) {
$try_again = pts_user_io::prompt_bool_input('Try downloading the file again', true, 'TRY_DOWNLOAD_AGAIN');
} else {
$try_again = false;
}
}
if ($try_again) {
$package_urls[] = $url;
}
}
}
if (!$try_again) {
//self::test_install_error(null, $test_install_request, 'Download of Needed Test Dependencies Failed!');
return false;
}
}
} while (!is_file($download_destination));
}
pts_module_manager::module_process('__interim_test_download', $module_pass);
}
}
pts_module_manager::module_process('__post_test_download', $identifier);
return true;
}
public static function evaluate_redundant_identifier_words($identifiers)
{
if (count($identifiers) < 4 || strpos(pts_arrays::first_element($identifiers), ':') !== false) {
// Probably not worth shortening so few result identifiers
return false;
}
// Breakup the an identifier into an array by spaces to be used for comparison
$common_segments = explode(' ', pts_arrays::first_element($identifiers));
$common_segments_last = explode(' ', pts_arrays::last_element($identifiers));
if (!isset($common_segments_last[2]) || !isset($common_segments[2])) {
// If there aren't at least three words in identifier, probably can't be shortened well
return false;
}
foreach (array_reverse($identifiers) as $id) {
$words = explode(' ', $id);
foreach ($words as $i => $word) {
if (isset($common_segments[$i]) && $word != $common_segments[$i] && isset($word[2]) && !ctype_alnum(substr($word, -1))) {
// IS COMMON WORD
} else {
unset($common_segments[$i]);
}
}
if (count($common_segments) == 0) {
return false;
}
}
return $common_segments;
}
public static function environmental_variables()
{
// The PTS environmental variables passed during the testing process, etc
static $env_variables = null;
if ($env_variables == null) {
$env_variables = array('PTS_VERSION' => PTS_VERSION, 'PTS_CODENAME' => PTS_CODENAME, 'PTS_DIR' => PTS_PATH, 'PHP_BIN' => PHP_BIN, 'NUM_CPU_CORES' => phodevi::read_property('cpu', 'core-count'), 'NUM_CPU_NODES' => phodevi::read_property('cpu', 'node-count'), 'NUM_CPU_JOBS' => phodevi::read_property('cpu', 'core-count') * 2, 'SYS_MEMORY' => phodevi::read_property('memory', 'capacity'), 'VIDEO_MEMORY' => phodevi::read_property('gpu', 'memory-capacity'), 'VIDEO_WIDTH' => pts_arrays::first_element(phodevi::read_property('gpu', 'screen-resolution')), 'VIDEO_HEIGHT' => pts_arrays::last_element(phodevi::read_property('gpu', 'screen-resolution')), 'VIDEO_MONITOR_COUNT' => phodevi::read_property('monitor', 'count'), 'VIDEO_MONITOR_LAYOUT' => phodevi::read_property('monitor', 'layout'), 'VIDEO_MONITOR_SIZES' => phodevi::read_property('monitor', 'modes'), 'OPERATING_SYSTEM' => phodevi::read_property('system', 'vendor-identifier'), 'OS_VERSION' => phodevi::read_property('system', 'os-version'), 'OS_ARCH' => phodevi::read_property('system', 'kernel-architecture'), 'OS_TYPE' => phodevi::operating_system(), 'THIS_RUN_TIME' => PTS_INIT_TIME, 'DEBUG_REAL_HOME' => pts_core::user_home_directory());
if (!pts_client::executable_in_path('cc') && pts_client::executable_in_path('gcc') && getenv('CC') == false) {
// This helps some test profiles build correctly if they don't do a cc check internally
$env_variables['CC'] = 'gcc';
}
}
return $env_variables;
}
protected static function process_user_config_external_hook_process($process, $cmd_value, $description_string = null, &$passed_obj = null)
{
if (!empty($cmd_value) && (is_executable($cmd_value) || ($cmd_value = pts_client::executable_in_path($cmd_value)))) {
$descriptor_spec = array(0 => array('pipe', 'r'), 1 => array('pipe', 'w'), 2 => array('pipe', 'w'));
$env_vars = array('PTS_EXTERNAL_TEST_HOOK' => $process);
if ($passed_obj instanceof pts_test_result) {
$env_vars['PTS_EXTERNAL_TEST_IDENTIFIER'] = $passed_obj->test_profile->get_identifier();
$env_vars['PTS_EXTERNAL_TEST_RUN_POSITION'] = $passed_obj->test_result_buffer->get_count() + 1;
$env_vars['PTS_EXTERNAL_TEST_RUN_COUNT'] = $passed_obj->test_profile->get_times_to_run();
$env_vars['PTS_EXTERNAL_TEST_ARGS'] = $passed_obj->get_arguments();
$env_vars['PTS_EXTERNAL_TEST_DESCRIPTION'] = $passed_obj->get_arguments_description();
$env_vars['PTS_EXTERNAL_TEST_RESULT_SET'] = $passed_obj->test_result_buffer->get_values_as_string();
$env_vars['PTS_EXTERNAL_TEST_RESULT'] = $passed_obj->get_result() != 0 ? $passed_obj->get_result() : pts_arrays::last_element($passed_obj->test_result_buffer->get_values());
$env_vars['PTS_EXTERNAL_TEST_HASH'] = bin2hex($passed_obj->get_comparison_hash());
$env_vars['PTS_EXTERNAL_TEST_STD_DEV_PERCENT'] = pts_math::percent_standard_deviation($passed_obj->test_result_buffer->get_values());
if (is_file($passed_obj->test_profile->get_install_dir() . 'cache-share-' . PTS_INIT_TIME . '.pt2so')) {
// There's a cache share present
$env_vars['PTS_EXTERNAL_TEST_CACHE_SHARE'] = 1;
}
} else {
if ($passed_obj instanceof pts_test_run_manager) {
$env_vars['PTS_EXTERNAL_TESTS_IN_QUEUE'] = implode(':', $passed_obj->get_tests_to_run_identifiers());
$env_vars['PTS_EXTERNAL_TEST_FILE_NAME'] = $passed_obj->get_file_name();
$env_vars['PTS_EXTERNAL_TEST_IDENTIFIER'] = $passed_obj->get_results_identifier();
}
}
$description_string != null && pts_client::$display->test_run_instance_error($description_string);
$proc = proc_open($cmd_value, $descriptor_spec, $pipes, null, $env_vars);
$std_output = stream_get_contents($pipes[1]);
$return_value = proc_close($proc);
// If you want PTS to exit or something when your script returns !0, you could add an 'exit;' or whatever you want below
// The contents of $std_output is anything that may have been written by your script, if you want it to be interpreted by anything in this module
if ($return_value != 0) {
return false;
}
}
return true;
}
public function __construct(&$result_object = null, &$result_file = null)
{
// Initalize Colors
$this->i['identifier_size'] = self::$c['size']['identifiers'];
// Copy this since it's commonly overwritten
$this->i['graph_orientation'] = 'VERTICAL';
$this->i['graph_value_type'] = 'NUMERICAL';
$this->i['hide_graph_identifiers'] = false;
$this->i['show_graph_key'] = false;
$this->i['show_background_lines'] = false;
$this->i['iveland_view'] = false;
$this->i['graph_max_value_multiplier'] = 1.285;
$this->i['graph_max_value'] = 0;
$this->i['bottom_offset'] = 0;
$this->i['hide_y_title'] = false;
$this->i['compact_result_view'] = false;
$this->i['key_line_height'] = 0;
$this->i['graph_height'] = 0;
$this->i['graph_width'] = 0;
$this->i['left_start'] = 10;
$this->i['left_end_right'] = 10;
$this->i['top_start'] = 62;
$this->i['top_end_bottom'] = 22;
$this->i['mark_count'] = 6;
// Number of marks to make on vertical axis
$this->i['notes'] = array();
// Reset of setup besides config
if ($result_object != null) {
$test_version = $result_object->test_profile->get_app_version();
if (isset($test_version[2]) && is_numeric($test_version[0])) {
$test_version = 'v' . $test_version;
}
$this->graph_title = trim($result_object->test_profile->get_title() . ' ' . $test_version);
$this->graph_y_title = $result_object->test_profile->get_result_scale_formatted();
$this->test_identifier = $result_object->test_profile->get_identifier();
$this->i['graph_proportion'] = $result_object->test_profile->get_result_proportion();
$this->addSubTitle($result_object->get_arguments_description());
}
$this->update_graph_dimensions(self::$c['graph']['width'], self::$c['graph']['height'], true);
if ($result_file != null && $result_file instanceof pts_result_file) {
$pts_version = pts_arrays::last_element($result_file->get_system_pts_version());
$this->is_multi_way_comparison = $result_file->is_multi_way_comparison();
}
if (!isset($pts_version) || empty($pts_version)) {
$pts_version = PTS_VERSION;
}
$this->i['graph_version'] = 'Phoronix Test Suite ' . $pts_version;
}
private function cpu_usage_solaris()
{
//TODO test this on Solaris
//TODO: Add support for monitoring load on a per-core basis (through mpstat maybe?)
$info = explode(' ', pts_strings::trim_spaces(pts_arrays::last_element(explode("\n", trim(shell_exec('sar -u 1 1 2>&1'))))));
$percent = $info[1] + $info[2];
return $percent;
}
public function increase_run_count_check(&$active_result_buffer, $scheduled_times_to_run, $latest_test_run_time)
{
// First make sure this test doesn't take too long to run where we don't want dynamic handling
if (floor($latest_test_run_time / 60) > $this->dynamic_run_count_on_length_or_less) {
return false;
}
// Determine if results are statistically significant, otherwise up the run count
$std_dev = pts_math::percent_standard_deviation($active_result_buffer->results);
if ($std_dev >= $this->dynamic_run_count_std_deviation_threshold) {
static $last_run_count = 128;
// just a number that should always cause the first check below to be true
static $run_std_devs;
$times_already_ran = $active_result_buffer->get_trial_run_count();
if ($times_already_ran <= $last_run_count) {
// We're now onto a new test so clear out the array
$run_std_devs = array();
}
$last_run_count = $times_already_ran;
$run_std_devs[$last_run_count] = $std_dev;
// If we haven't reached scheduled times to run x 2, increase count straight away
if ($times_already_ran < $scheduled_times_to_run * 2) {
return true;
} else {
if ($times_already_ran < $scheduled_times_to_run * 3) {
// More aggressive determination whether to still keep increasing the run count
$first_and_now_diff = pts_arrays::first_element($run_std_devs) - pts_arrays::last_element($run_std_devs);
// Increasing the run count at least looks to be helping...
if ($first_and_now_diff > pts_arrays::first_element($run_std_devs) / 2) {
// If we are at least making progress in the right direction, increase the run count some more
return true;
}
// TODO: could add more checks and take better advantage of the array of data to better determine if it's still worth increasing
}
}
}
// Check to see if there is an external/custom script to export the results to in determining whether results are valid
if (($ex_file = $this->dynamic_run_count_export_script) != null && is_executable($ex_file) || is_executable($ex_file = PTS_USER_PATH . $this->dynamic_run_count_export_script)) {
$exit_status = trim(shell_exec($ex_file . ' ' . $active_result_buffer->get_values_as_string() . ' > /dev/null 2>&1; echo $?'));
switch ($exit_status) {
case 1:
// Run the test again
return true;
case 2:
// Results are bad, abandon testing and do not record results
return -1;
case 0:
default:
// Return was 0 or something else, results are valid, or was some other exit status
break;
}
}
// No reason to increase the run count with none of the previous checks requesting otherwise
return false;
}
public function get_results()
{
$return_results = array();
$compared_to_index = array();
foreach ($this->relations as $test_name => $tests_of_same_name) {
foreach ($tests_of_same_name as $test_version => $tests_of_same_name_and_version) {
if (count($tests_of_same_name_and_version) == 1) {
// Stub, no similar results to analyze
array_push($return_results, $this->test_results[$tests_of_same_name_and_version[0][0]]);
} else {
if (in_array($this->test_results[$tests_of_same_name_and_version[0][0]]->test_profile->get_display_format(), array('IMAGE_COMPARISON', 'LINE_GRAPH'))) {
foreach ($tests_of_same_name_and_version as $add) {
array_push($return_results, $this->test_results[$add[0]]);
}
} else {
foreach ($tests_of_same_name_and_version as $test_info) {
$similar_ids = array($test_info[0]);
$similar_ids_names = array();
$diff_index = null;
$this_attributes = $test_info[1];
foreach ($tests_of_same_name_and_version as $compare_to) {
if (in_array($compare_to[0], $similar_ids)) {
continue;
}
$diff = array_diff_assoc($this_attributes, $compare_to[1]);
if (count($diff) == 1) {
if ($diff_index == null) {
$this_index = pts_arrays::last_element(array_keys($diff));
//$this_index_value = $diff[$this_index];
$index_id = implode(',', array($test_name, $test_version, $this_index));
if (in_array($index_id, $compared_to_index)) {
continue;
}
array_push($compared_to_index, $index_id);
array_push($similar_ids_names, $this_attributes[$this_index]);
$diff_index = $this_index;
}
if (isset($diff[$diff_index])) {
array_push($similar_ids, $compare_to[0]);
array_push($similar_ids_names, $compare_to[1][$diff_index]);
}
}
}
if (count($similar_ids) > 1) {
$mto = $this->test_results[$similar_ids[0]];
$results = array();
foreach ($mto->test_result_buffer->get_identifiers() as $identifier) {
$results[$identifier] = array();
}
foreach ($similar_ids as $id) {
$mto_read = $this->test_results[$id];
$mto_identifiers = $mto_read->test_result_buffer->get_identifiers();
$mto_values = $mto_read->test_result_buffer->get_values();
foreach (array_keys($results) as $key) {
for ($i = 0; $i < count($mto_identifiers); $i++) {
if ($mto_identifiers[$i] == $key) {
array_push($results[$key], $mto_values[$i]);
break;
}
}
}
}
$mto->test_result_buffer = new pts_test_result_buffer();
$do_line_graph = true;
foreach ($similar_ids_names as $id_name_check) {
if (str_ireplace(array(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 'x', 'M', 'K', 'B', ' '), null, $id_name_check) != null) {
$do_line_graph = false;
break;
}
}
if ($do_line_graph && count($similar_ids_names) < 4) {
$do_line_graph = false;
}
$mto->test_profile->set_display_format($do_line_graph ? 'LINE_GRAPH' : 'BAR_ANALYZE_GRAPH');
$mto->set_used_arguments_description($diff_index . ' Analysis');
$mto->test_profile->set_result_scale($mto->test_profile->get_result_scale() . ' | ' . implode(',', $similar_ids_names));
foreach ($results as $identifier => $values) {
$mto->test_result_buffer->add_test_result($identifier, implode(',', $values), null);
}
array_push($return_results, $mto);
}
}
}
}
}
}
return $return_results;
}
