PHP pts_arrays::first_element方法代码示例

 public static function run($r)
 {
     $compare_tests = array();
     $compare_subsystems = array();
     foreach ($r as $test_object) {
         $test_object = pts_types::identifier_to_object($test_object);
         if ($test_object instanceof pts_test_profile) {
             array_push($compare_tests, $test_object->get_identifier(false));
             if (!isset($compare_subsystems[$test_object->get_test_hardware_type()])) {
                 $compare_subsystems[$test_object->get_test_hardware_type()] = 1;
             } else {
                 $compare_subsystems[$test_object->get_test_hardware_type()] += 1;
             }
         }
     }
     if (empty($compare_tests)) {
         $subsystem_under_test = pts_user_io::prompt_text_menu('Sub-System To Test', array('Processor', 'Graphics', 'Disk'));
     } else {
         arsort($compare_subsystems);
         $compare_subsystems = array_keys($compare_subsystems);
         $subsystem_under_test = array_shift($compare_subsystems);
     }
     $system_info = array_merge(phodevi::system_hardware(false), phodevi::system_software(false));
     $to_include = array();
     $to_exclude = array();
     if (isset($system_info[$subsystem_under_test])) {
         $compare_component = $system_info[$subsystem_under_test];
     } else {
         return;
     }
     switch ($subsystem_under_test) {
         case 'Processor':
             self::system_component_to_format($system_info, $to_include, array('OS', 'Compiler', 'Kernel', 'Motherboard'), true);
             break;
         case 'Graphics':
             self::system_component_to_format($system_info, $to_include, array('OS', 'Display Driver', 'OpenGL', 'Processor', 'Kernel', 'Desktop'), true);
             break;
         case 'OS':
             self::system_component_to_format($system_info, $to_include, array('Processor', 'Motherboard', 'Graphics', 'Disk'), true);
             self::system_component_to_format($system_info, $to_exclude, array('OS'));
             break;
         case 'Disk':
             self::system_component_to_format($system_info, $to_include, array('Processor', 'OS', 'Chipset', 'Motherboard', 'Kernel'), true);
             break;
     }
     $payload = array('subsystem_under_test' => $subsystem_under_test, 'component_under_test' => $compare_component, 'include_components' => implode(',', $to_include), 'exclude_components' => implode(',', $to_exclude), 'include_tests' => implode(',', $compare_tests));
     echo PHP_EOL . 'Querying test data from OpenBenchmarking.org...' . PHP_EOL;
     $json = pts_openbenchmarking::make_openbenchmarking_request('auto_generate_comparison', $payload);
     $json = json_decode($json, true);
     if (isset($json['auto_compare']['public_ids']) && isset($json['auto_compare']['count']) && $json['auto_compare']['count'] > 0) {
         echo 'Found ' . $json['auto_compare']['count'] . ' comparable results on OpenBenchmarking.org with a ' . $json['auto_compare']['accuracy'] . '% accuracy.' . PHP_EOL;
         $compare_results = array();
         foreach ($json['auto_compare']['public_ids'] as $public_id) {
             $result_xml = pts_openbenchmarking::clone_openbenchmarking_result($public_id, true);
             if ($result_xml) {
                 $result_file = new pts_result_file($result_xml);
                 $result_objects = $result_file->get_result_objects();
                 foreach ($result_objects as $i => &$result_object) {
                     if (!empty($compare_tests)) {
                         if (!in_array($result_object->test_profile->get_identifier(false), $compare_tests)) {
                             unset($result_objects[$i]);
                         }
                     } else {
                         if ($result_object->test_profile->get_test_hardware_type() != $subsystem_under_test) {
                             unset($result_objects[$i]);
                         }
                     }
                 }
                 if (count($result_objects) == 0) {
                     continue;
                 }
                 $result_file->override_result_objects($result_objects);
                 array_push($compare_results, $result_file);
             }
         }
         if (count($compare_results) > 0) {
             $result_xml = pts_merge::merge_test_results_array($compare_results);
             if (count($compare_results) > 2) {
                 $result_file = new pts_result_file($result_xml);
                 $result_objects = $result_file->get_result_objects();
                 $system_count = $result_file->get_system_count();
                 $result_count = count($result_objects);
                 $result_match_count = array();
                 if ($result_count > 3) {
                     foreach ($result_objects as $i => &$result_object) {
                         $result_match_count[$i] = $result_object->test_result_buffer->get_count();
                     }
                     arsort($result_match_count);
                     $biggest_size = pts_arrays::first_element($result_match_count);
                     if ($biggest_size == $system_count || $biggest_size > 3) {
                         foreach ($result_match_count as $key => $value) {
                             if ($value < 2) {
                                 unset($result_objects[$key]);
                             }
                         }
                     }
                     $result_file->override_result_objects($result_objects);
                     $result_xml = pts_merge::merge_test_results_array(array($result_file));
                 }
             }
//.........这里部分代码省略.........

 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 result_file_to_text(&$result_file, $terminal_width = 80)
 {
     $result_output = null;
     $result_output .= $result_file->get_title() . PHP_EOL;
     $result_output .= $result_file->get_description() . PHP_EOL . PHP_EOL . PHP_EOL;
     $system_identifiers = array();
     $system_hardware = array();
     $system_software = array();
     foreach ($result_file->get_systems() as $system) {
         array_push($system_identifiers, $system->get_identifier());
         array_push($system_hardware, $system->get_hardware());
         array_push($system_software, $system->get_software());
     }
     for ($i = 0; $i < count($system_identifiers); $i++) {
         $result_output .= $system_identifiers[$i] . ': ' . PHP_EOL . PHP_EOL;
         $result_output .= "\t" . $system_hardware[$i] . PHP_EOL . PHP_EOL . "\t" . $system_software[$i] . PHP_EOL . PHP_EOL;
     }
     $longest_identifier_length = strlen(pts_strings::find_longest_string($system_identifiers)) + 2;
     foreach ($result_file->get_result_objects() as $result_object) {
         $result_output .= trim($result_object->test_profile->get_title() . ' ' . $result_object->test_profile->get_app_version() . PHP_EOL . $result_object->get_arguments_description());
         if ($result_object->test_profile->get_result_scale() != null) {
             $result_output .= PHP_EOL . '  ' . $result_object->test_profile->get_result_scale();
         }
         foreach ($result_object->test_result_buffer as &$buffers) {
             $max_value = 0;
             $min_value = pts_arrays::first_element($buffers)->get_result_value();
             foreach ($buffers as &$buffer_item) {
                 if ($buffer_item->get_result_value() > $max_value) {
                     $max_value = $buffer_item->get_result_value();
                 } else {
                     if ($buffer_item->get_result_value() < $min_value) {
                         $min_value = $buffer_item->get_result_value();
                     }
                 }
             }
             $longest_result = strlen($max_value) + 1;
             foreach ($buffers as &$buffer_item) {
                 $val = $buffer_item->get_result_value();
                 if (stripos($val, ',') !== false) {
                     $vals = explode(',', $val);
                     $val = 'MIN: ' . min($vals) . ' / AVG: ' . round(array_sum($vals) / count($vals), 2) . ' / MAX: ' . max($vals);
                 }
                 $result_output .= PHP_EOL . '    ' . $buffer_item->get_result_identifier() . ' ';
                 $result_length_offset = $longest_identifier_length - strlen($buffer_item->get_result_identifier());
                 if ($result_length_offset > 0) {
                     $result_output .= str_repeat('.', $result_length_offset) . ' ';
                 }
                 $result_output .= $val;
                 if (is_numeric($val)) {
                     $result_output .= str_repeat(' ', $longest_result - strlen($val)) . '|';
                     $current_line_length = strlen(substr($result_output, strrpos($result_output, PHP_EOL) + 1)) + 1;
                     $result_output .= str_repeat('=', round($val / $max_value * ($terminal_width - $current_line_length)));
                 }
             }
         }
         $result_output .= PHP_EOL . PHP_EOL;
     }
     return $result_output;
 }

 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;
 }

 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 static function cpu_default_frequency($cpu_core = 0)
 {
     // Find out the processor frequency
     $info = null;
     // First, the ideal way, with modern CPUs using CnQ or EIST and cpuinfo reporting the current
     if (is_file('/sys/devices/system/cpu/cpu' . $cpu_core . '/cpufreq/scaling_max_freq')) {
         $info = pts_file_io::file_get_contents('/sys/devices/system/cpu/cpu' . $cpu_core . '/cpufreq/scaling_max_freq');
         $info = intval($info) / 1000000;
         if ($info > 9) {
             // For some reason on Linux 3.10 the scaling_max_freq is reported as 25GHz...
             $info = null;
         }
     }
     if ($info == null && isset(phodevi::$vfs->cpuinfo)) {
         $cpu_mhz = self::read_cpuinfo_line('cpu MHz');
         $info = $cpu_mhz / 1000;
         if (empty($info)) {
             $cpu_mhz = self::read_cpuinfo_line('clock');
             $info = $cpu_mhz / 1000;
         }
     } else {
         if ($info == null && phodevi::is_bsd()) {
             $info = phodevi_bsd_parser::read_sysctl(array('dev.cpu.0.freq_levels'));
             if ($info != null) {
                 // Popping the top speed off of dev.cpu.0.freq_levels should be the default/highest supported frequency
                 $info = pts_arrays::first_element(explode(' ', str_replace('/', ' ', $info)));
                 if (!is_numeric($info)) {
                     $info = null;
                 }
             }
             if ($info == null) {
                 $info = phodevi_bsd_parser::read_sysctl(array('hw.acpi.cpu.px_global', 'machdep.est.frequency.target', 'hw.cpuspeed'));
             }
             if ($info == null) {
                 // dev.cpu.0.freq seems to be the real/current frequency, affected by power management, etc so only use as last fallback
                 $info = phodevi_bsd_parser::read_sysctl(array('dev.cpu.0.freq'));
             }
             if (is_numeric($info)) {
                 $info = $info / 1000;
             } else {
                 $info = null;
             }
         } else {
             if ($info == null && phodevi::is_windows()) {
                 $info = phodevi_windows_parser::read_cpuz('Processor 1', 'Stock frequency');
                 if ($info != null) {
                     if (($e = strpos($info, ' MHz')) !== false) {
                         $info = substr($info, 0, $e);
                     }
                     $info = $info / 1000;
                 }
             } else {
                 if ($info == null) {
                     $info = phodevi::read_sensor(array('cpu', 'freq'));
                     if ($info > 1000) {
                         // Convert from MHz to GHz
                         $info = $info / 1000;
                     }
                 }
             }
         }
     }
     return pts_math::set_precision($info, 2);
 }

 public function render_graph_dimensions()
 {
     $this->i['graph_max_value'] = $this->maximum_graph_value();
     $longest_identifier = $this->test_result->test_result_buffer->get_longest_identifier();
     // Make room for tick markings, left hand side
     if ($this->i['iveland_view'] == false) {
         if ($this->i['graph_value_type'] == 'NUMERICAL') {
             $this->i['left_start'] += self::text_string_width($this->i['graph_max_value'], self::$c['size']['tick_mark']) + 2;
         }
         if ($this->i['hide_graph_identifiers']) {
             $this->i['graph_top_end'] += $this->i['top_end_bottom'] / 2;
         }
         $this->i['top_start'] += $this->graph_key_height();
     } else {
         if ($this->i['graph_orientation'] == 'HORIZONTAL') {
             if ($this->is_multi_way_comparison && count($this->results) > 1) {
                 $longest_r = $longest_identifier;
                 $longest_r = explode(' - ', $longest_r);
                 $plus_extra = 0;
                 if (count($longest_r) > 1) {
                     $plus_extra = count($longest_r) * $this->i['identifier_size'] * 1.2;
                 }
                 $longest_identifier_width = self::text_string_width($this->i['graph_max_value'], $this->i['identifier_size']) + 60 + $plus_extra;
             } else {
                 $longest_identifier_width = self::text_string_width($longest_identifier, $this->i['identifier_size']) + 8;
             }
             $longest_identifier_max = $this->i['graph_width'] * 0.5 + 0.01;
             $this->i['left_start'] = min($longest_identifier_max, max($longest_identifier_width, 70));
             $this->i['left_end_right'] = 15;
             $this->i['graph_left_end'] = $this->i['graph_width'] - $this->i['left_end_right'];
         } else {
             if ($this->i['graph_value_type'] == 'NUMERICAL') {
                 $this->i['left_start'] += max(20, self::text_string_width($this->i['graph_max_value'] + 0.01, self::$c['size']['tick_mark']) + 2);
             }
         }
         // Pad 8px on top and bottom + title bar + sub-headings
         $this->i['top_heading_height'] = 16 + self::$c['size']['headers'] + count($this->graph_sub_titles) * (self::$c['size']['sub_headers'] + 4);
         if ($this->i['iveland_view']) {
             // Ensure there is enough room to print PTS logo
             $this->i['top_heading_height'] = max($this->i['top_heading_height'], 46);
         }
         $key_height = $this->graph_key_height();
         if ($key_height > $this->i['key_line_height']) {
             // Increase height so key doesn't take up too much room
             $this->i['graph_height'] += $key_height;
             $this->i['graph_top_end'] += $key_height;
         }
         $this->i['top_start'] = $this->i['top_heading_height'] + $key_height + 16;
         // + spacing before graph starts
         $bottom_heading = 14;
         if ($this->i['graph_orientation'] == 'HORIZONTAL') {
             if ($this->is_multi_way_comparison && count($this->results) > 1) {
                 $longest_string = explode(' - ', $longest_identifier);
                 $longest_string = pts_strings::find_longest_string($longest_string);
                 $rotated_text = round(self::text_string_width($longest_string, $this->i['identifier_size']) * 0.96);
                 $per_identifier_height = max(14 + 22 * count($this->results), $rotated_text);
             } else {
                 if (count($this->results) > 3) {
                     $per_identifier_height = count($this->results) * 18;
                 } else {
                     // If there's too much to plot, reduce the size so each graph doesn't take too much room
                     $id_count = count(pts_arrays::first_element($this->results));
                     if ($id_count < 10) {
                         $per_identifier_height = 46;
                     } else {
                         if ($id_count < 20) {
                             $per_identifier_height = 36;
                         } else {
                             if ($id_count <= 38) {
                                 $this->i['compact_result_view'] = true;
                                 $per_identifier_height = 30;
                             } else {
                                 $this->i['compact_result_view'] = true;
                                 $per_identifier_height = 26;
                             }
                         }
                     }
                 }
             }
             $num_identifiers = $this->test_result->test_result_buffer->get_count();
             $this->i['graph_top_end'] = $this->i['top_start'] + $num_identifiers * $per_identifier_height;
             // $this->i['top_end_bottom']
             $this->i['graph_height'] = $this->i['graph_top_end'] + 25 + $bottom_heading;
         } else {
             $this->i['graph_height'] += $bottom_heading + 4;
         }
         if (!empty($this->i['notes'])) {
             $this->i['graph_height'] += $this->note_display_height();
         }
     }
 }

 public function read_sensor()
 {
     // Graphics processor real/current frequency
     $show_memory = false;
     $core_freq = 0;
     $mem_freq = 0;
     if (phodevi::is_nvidia_graphics()) {
         $nv_freq = phodevi_parser::read_nvidia_extension('GPUCurrentClockFreqs');
         $nv_freq = pts_strings::comma_explode($nv_freq);
         $core_freq = isset($nv_freq[0]) ? $nv_freq[0] : 0;
         $mem_freq = isset($nv_freq[1]) ? $nv_freq[1] : 0;
     } else {
         if (phodevi::is_ati_graphics() && phodevi::is_linux()) {
             $od_clocks = phodevi_linux_parser::read_ati_overdrive('CurrentClocks');
             if (is_array($od_clocks) && count($od_clocks) >= 2) {
                 $core_freq = array_shift($od_clocks);
                 $mem_freq = array_pop($od_clocks);
             }
         } else {
             if (phodevi::is_linux()) {
                 if (isset(phodevi::$vfs->radeon_pm_info)) {
                     // radeon_pm_info should be present with Linux 2.6.34+
                     foreach (pts_strings::trim_explode("\n", phodevi::$vfs->radeon_pm_info) as $pm_line) {
                         $pm_line = pts_strings::colon_explode($pm_line);
                         if (isset($pm_line[1])) {
                             list($descriptor, $value) = $pm_line;
                         } else {
                             continue;
                         }
                         switch ($descriptor) {
                             case 'current engine clock':
                                 $core_freq = pts_arrays::first_element(explode(' ', $value)) / 1000;
                                 break;
                             case 'current memory clock':
                                 $mem_freq = pts_arrays::first_element(explode(' ', $value)) / 1000;
                                 break;
                         }
                     }
                     if ($core_freq == null && ($x = strpos(phodevi::$vfs->radeon_pm_info, 'sclk: '))) {
                         $x = substr(phodevi::$vfs->radeon_pm_info, $x + strlen('sclk: '));
                         $x = substr($x, 0, strpos($x, ' '));
                         if (is_numeric($x)) {
                             if ($x > 1000) {
                                 $x = $x / 100;
                             }
                             $core_freq = $x;
                         }
                     }
                     if ($mem_freq == null && ($x = strpos(phodevi::$vfs->radeon_pm_info, 'mclk: '))) {
                         $x = substr(phodevi::$vfs->radeon_pm_info, $x + strlen('mclk: '));
                         $x = substr($x, 0, strpos($x, ' '));
                         if (is_numeric($x)) {
                             if ($x > 1000) {
                                 $x = $x / 100;
                             }
                             $mem_freq = $x;
                         }
                     }
                 } else {
                     if (is_file('/sys/class/drm/card0/gt_cur_freq_mhz')) {
                         $gt_cur_freq_mhz = pts_file_io::file_get_contents('/sys/class/drm/card0/gt_cur_freq_mhz');
                         if ($gt_cur_freq_mhz > 2) {
                             $core_freq = $gt_cur_freq_mhz;
                         }
                     } else {
                         if (is_file('/sys/class/drm/card0/device/performance_level')) {
                             $performance_level = pts_file_io::file_get_contents('/sys/class/drm/card0/device/performance_level');
                             $performance_level = explode(' ', $performance_level);
                             $core_string = array_search('core', $performance_level);
                             if ($core_string !== false && isset($performance_level[$core_string + 1])) {
                                 $core_string = str_ireplace('MHz', null, $performance_level[$core_string + 1]);
                                 if (is_numeric($core_string) && $core_string > $core_freq) {
                                     $core_freq = $core_string;
                                 }
                             }
                             $mem_string = array_search('memory', $performance_level);
                             if ($mem_string !== false && isset($performance_level[$mem_string + 1])) {
                                 $mem_string = str_ireplace('MHz', null, $performance_level[$mem_string + 1]);
                                 if (is_numeric($mem_string) && $mem_string > $mem_freq) {
                                     $mem_freq = $mem_string;
                                 }
                             }
                         } else {
                             if (isset(phodevi::$vfs->i915_cur_delayinfo)) {
                                 $i915_cur_delayinfo = phodevi::$vfs->i915_cur_delayinfo;
                                 $cagf = strpos($i915_cur_delayinfo, 'CAGF: ');
                                 if ($cagf !== false) {
                                     $cagf_mhz = substr($i915_cur_delayinfo, $cagf + 6);
                                     $cagf_mhz = substr($cagf_mhz, 0, strpos($cagf_mhz, 'MHz'));
                                     if (is_numeric($cagf_mhz)) {
                                         $core_freq = $cagf_mhz;
                                     }
                                 }
                             }
                         }
                     }
                 }
             }
         }
     }
//.........这里部分代码省略.........

//.........这里部分代码省略.........
                                     }
                                     if (is_numeric($core_string)) {
                                         $core_freq = $core_string;
                                     }
                                 }
                                 $mem_string = array_search('memory', $performance_level);
                                 if ($mem_string !== false && isset($performance_level[$mem_string + 1])) {
                                     $mem_string = str_ireplace('MHz', null, $performance_level[$mem_string + 1]);
                                     if (strpos($mem_string, '-') !== false) {
                                         // to work around a range of values, e.g.
                                         // 0a: core 405-1032 MHz memory 1620 MHz AC DC *
                                         $mem_string = max(explode('-', $mem_string));
                                     }
                                     if (is_numeric($mem_string)) {
                                         $mem_freq = $mem_string;
                                     }
                                 }
                             }
                         }
                         if ($display_driver != null) {
                             break;
                         }
                     case 'radeon':
                         if (isset(phodevi::$vfs->radeon_pm_info)) {
                             // radeon_pm_info should be present with Linux 2.6.34+ but was changed with Linux 3.11 Radeon DPM
                             if (stripos(phodevi::$vfs->radeon_pm_info, 'default')) {
                                 foreach (pts_strings::trim_explode("\n", phodevi::$vfs->radeon_pm_info) as $pm_line) {
                                     if ($pm_line == null) {
                                         continue;
                                     }
                                     list($descriptor, $value) = pts_strings::colon_explode($pm_line);
                                     switch ($descriptor) {
                                         case 'default engine clock':
                                             $core_freq = pts_arrays::first_element(explode(' ', $value)) / 1000;
                                             break;
                                         case 'default memory clock':
                                             $mem_freq = pts_arrays::first_element(explode(' ', $value)) / 1000;
                                             break;
                                     }
                                 }
                             }
                             if ($core_freq == 0 && ($x = stripos(phodevi::$vfs->radeon_pm_info, 'sclk: ')) != false) {
                                 $x = substr(phodevi::$vfs->radeon_pm_info, $x + strlen('sclk: '));
                                 $x = substr($x, 0, strpos($x, ' '));
                                 if (is_numeric($x) && $x > 100) {
                                     if ($x > 10000) {
                                         $x = $x / 100;
                                     }
                                     $core_freq = $x;
                                 }
                                 if (($x = stripos(phodevi::$vfs->radeon_pm_info, 'mclk: ')) != false) {
                                     $x = substr(phodevi::$vfs->radeon_pm_info, $x + strlen('mclk: '));
                                     $x = substr($x, 0, strpos($x, ' '));
                                     if (is_numeric($x) && $x > 100) {
                                         if ($x > 10000) {
                                             $x = $x / 100;
                                         }
                                         $mem_freq = $x;
                                     }
                                 }
                             }
                         }
                         if ($core_freq == null) {
                             // Attempt to read the LAST power level reported to dmesg, this is the current way for Radeon DPM on Linux 3.11+
                             $dmesg_parse = isset(phodevi::$vfs->dmesg) ? phodevi::$vfs->dmesg : null;
                             if ($x = strrpos($dmesg_parse, ' sclk:')) {

 public static function memory_string()
 {
     $mem_string = null;
     $mem_prefix = null;
     $mem_size = false;
     $mem_speed = false;
     $mem_type = false;
     $mem_manufacturer = false;
     $mem_part = false;
     if (phodevi::is_macosx()) {
         $mem_size = phodevi_osx_parser::read_osx_system_profiler('SPMemoryDataType', 'Size', true, array('Empty'));
         $mem_speed = phodevi_osx_parser::read_osx_system_profiler('SPMemoryDataType', 'Speed');
         $mem_type = phodevi_osx_parser::read_osx_system_profiler('SPMemoryDataType', 'Type');
     } else {
         if (phodevi::is_solaris()) {
             $mem_size = phodevi_solaris_parser::read_sun_ddu_dmi_info('MemoryDevice*,InstalledSize');
             $mem_speed = phodevi_solaris_parser::read_sun_ddu_dmi_info('MemoryDevice*,Speed');
             $mem_type = phodevi_solaris_parser::read_sun_ddu_dmi_info('MemoryDevice*,MemoryDeviceType');
             if (is_array($mem_speed) && count($mem_speed) > 0) {
                 $mem_speed = array_shift($mem_speed);
             }
             $mem_speed = str_replace('MHZ', 'MHz', $mem_speed);
         } else {
             if (phodevi::is_windows()) {
                 $mem_size = phodevi_windows_parser::read_cpuz('DIMM #', 'Size', true);
                 foreach ($mem_size as $key => &$individual_size) {
                     $individual_size = pts_arrays::first_element(explode(' ', $individual_size));
                     if (!is_numeric($individual_size)) {
                         unset($mem_size[$key]);
                     }
                 }
                 $mem_type = phodevi_windows_parser::read_cpuz('Memory Type', null);
                 $mem_speed = intval(phodevi_windows_parser::read_cpuz('Memory Frequency', null)) . 'MHz';
             } else {
                 if (phodevi::is_linux()) {
                     $mem_size = phodevi_linux_parser::read_dmidecode('memory', 'Memory Device', 'Size', false, array('Not Installed', 'No Module Installed', 'Undefined'));
                     $mem_speed = phodevi_linux_parser::read_dmidecode('memory', 'Memory Device', 'Speed', true, array('Unknown', 'Undefined'));
                     $mem_type = phodevi_linux_parser::read_dmidecode('memory', 'Memory Device', 'Type', true, array('Unknown', 'Other', 'Flash', 'Undefined'));
                     $mem_manufacturer = phodevi_linux_parser::read_dmidecode('memory', 'Memory Device', 'Manufacturer', true, array('Unknown', 'Undefined'));
                     $mem_part = phodevi_linux_parser::read_dmidecode('memory', 'Memory Device', 'Part Number', true, array('Unknown', 'Undefined'));
                 }
             }
         }
     }
     if (is_array($mem_type)) {
         $mem_type = array_pop($mem_type);
     }
     if ($mem_size != false && (!is_array($mem_size) || count($mem_size) != 0)) {
         for ($i = 0; $i < count($mem_size); $i++) {
             switch (substr($mem_size[$i], -1)) {
                 case 'K':
                     // looks like sometimes Solaris now reports flash chip as memory. its string ends with K
                     unset($mem_size[$i]);
                     unset($mem_speed[$i]);
                     unset($mem_type[$i]);
                     break;
                 case 'M':
                     // report megabytes as MB, just not M, as on Solaris
                     $mem_size[$i] .= 'B';
                     break;
                 case 'B':
                     if (strtolower(substr($mem_size[$i], -2, 1)) == 'k') {
                         // some hardware on Linux via dmidecode reports flash chips
                         unset($mem_size[$i]);
                         //unset($mem_speed[$i]);
                         //unset($mem_type[$i]);
                     }
                     break;
             }
         }
         foreach ($mem_size as $i => $mem_stick) {
             if (!is_numeric(substr($mem_stick, 0, 3)) && stripos($mem_stick, 'GB') == false) {
                 // If the memory size isn't at least three digits (basically 128MB+), chances are something is wrong, i.e. reporting flash chip from dmidecode, so get rid of it.
                 unset($mem_size[$i]);
             }
         }
         $mem_count = count($mem_size);
         if (!empty($mem_type)) {
             if (($cut = strpos($mem_type, ' ')) > 0) {
                 $mem_type = substr($mem_type, 0, $cut);
             }
             if (!in_array($mem_type, array('Other')) && (pts_strings::keep_in_string($mem_type, pts_strings::CHAR_NUMERIC | pts_strings::CHAR_LETTER) == $mem_type || phodevi::is_windows())) {
                 $mem_prefix = $mem_type;
             }
         } else {
             $mem_prefix = null;
         }
         if (!empty($mem_speed)) {
             if (($cut = strpos($mem_speed, ' (')) > 0) {
                 $mem_speed = substr($mem_speed, 0, $cut);
             }
             if (!empty($mem_prefix)) {
                 $mem_prefix .= '-';
             }
             $mem_prefix .= str_replace(' ', null, $mem_speed);
         }
         // TODO: Allow a combination of both functions below, so like 2 x 2GB + 3 x 1GB DDR2-800
         if ($mem_count > 1 && count(array_unique($mem_size)) > 1) {
             $mem_string = implode(' + ', $mem_size) . ' ' . $mem_prefix;
         } else {
//.........这里部分代码省略.........

 public static function mem_usage($TYPE = 'TOTAL', $READ = 'USED')
 {
     // Reads system memory usage
     $mem_usage = -1;
     if (pts_client::executable_in_path('free') != false) {
         $mem = explode("\n", shell_exec('free -t -m 2>&1'));
         $grab_line = null;
         $buffers_and_cache = 0;
         for ($i = 0; $i < count($mem); $i++) {
             $line_parts = pts_strings::colon_explode($mem[$i]);
             if (count($line_parts) == 2) {
                 $line_type = $line_parts[0];
                 if ($TYPE == 'MEMORY' && $line_type == 'Mem') {
                     $grab_line = $line_parts[1];
                 } else {
                     if ($TYPE == 'SWAP' && $line_type == 'Swap') {
                         $grab_line = $line_parts[1];
                     } else {
                         if ($TYPE == 'TOTAL' && $line_type == 'Total') {
                             $grab_line = $line_parts[1];
                         } else {
                             if ($line_type == '-/+ buffers/cache' && $TYPE != 'SWAP') {
                                 $buffers_and_cache = pts_arrays::first_element(explode(' ', pts_strings::trim_spaces($line_parts[1])));
                             }
                         }
                     }
                 }
             }
         }
         if (!empty($grab_line)) {
             $grab_line = pts_strings::trim_spaces($grab_line);
             $mem_parts = explode(' ', $grab_line);
             if ($READ == 'USED') {
                 if (count($mem_parts) >= 2 && is_numeric($mem_parts[1])) {
                     $mem_usage = $mem_parts[1] - $buffers_and_cache;
                 }
             } else {
                 if ($READ == 'TOTAL') {
                     if (count($mem_parts) >= 1 && is_numeric($mem_parts[0])) {
                         $mem_usage = $mem_parts[0];
                     }
                 } else {
                     if ($READ == 'FREE') {
                         if (count($mem_parts) >= 3 && is_numeric($mem_parts[2])) {
                             $mem_usage = $mem_parts[2];
                         }
                     }
                 }
             }
         }
     } else {
         if (pts_client::executable_in_path('vm_stat') != false) {
             $vmstats = explode("\n", shell_exec('vm_stat 2>&1'));
             $grab_line = null;
             // buffers_and_cache
             foreach ($vmstats as $vmstat_line) {
                 $line_parts = pts_strings::colon_explode($vmstat_line);
                 if (self::$page_size == -1) {
                     strtok($vmstat_line, ':');
                     $tok = strtok(' ');
                     while (self::$page_size == -1) {
                         if (is_numeric($tok)) {
                             self::$page_size = $tok;
                         } else {
                             $tok = strtok(' ');
                         }
                     }
                     continue;
                 }
                 //$line_parts[1] = pts_strings::trim_spaces($line_parts[1]);
                 $line_type = strtok($vmstat_line, ':');
                 $line_value = strtok(' .');
                 if ($TYPE == 'MEMORY') {
                     if ($line_type == 'Pages active' && $READ == 'USED') {
                         $mem_usage = $line_value / (1048576 / self::$page_size);
                         break;
                     }
                     if ($line_type == 'Pages free' && $READ == 'FREE') {
                         $mem_usage = $line_value / (1048576 / self::$page_size);
                         break;
                     }
                 }
             }
             $mem_usage = pts_math::set_precision($mem_usage);
         }
     }
     return $mem_usage;
 }