From 43a97878ce14b72f0981164f87f2e35e14151312 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sun, 7 Apr 2024 11:22:09 +0200 Subject: Adding upstream version 110.0.1. Signed-off-by: Daniel Baumann --- testing/mozbase/mozpower/mozpower/__init__.py | 24 + .../mozpower/mozpower/intel_power_gadget.py | 910 +++++++++++++++++++++ testing/mozbase/mozpower/mozpower/macintelpower.py | 92 +++ testing/mozbase/mozpower/mozpower/mozpower.py | 376 +++++++++ testing/mozbase/mozpower/mozpower/mozpowerutils.py | 58 ++ testing/mozbase/mozpower/mozpower/powerbase.py | 122 +++ testing/mozbase/mozpower/setup.cfg | 2 + testing/mozbase/mozpower/setup.py | 34 + testing/mozbase/mozpower/tests/conftest.py | 103 +++ testing/mozbase/mozpower/tests/files/emptyfile.txt | 0 .../raptor-tp6-amazon-firefox_powerlog_1_.txt | 30 + .../raptor-tp6-amazon-firefox_powerlog_2_.txt | 30 + .../raptor-tp6-amazon-firefox_powerlog_3_.txt | 30 + .../mozpower/tests/files/valueerrorfile.txt | 30 + testing/mozbase/mozpower/tests/manifest.ini | 6 + .../mozpower/tests/test_intelpowergadget.py | 348 ++++++++ .../mozbase/mozpower/tests/test_macintelpower.py | 76 ++ testing/mozbase/mozpower/tests/test_mozpower.py | 255 ++++++ testing/mozbase/mozpower/tests/test_powerbase.py | 91 +++ 19 files changed, 2617 insertions(+) create mode 100644 testing/mozbase/mozpower/mozpower/__init__.py create mode 100644 testing/mozbase/mozpower/mozpower/intel_power_gadget.py create mode 100644 testing/mozbase/mozpower/mozpower/macintelpower.py create mode 100644 testing/mozbase/mozpower/mozpower/mozpower.py create mode 100644 testing/mozbase/mozpower/mozpower/mozpowerutils.py create mode 100644 testing/mozbase/mozpower/mozpower/powerbase.py create mode 100644 testing/mozbase/mozpower/setup.cfg create mode 100644 testing/mozbase/mozpower/setup.py create mode 100644 testing/mozbase/mozpower/tests/conftest.py create mode 100644 testing/mozbase/mozpower/tests/files/emptyfile.txt create mode 100644 testing/mozbase/mozpower/tests/files/raptor-tp6-amazon-firefox_powerlog_1_.txt create mode 100644 testing/mozbase/mozpower/tests/files/raptor-tp6-amazon-firefox_powerlog_2_.txt create mode 100644 testing/mozbase/mozpower/tests/files/raptor-tp6-amazon-firefox_powerlog_3_.txt create mode 100644 testing/mozbase/mozpower/tests/files/valueerrorfile.txt create mode 100644 testing/mozbase/mozpower/tests/manifest.ini create mode 100644 testing/mozbase/mozpower/tests/test_intelpowergadget.py create mode 100644 testing/mozbase/mozpower/tests/test_macintelpower.py create mode 100644 testing/mozbase/mozpower/tests/test_mozpower.py create mode 100644 testing/mozbase/mozpower/tests/test_powerbase.py (limited to 'testing/mozbase/mozpower') diff --git a/testing/mozbase/mozpower/mozpower/__init__.py b/testing/mozbase/mozpower/mozpower/__init__.py new file mode 100644 index 0000000000..6ac10d076b --- /dev/null +++ b/testing/mozbase/mozpower/mozpower/__init__.py @@ -0,0 +1,24 @@ +# This Source Code Form is subject to the terms of the Mozilla Public +# License, v. 2.0. If a copy of the MPL was not distributed with this file, +# You can obtain one at http://mozilla.org/MPL/2.0/. + +from .intel_power_gadget import ( + IPGEmptyFileError, + IPGMissingOutputFileError, + IPGTimeoutError, + IPGUnknownValueTypeError, +) +from .mozpower import MissingProcessorInfoError, MozPower, OsCpuComboMissingError +from .powerbase import IPGExecutableMissingError, PlatformUnsupportedError + +__all__ = [ + "IPGEmptyFileError", + "IPGExecutableMissingError", + "IPGMissingOutputFileError", + "IPGTimeoutError", + "IPGUnknownValueTypeError", + "MissingProcessorInfoError", + "MozPower", + "OsCpuComboMissingError", + "PlatformUnsupportedError", +] diff --git a/testing/mozbase/mozpower/mozpower/intel_power_gadget.py b/testing/mozbase/mozpower/mozpower/intel_power_gadget.py new file mode 100644 index 0000000000..0382084d8f --- /dev/null +++ b/testing/mozbase/mozpower/mozpower/intel_power_gadget.py @@ -0,0 +1,910 @@ +# This Source Code Form is subject to the terms of the Mozilla Public +# License, v. 2.0. If a copy of the MPL was not distributed with this +# file, You can obtain one at http://mozilla.org/MPL/2.0/. +import csv +import os +import re +import subprocess +import threading +import time + +from .mozpowerutils import get_logger + + +class IPGTimeoutError(Exception): + """IPGTimeoutError is raised when we cannot stop Intel Power + Gadget from running. One possble cause of this is not calling + `stop_ipg` through a `finalize_power_measurements` call. The + other possiblity is that IPG failed to stop. + """ + + pass + + +class IPGMissingOutputFileError(Exception): + """IPGMissingOutputFile is raised when a file path is given + to _clean_ipg_file but it does not exist or cannot be found + at the expected location. + """ + + pass + + +class IPGEmptyFileError(Exception): + """IPGEmptyFileError is raised when a file path is given + to _clean_ipg_file and it exists but it is empty (contains + no results to clean). + """ + + pass + + +class IPGUnknownValueTypeError(Exception): + """IPGUnknownValueTypeError is raised when a value within a + given results file (that was cleaned) cannot be converted to + its column's expected data type. + """ + + pass + + +class IntelPowerGadget(object): + """IntelPowerGadget provides methods for using Intel Power Gadget + to measure power consumption. + + :: + + from mozpower.intel_power_gadget import IntelPowerGadget + + # On Mac, the ipg_exe_path should point to '/Applications/Intel Power Gadget/PowerLog' + ipg = IntelPowerGadget(ipg_exe_path, ipg_measure_duration=600, sampling_rate=500) + + ipg.start_ipg() + + # Run tests... + + ipg.stop_ipg() + + # Now process results with IPGResultsHandler by passing it + # ipg.output_files, ipg.output_file_ext, ipg.ipg_measure_duration, + # and ipg.sampling_rate. + """ + + def __init__( + self, + exe_file_path, + ipg_measure_duration=10, + sampling_rate=1000, + output_file_ext=".txt", + file_counter=1, + output_file_path="powerlog", + logger_name="mozpower", + ): + """Initializes the IntelPowerGadget object. + + :param str exe_file_path: path to Intel Power Gadget 'PowerLog' executable. + :param int ipg_measure_duration: duration to run IPG for in seconds. + This does not dictate when the tools shuts down. It only stops when stop_ipg + is called in case the test runs for a non-deterministic amount of time. The + IPG executable requires a duration to be supplied. The machinery in place is + to ensure that IPG keeps recording as long as the experiment runs, so + multiple files may result, which is handled in + IPGResultsHandler._combine_cumulative_rows. Defaults to 10s. + :param int sampling_rate: sampling rate of measurements in milliseconds. + Defaults to 1000ms. + :param output_file_ext: file extension of data being output. Defaults to '.txt'. + :param int file_counter: dictates the start of the file numbering (used + when test time exceeds duration value). Defaults to 0. + :param str output_file_path: path to the output location combined + with the output file prefix. Defaults to current working directory using the + prefix 'powerlog'. + :param str logger_name: logging logger name. Defaults to 'mozpower'. + """ + self._logger = get_logger(logger_name) + + # Output-specific settings + self._file_counter = file_counter + self._output_files = [] + self._output_file_path = output_file_path + self._output_file_ext = output_file_ext + self._output_dir_path, self._output_file_prefix = os.path.split( + self._output_file_path + ) + + # IPG-specific settings + self._ipg_measure_duration = ipg_measure_duration # in seconds + self._sampling_rate = sampling_rate # in milliseconds + self._exe_file_path = exe_file_path + + # Setup thread for measurement gathering + self._thread = threading.Thread( + target=self.run, args=(exe_file_path, ipg_measure_duration) + ) + self._thread.daemon = True + self._running = False + + @property + def output_files(self): + """Returns the list of files produced from running IPG. + + :returns: list + """ + return self._output_files + + @property + def output_file_ext(self): + """Returns the extension of the files produced by IPG. + + :returns: str + """ + return self._output_file_ext + + @property + def output_file_prefix(self): + """Returns the prefix of the files produces by IPG. + + :returns: str + """ + return self._output_file_prefix + + @property + def output_dir_path(self): + """Returns the output directory of the files produced by IPG. + + :returns: str + """ + return self._output_dir_path + + @property + def sampling_rate(self): + """Returns the specified sampling rate. + + :returns: int + """ + return self._sampling_rate + + @property + def ipg_measure_duration(self): + """Returns the IPG measurement duration (see __init__ for description + of what this value does). + + :returns: int + """ + return self._ipg_measure_duration + + def start_ipg(self): + """Starts the thread which runs IPG to start gathering measurements.""" + self._logger.info("Starting IPG thread") + self._stop = False + self._thread.start() + + def stop_ipg(self, wait_interval=10, timeout=200): + """Stops the thread which runs IPG and waits for it to finish it's work. + + :param int wait_interval: interval time (in seconds) at which to check if + IPG is finished. + :param int timeout: time to wait until _wait_for_ipg hits a time out, + in seconds. + """ + self._logger.info("Stopping IPG thread") + self._stop = True + self._wait_for_ipg(wait_interval=wait_interval, timeout=timeout) + + def _wait_for_ipg(self, wait_interval=10, timeout=200): + """Waits for IPG to finish it's final dataset. + + :param int wait_interval: interval time (in seconds) at which to check if + IPG is finished. + :param int timeout: time to wait until this method hits a time out, + in seconds. + :raises: * IPGTimeoutError + """ + timeout_stime = time.time() + while self._running and (time.time() - timeout_stime) < timeout: + self._logger.info( + "Waiting %s sec for Intel Power Gadget to stop" % wait_interval + ) + time.sleep(wait_interval) + if self._running: + raise IPGTimeoutError("Timed out waiting for IPG to stop") + + def _get_output_file_path(self): + """Returns the next output file name to be used. Starts at 1 and increases + at each successive call. Used when the test duration exceeds the specified + duration through ipg_meaure_duration. + + :returns: str + """ + self._output_file_path = os.path.join( + self._output_dir_path, + "%s_%s_%s" + % (self._output_file_prefix, self._file_counter, self._output_file_ext), + ) + self._file_counter += 1 + self._logger.info( + "Creating new file for IPG data measurements: %s" % self._output_file_path + ) + return self._output_file_path + + def run(self, exe_file_path, ipg_measure_duration): + """Runs the IPG measurement gatherer. While stop has not been set to True, + it continuously gathers measurements into separate files that are merged + by IPGResultsHandler once the output_files are passed to it. + + :param str exe_file_path: file path of where to find the IPG executable. + :param int ipg_measure_duration: time to gather measurements for. + """ + self._logger.info("Starting to gather IPG measurements in thread") + self._running = True + + while not self._stop: + outname = self._get_output_file_path() + self._output_files.append(outname) + + try: + subprocess.check_output( + [ + exe_file_path, + "-duration", + str(ipg_measure_duration), + "-resolution", + str(self._sampling_rate), + "-file", + outname, + ], + stderr=subprocess.STDOUT, + ) + except subprocess.CalledProcessError as e: + error_log = str(e) + if e.output: + error_log = e.output.decode() + self._logger.critical( + "Error while running Intel Power Gadget: %s" % error_log + ) + + self._running = False + + +class IPGResultsHandler(object): + """IPGResultsHandler provides methods for cleaning and formatting + the files that were created by IntelPowerGadget. + + :: + + from mozpower.intel_power_gadget import IntelPowerGadget, IPGResultsHandler + + ipg = IntelPowerGadget(ipg_exe_path, ipg_measure_duration=600, sampling_rate=500) + + # Run tests - call start_ipg and stop_ipg... + + ipg_rh = IPGResultsHandler( + ipg.output_files, + ipg.output_dir_path, + ipg_measure_duration=ipg.ipg_measure_duration, + sampling_rate=ipg.sampling_rate + ) + + cleaned_data = ipg_rh.clean_ipg_data() + # you can also get the data from results after calling clean_ipg_data + cleaned_data = ipg_rh.results + + perfherder_data = ipg_rh.format_ipg_data_to_partial_perfherder( + experiment_duration, + test_name + ) + # you can also get the perfherder data from summarized_results + # after calling format_ipg_data_to_partial_perfherder + perfherder_data = ipg_rh.summarized_results + """ + + def __init__( + self, + output_files, + output_dir_path, + ipg_measure_duration=10, + sampling_rate=1000, + logger_name="mozpower", + ): + """Initializes the IPGResultsHandler object. + + :param list output_files: files output by IntelPowerGadget containing + the IPG data. + :param str output_dir_path: location to store cleaned files and merged data. + :param int ipg_measure_duration: length of time that each IPG measurement lasted + in seconds (see IntelPowerGadget for more information on this argument). + Defaults to 10s. + :param int sampling_rate: sampling rate of the measurements in milliseconds. + Defaults to 1000ms. + :param str logger_name: logging logger name. Defaults to 'mozpower'. + """ + self._logger = get_logger(logger_name) + self._results = {} + self._summarized_results = {} + self._cleaned_files = [] + self._csv_header = None + self._merged_output_path = None + self._output_file_prefix = None + self._output_file_ext = None + + self._sampling_rate = sampling_rate + self._ipg_measure_duration = ipg_measure_duration + self._output_files = output_files + self._output_dir_path = output_dir_path + + if self._output_files: + # Gather the output file extension, and prefix + # for the cleaned files, and the merged file. + single_file = self._output_files[0] + _, file = os.path.split(single_file) + self._output_file_ext = "." + file.split(".")[-1] + + # This prefix detection depends on the path names created + # by _get_output_file_path. + integer_re = re.compile(r"""(.*)_[\d+]_%s""" % self._output_file_ext) + match = integer_re.match(file) + if match: + self._output_file_prefix = match.group(1) + else: + self._output_file_prefix = file.split("_")[0] + self._logger.warning( + "Cannot find output file prefix from output file name %s" + "using the following prefix: %s" % (file, self._output_file_prefix) + ) + + @property + def results(self): + """Returns the cleaned IPG data in the form of a dict. + Each key is a measurement name with the values being the list + of measurements. All value lists are sorted in increasing time. + + :returns: dict + """ + return self._results + + @property + def summarized_results(self): + """Returns IPG data in the form of a dict that is formatted + into a perfherder data blob. + + :returns: dict + """ + return self._summarized_results + + @property + def cleaned_files(self): + """Returns a list of cleaned IPG data files that were output + after running clean_ipg_data. + + :returns: list + """ + return self._cleaned_files + + @property + def merged_output_path(self): + """Returns the path to the cleaned, and merged output file. + + :returns: str + """ + return self._merged_output_path + + def _clean_ipg_file(self, file): + """Cleans an individual IPG file and writes out a cleaned file. + + An uncleaned file looks like this (this contains a partial + sample of the time series data): + ``` + "System Time","RDTSC","Elapsed Time (sec)" + "12:11:05:769","61075218263548"," 2.002" + "12:11:06:774","61077822279584"," 3.007" + "12:11:07:778","61080424421708"," 4.011" + "12:11:08:781","61083023535972"," 5.013" + "12:11:09:784","61085623402302"," 6.016" + + "Total Elapsed Time (sec) = 10.029232" + "Measured RDTSC Frequency (GHz) = 2.592" + + "Cumulative Processor Energy_0 (Joules) = 142.337524" + "Cumulative Processor Energy_0 (mWh) = 39.538201" + "Average Processor Power_0 (Watt) = 14.192265" + + "Cumulative IA Energy_0 (Joules) = 121.888000" + "Cumulative IA Energy_0 (mWh) = 33.857778" + "Average IA Power_0 (Watt) = 12.153273" + + "Cumulative DRAM Energy_0 (Joules) = 7.453308" + "Cumulative DRAM Energy_0 (mWh) = 2.070363" + "Average DRAM Power_0 (Watt) = 0.743158" + + "Cumulative GT Energy_0 (Joules) = 0.079834" + "Cumulative GT Energy_0 (mWh) = 0.022176" + "Average GT Power_0 (Watt) = 0.007960" + ``` + + While a cleaned file looks like: + ``` + System Time,RDTSC,Elapsed Time (sec) + 12:11:05:769,61075218263548, 2.002 + 12:11:06:774,61077822279584, 3.007 + 12:11:07:778,61080424421708, 4.011 + 12:11:08:781,61083023535972, 5.013 + 12:11:09:784,61085623402302, 6.016 + ``` + + The first portion of the file before the '"Total Elapsed Time' entry is + considered as the time series which is captured as a dict in the returned + results. + + All the text starting from '"Total Elapsed Time' is removed from the file and + is considered as a summary of the experiment (which is returned). This + portion is ignored in any other processing done by IPGResultsHandler, + and is not saved, unlike the returned results value. + + Note that the new lines are removed from the summary that is returned + (as well as the results). + + :param str file: file to clean. + :returns: a tuple of (dict, list, str) for + (results, summary, clean_output_path) + see method comments above for information on what + this output contains. + :raises: * IPGMissingOutputFileError + * IPGEmptyFileError + """ + self._logger.info("Cleaning IPG data file %s" % file) + + txt = "" + if os.path.exists(file): + with open(file, "r") as f: + txt = f.read() + else: + # This should never happen, so prevent IPGResultsHandler + # from continuing to clean files if it does occur. + raise IPGMissingOutputFileError( + "The following file does not exist so it cannot be cleaned: %s " % file + ) + + if txt == "": + raise IPGEmptyFileError( + "The following file is empty so it cannot be cleaned: %s" % file + ) + + # Split the time series data from the summary + tseries, summary = re.split('"Total Elapsed Time', txt) + + # Clean the summary + summary = '"Total Elapsed Time' + summary + summary = [ + line for line in re.split(r"""\n""", summary.replace("\r", "")) if line + ] + + # Clean the time series data, store the clean rows to write out later, + # and format the rows into a dict entry for each measure. + results = {} + clean_rows = [] + csv_header = None + for c, row in enumerate( + csv.reader(tseries.split("\n"), quotechar=str('"'), delimiter=str(",")) + ): + if not row: + continue + + # Make sure we don't have any bad line endings + # contaminating the cleaned rows. + fmt_row = [ + val.replace("\n", "") + .replace("\t", "") + .replace("\r", "") + .replace("\\n", "") + .strip() + for val in row + ] + + if not fmt_row or not any(fmt_row): + continue + + clean_rows.append(fmt_row) + if c == 0: + csv_header = fmt_row + for col in fmt_row: + results[col] = [] + continue + for i, col in enumerate(fmt_row): + results[csv_header[i]].append(col) + + # Write out the cleaned data and check to make sure + # the csv header hasn't changed mid-experiment + _, fname = os.path.split(file) + clean_output_path = os.path.join( + self._output_dir_path, + fname.replace( + self._output_file_ext, + "_clean.%s" % self._output_file_ext.replace(".", ""), + ), + ) + self._logger.info("Writing cleaned IPG results to %s" % clean_output_path) + try: + with open(clean_output_path, "w") as csvfile: + writer = csv.writer(csvfile) + for count, row in enumerate(clean_rows): + if count == 0: + if self._csv_header is None: + self._csv_header = row + elif self._csv_header != row: + self._logger.warning( + "CSV Headers from IPG data have changed during the experiment " + "expected: %s; got: %s" + % (str(self._csv_header), str(row)) + ) + writer.writerow(row) + except Exception as e: + self._logger.warning( + "Could not write out cleaned results of %s to %s due to the following error" + ", skipping this step: %s" % (file, clean_output_path, str(e)) + ) + + # Check to make sure the expected number of samples + # exist in the file and that the columns have the correct + # data type. + column_datatypes = {"System Time": str, "RDTSC": int, "default": float} + # pylint --py3k W1619 + expected_samples = int( + self._ipg_measure_duration / (float(self._sampling_rate) / 1000) + ) + for key in results: + if len(results[key]) != expected_samples: + self._logger.warning( + "Unexpected number of samples in %s for column %s - " + "expected: %s, got: %s" + % (clean_output_path, key, expected_samples, len(results[key])) + ) + + dtype = column_datatypes["default"] + if key in column_datatypes: + dtype = column_datatypes[key] + + for val in results[key]: + try: + # Check if converting from a string to its expected data + # type works, if not, it's not the expected data type. + dtype(val) + except ValueError as e: + raise IPGUnknownValueTypeError( + "Cleaned file %s entry %s in column %s has unknown type " + "instead of the expected type %s - data corrupted, " + "cannot continue: %s" + % (clean_output_path, str(val), key, dtype.__name__, str(e)) + ) + + # Check to make sure that IPG measured for the expected + # amount of time. + etime = "Elapsed Time (sec)" + if etime in results: + total_time = int(float(results[etime][-1])) + if total_time != self._ipg_measure_duration: + self._logger.warning( + "Elapsed time found in file %s is different from expected length - " + "expected: %s, got: %s" + % (clean_output_path, self._ipg_measure_duration, total_time) + ) + else: + self._logger.warning( + "Missing 'Elapsed Time (sec)' in file %s" % clean_output_path + ) + + return results, summary, clean_output_path + + def _combine_cumulative_rows(self, cumulatives): + """Combine cumulative rows from multiple IPG files into + a single time series. + + :param list cumulatives: list of cumulative time series collected + over time, on for each file. Must be ordered in increasing time. + :returns: list + """ + combined_cumulatives = [] + + val_mod = 0 + for count, cumulative in enumerate(cumulatives): + # Add the previous file's maximum cumulative value + # to the current one + mod_cumulative = [val_mod + float(val) for val in cumulative] + val_mod = mod_cumulative[-1] + combined_cumulatives.extend(mod_cumulative) + + return combined_cumulatives + + def clean_ipg_data(self): + """Cleans all IPG files, or data, that was produced by an IntelPowerGadget object. + Returns a dict containing the merged data from all files. + + :returns: dict + """ + self._logger.info("Cleaning IPG data...") + + if not self._output_files: + self._logger.warning("No IPG files to clean.") + return + # If this is called a second time for the same set of files, + # then prevent it from duplicating the cleaned file entries. + if self._cleaned_files: + self._cleaned_files = [] + + # Clean each file individually and gather the results + all_results = [] + for file in self._output_files: + results, summary, output_file_path = self._clean_ipg_file(file) + self._cleaned_files.append(output_file_path) + all_results.append(results) + + # Merge all the results into a single result + combined_results = {} + for measure in all_results[0]: + lmeasure = measure.lower() + if "cumulative" not in lmeasure and "elapsed time" not in lmeasure: + # For measures which are not cumulative, or elapsed time, + # combine them without changing the data. + for count, result in enumerate(all_results): + if "system time" in lmeasure or "rdtsc" in lmeasure: + new_results = result[measure] + else: + new_results = [float(val) for val in result[measure]] + + if count == 0: + combined_results[measure] = new_results + else: + combined_results[measure].extend(new_results) + else: + # For cumulative, and elapsed time measures, we need to + # modify all values - see _combine_cumulative_rows for + # more information on this procedure. + cumulatives = [result[measure] for result in all_results] + self._logger.info( + "Combining cumulative rows for '%s' measure" % measure + ) + combined_results[measure] = self._combine_cumulative_rows(cumulatives) + + # Write merged results to a new file + merged_output_path = os.path.join( + self._output_dir_path, + "%s_merged.%s" + % (self._output_file_prefix, self._output_file_ext.replace(".", "")), + ) + + self._merged_output_path = merged_output_path + self._logger.info("Writing merged IPG results to %s" % merged_output_path) + try: + with open(merged_output_path, "w") as csvfile: + writer = csv.writer(csvfile) + writer.writerow(self._csv_header) + + # Use _csv_header list to keep the header ordering + # the same as the cleaned and raw files. + first_key = list(combined_results.keys())[0] + for row_count, _ in enumerate(combined_results[first_key]): + row = [] + for measure in self._csv_header: + row.append(combined_results[measure][row_count]) + writer.writerow(row) + except Exception as e: + self.merged_output_path = None + self._logger.warning( + "Could not write out merged results to %s due to the following error" + ", skipping this step: %s" % (merged_output_path, str(e)) + ) + + # Check that the combined results have the expected number of samples. + # pylint W16919 + expected_samples = int( + self._ipg_measure_duration / (float(self._sampling_rate) / 1000) + ) + combined_expected_samples = len(self._cleaned_files) * expected_samples + for key in combined_results: + if len(combined_results[key]) != combined_expected_samples: + self._logger.warning( + "Unexpected number of merged samples in %s for column %s - " + "expected: %s, got: %s" + % ( + merged_output_path, + key, + combined_expected_samples, + len(results[key]), + ) + ) + + self._results = combined_results + return self._results + + def format_ipg_data_to_partial_perfherder(self, duration, test_name): + """Format the merged IPG data produced by clean_ipg_data into a + partial/incomplete perfherder data blob. Returns the perfherder + data and stores it in _summarized_results. + + This perfherder data still needs more information added to it before it + can be validated against the perfherder schema. The entries returned + through here are missing many required fields. Furthermore, the 'values' + entries need to be formatted into 'subtests'. + + Here is a sample of a complete perfherder data which uses + the 'utilization' results within the subtests: + ``` + { + "framework": {"name": "raptor"}, + "type": "power", + "unit": "mWh" + "suites": [ + { + "name": "raptor-tp6-amazon-firefox-power", + "lowerIsBetter": true, + "alertThreshold": 2.0, + "subtests": [ + { + "lowerIsBetter": true, + "unit": "%", + "name": "raptor-tp6-youtube-firefox-power-cpu", + "value": 14.409090909090908, + "alertThreshold": 2.0 + }, + { + "lowerIsBetter": true, + "unit": "%", + "name": "raptor-tp6-youtube-firefox-power-gpu", + "value": 20.1, + "alertThreshold": 2.0 + }, + ] + } + ] + } + ``` + + To obtain data that is formatted to a complete perfherder data blob, + see get_complete_perfherder_data in MozPower. + + :param float duration: the actual duration of the test in case some + data needs to be cut off from the end. + :param str test_name: the name of the test. + :returns: dict + """ + self._logger.info("Formatting cleaned IPG data into partial perfherder data") + + if not self._results: + self._logger.warning( + "No merged results found - cannot format data to perfherder format." + ) + return + + def replace_measure_name(name): + """Replaces the long IPG names with shorter versions. + Returns the given name if no conversions exist. + + :param str name: name of the entry to replace. + :returns: str + """ + lname = name.lower() + if "ia " in lname: + return "processor-cores" + elif "processor " in lname: + return "processor-package" + elif "gt " in lname: + return "gpu" + elif "dram " in lname: + return "dram" + else: + return name + + # Cut out entries which surpass the test duration. + # Occurs when IPG continues past the call to stop it. + cut_results = self._results + if duration: + cutoff_index = 0 + for count, etime in enumerate(self._results["Elapsed Time (sec)"]): + if etime > duration: + cutoff_index = count + break + if cutoff_index > 0: + for measure in self._results: + cut_results[measure] = self._results[measure][:cutoff_index] + + # Get the cumulative power used in mWh + cumulative_mwh = {} + for measure in cut_results: + if "cumulative" in measure.lower() and "mwh" in measure.lower(): + cumulative_mwh[replace_measure_name(measure)] = float( + cut_results[measure][-1] + ) + + # Get the power usage rate in Watts + watt_usage = {} + for measure in cut_results: + if "watt" in measure.lower() and "limit" not in measure.lower(): + # pylint --py3k W1619 + watt_usage[replace_measure_name(measure) + "-avg"] = sum( + [float(val) for val in cut_results[measure]] + ) / len(cut_results[measure]) + watt_usage[replace_measure_name(measure) + "-max"] = max( + [float(val) for val in cut_results[measure]] + ) + + # Get average CPU and GPU utilization + average_utilization = {} + for utilization in ("CPU Utilization(%)", "GT Utilization(%)"): + if utilization not in cut_results: + self._logger.warning( + "Could not find measurements for: %s" % utilization + ) + continue + + utilized_name = utilization.lower() + if "cpu " in utilized_name: + utilized_name = "cpu" + elif "gt " in utilized_name: + utilized_name = "gpu" + + # pylint --py3k W1619 + average_utilization[utilized_name] = sum( + [float(val) for val in cut_results[utilization]] + ) / len(cut_results[utilization]) + + # Get average and maximum CPU and GPU frequency + frequency_info = {"cpu": {}, "gpu": {}} + for frequency_measure in ("CPU Frequency_0(MHz)", "GT Frequency(MHz)"): + if frequency_measure not in cut_results: + self._logger.warning( + "Could not find measurements for: %s" % frequency_measure + ) + continue + + fmeasure_name = frequency_measure.lower() + if "cpu " in fmeasure_name: + fmeasure_name = "cpu" + elif "gt " in fmeasure_name: + fmeasure_name = "gpu" + # pylint --py3k W1619 + + frequency_info[fmeasure_name]["favg"] = sum( + [float(val) for val in cut_results[frequency_measure]] + ) / len(cut_results[frequency_measure]) + + frequency_info[fmeasure_name]["fmax"] = max( + [float(val) for val in cut_results[frequency_measure]] + ) + + frequency_info[fmeasure_name]["fmin"] = min( + [float(val) for val in cut_results[frequency_measure]] + ) + + summarized_results = { + "utilization": { + "type": "power", + "test": str(test_name) + "-utilization", + "unit": "%", + "values": average_utilization, + }, + "power-usage": { + "type": "power", + "test": str(test_name) + "-cumulative", + "unit": "mWh", + "values": cumulative_mwh, + }, + "power-watts": { + "type": "power", + "test": str(test_name) + "-watts", + "unit": "W", + "values": watt_usage, + }, + "frequency-cpu": { + "type": "power", + "test": str(test_name) + "-frequency-cpu", + "unit": "MHz", + "values": frequency_info["cpu"], + }, + "frequency-gpu": { + "type": "power", + "test": str(test_name) + "-frequency-gpu", + "unit": "MHz", + "values": frequency_info["gpu"], + }, + } + + self._summarized_results = summarized_results + return self._summarized_results diff --git a/testing/mozbase/mozpower/mozpower/macintelpower.py b/testing/mozbase/mozpower/mozpower/macintelpower.py new file mode 100644 index 0000000000..18629b4a9a --- /dev/null +++ b/testing/mozbase/mozpower/mozpower/macintelpower.py @@ -0,0 +1,92 @@ +# This Source Code Form is subject to the terms of the Mozilla Public +# License, v. 2.0. If a copy of the MPL was not distributed with this +# file, You can obtain one at http://mozilla.org/MPL/2.0/. +import time + +from .intel_power_gadget import IntelPowerGadget, IPGResultsHandler +from .powerbase import PowerBase + + +class MacIntelPower(PowerBase): + """MacIntelPower is the OS and CPU dependent class for + power measurement gathering on Mac Intel-based hardware. + + :: + + from mozpower.macintelpower import MacIntelPower + + # duration and output_file_path are used in IntelPowerGadget + mip = MacIntelPower(ipg_measure_duration=600, output_file_path='power-testing') + + mip.initialize_power_measurements() + # Run test... + mip.finalize_power_measurements(test_name='raptor-test-name') + + perfherder_data = mip.get_perfherder_data() + """ + + def __init__(self, logger_name="mozpower", **kwargs): + """Initializes the MacIntelPower object. + + :param str logger_name: logging logger name. Defaults to 'mozpower'. + :param dict kwargs: optional keyword arguments passed to IntelPowerGadget. + """ + PowerBase.__init__(self, logger_name=logger_name, os="darwin", cpu="intel") + self.ipg = IntelPowerGadget(self.ipg_path, **kwargs) + self.ipg_results_handler = None + self.start_time = None + self.end_time = None + self.perfherder_data = {} + + def initialize_power_measurements(self): + """Starts power measurement gathering through IntelPowerGadget.""" + self._logger.info("Initializing power measurements...") + + # Start measuring + self.ipg.start_ipg() + + # Record start time to get an approximation of run time + self.start_time = time.time() + + def finalize_power_measurements( + self, test_name="power-testing", output_dir_path="", **kwargs + ): + """Stops power measurement gathering through IntelPowerGadget, cleans the data, + and produces partial perfherder formatted data that is stored in perfherder_data. + + :param str test_name: name of the test that was run. + :param str output_dir_path: directory to store output files. + :param dict kwargs: contains optional arguments to stop_ipg. + """ + self._logger.info("Finalizing power measurements...") + self.end_time = time.time() + + # Wait until Intel Power Gadget is done, then clean the data + # and then format it + self.ipg.stop_ipg(**kwargs) + + # Handle the results and format them to a partial perfherder format + if not output_dir_path: + output_dir_path = self.ipg.output_dir_path + + self.ipg_results_handler = IPGResultsHandler( + self.ipg.output_files, + output_dir_path, + ipg_measure_duration=self.ipg.ipg_measure_duration, + sampling_rate=self.ipg.sampling_rate, + logger_name=self.logger_name, + ) + + self.ipg_results_handler.clean_ipg_data() + self.perfherder_data = ( + self.ipg_results_handler.format_ipg_data_to_partial_perfherder( + self.end_time - self.start_time, test_name + ) + ) + + def get_perfherder_data(self): + """Returns the perfherder data output that was produced. + + :returns: dict + """ + return self.perfherder_data diff --git a/testing/mozbase/mozpower/mozpower/mozpower.py b/testing/mozbase/mozpower/mozpower/mozpower.py new file mode 100644 index 0000000000..2333fc84ee --- /dev/null +++ b/testing/mozbase/mozpower/mozpower/mozpower.py @@ -0,0 +1,376 @@ +# This Source Code Form is subject to the terms of the Mozilla Public +# License, v. 2.0. If a copy of the MPL was not distributed with this +# file, You can obtain one at http://mozilla.org/MPL/2.0/. +import os +import platform +import re +import subprocess + +import six + +from .macintelpower import MacIntelPower +from .mozpowerutils import average_summary, frequency_summary, get_logger, sum_summary + +OSCPU_COMBOS = { + "darwin-intel": MacIntelPower, +} + +SUMMARY_METHODS = { + "utilization": average_summary, + "power-usage": sum_summary, + "power-watts": frequency_summary, + "frequency-cpu": frequency_summary, + "frequency-gpu": frequency_summary, + "default": sum_summary, +} + + +class OsCpuComboMissingError(Exception): + """OsCpuComboMissingError is raised when we cannot find + a class responsible for the OS, and CPU combination that + was detected. + """ + + pass + + +class MissingProcessorInfoError(Exception): + """MissingProcessorInfoError is raised when we cannot find + the processor information on the machine. This is raised when + the file is missing (mentioned in the error message) or if + an exception occurs when we try to gather the information + from the file. + """ + + pass + + +class MozPower(object): + """MozPower provides an OS and CPU independent interface + for initializing, finalizing, and gathering power measurement + data from OS+CPU combo-dependent measurement classes. The combo + is detected automatically, and the correct class is instantiated + based on the OSCPU_COMBOS list. If it cannot be found, an + OsCpuComboMissingError will be raised. + + If a newly added power measurer does not have the required functions + `initialize_power_measurements`, `finalize_power_measurements`, + or `get_perfherder_data`, then a NotImplementedError will be + raised. + + Android power measurements are currently not supported by this + module. + + :: + + from mozpower import MozPower + + mp = MozPower(output_file_path='dir/power-testing') + + mp.initialize_power_measurements() + # Run test... + mp.finalize_power_measurements(test_name='raptor-test-name') + + perfherder_data = mp.get_perfherder_data() + """ + + def __init__( + self, + android=False, + logger_name="mozpower", + output_file_path="power-testing", + **kwargs + ): + """Initializes the MozPower object, detects OS and CPU (if not android), + and instatiates the appropriate combo-dependent class for measurements. + + :param bool android: run android power measurer. + :param str logger_name: logging logger name. Defaults to 'mozpower'. + :param str output_file_path: path to where output files will be stored. + Can include a prefix for the output files, i.e. 'dir/raptor-test' + would output data to 'dir' with the prefix 'raptor-test'. + Defaults to 'power-testing', the current directory using + the prefix 'power-testing'. + :param dict kwargs: optional keyword arguments passed to power measurer. + :raises: * OsCpuComboMissingError + * NotImplementedError + """ + self.measurer = None + self._os = None + self._cpu = None + self._logger = get_logger(logger_name) + + if android: + self._logger.error("Android power usage measurer has not been implemented") + raise NotImplementedError + else: + self._os = self._get_os().lower() + cpu = six.text_type(self._get_processor_info().lower()) + + if "intel" in cpu: + self._cpu = "intel" + else: + self._cpu = "arm64" + + # OS+CPU combos are specified through strings such as 'darwin-intel' + # for mac power measurement on intel-based machines. If none exist in + # OSCPU_COMBOS, OsCpuComboMissingError will be raised. + measurer = None + oscpu_combo = "%s-%s" % (self._os, self._cpu) + if oscpu_combo in OSCPU_COMBOS: + measurer = OSCPU_COMBOS[oscpu_combo] + else: + raise OsCpuComboMissingError( + "Cannot find OS+CPU combo for %s" % oscpu_combo + ) + + if measurer: + self._logger.info( + "Intializing measurer %s for %s power measurements, see below for errors..." + % (measurer.__name__, oscpu_combo) + ) + self.measurer = measurer( + logger_name=logger_name, output_file_path=output_file_path, **kwargs + ) + + def _get_os(self): + """Returns the operating system of the machine being tested. platform.system() + returns 'darwin' on MacOS, 'windows' on Windows, and 'linux' on Linux systems. + + :returns: str + """ + return platform.system() + + def _get_processor_info(self): + """Returns the processor model type of the machine being tested. + Each OS has it's own way of storing this information. Raises + MissingProcessorInfoError if we cannot get the processor info + from the expected locations. + + :returns: str + :raises: * MissingProcessorInfoError + """ + model = "" + + if self._get_os() == "Windows": + model = platform.processor() + + elif self._get_os() == "Darwin": + proc_info_path = "/usr/sbin/sysctl" + command = [proc_info_path, "-n", "machdep.cpu.brand_string"] + + if not os.path.exists(proc_info_path): + raise MissingProcessorInfoError( + "Missing processor info file for darwin platform, " + "expecting it here %s" % proc_info_path + ) + + try: + model = subprocess.check_output(command).strip() + except subprocess.CalledProcessError as e: + error_log = str(e) + if e.output: + error_log = e.output.decode() + raise MissingProcessorInfoError( + "Error while attempting to get darwin processor information " + "from %s (exists) with the command %s: %s" + % (proc_info_path, str(command), error_log) + ) + + elif self._get_os() == "Linux": + proc_info_path = "/proc/cpuinfo" + model_re = re.compile(r""".*model name\s+[:]\s+(.*)\s+""") + + if not os.path.exists(proc_info_path): + raise MissingProcessorInfoError( + "Missing processor info file for linux platform, " + "expecting it here %s" % proc_info_path + ) + + try: + with open(proc_info_path) as cpuinfo: + for line in cpuinfo: + if not line.strip(): + continue + match = model_re.match(line) + if match: + model = match.group(1) + if not model: + raise Exception( + "No 'model name' entries found in the processor info file" + ) + except Exception as e: + raise MissingProcessorInfoError( + "Error while attempting to get linux processor information " + "from %s (exists): %s" % (proc_info_path, str(e)) + ) + + return model + + def initialize_power_measurements(self, **kwargs): + """Starts the power measurements by calling the power measurer's + `initialize_power_measurements` function. + + :param dict kwargs: keyword arguments for power measurer initialization + function if they are needed. + """ + if self.measurer is None: + return + self.measurer.initialize_power_measurements(**kwargs) + + def finalize_power_measurements(self, **kwargs): + """Stops the power measurements by calling the power measurer's + `finalize_power_measurements` function. + + :param dict kwargs: keyword arguments for power measurer finalization + function if they are needed. + """ + if self.measurer is None: + return + self.measurer.finalize_power_measurements(**kwargs) + + def get_perfherder_data(self): + """Returns the partial perfherder data output produced by the measurer. + For a complete perfherder data blob, see get_full_perfherder_data. + + :returns: dict + """ + if self.measurer is None: + return + return self.measurer.get_perfherder_data() + + def _summarize_values(self, datatype, values): + """Summarizes the given values based on the type of the + data. See SUMMARY_METHODS for the methods used for each + known data type. Defaults to using the sum of the values + when a data type cannot be found. + + Data type entries in SUMMARY_METHODS are case-sensitive. + + :param str datastype: the measurement type being summarized. + :param list values: the values to summarize. + :returns: float + """ + if datatype not in SUMMARY_METHODS: + self._logger.warning( + "Missing summary method for data type %s, defaulting to sum" % datatype + ) + datatype = "default" + + summary_func = SUMMARY_METHODS[datatype] + return summary_func(values) + + def get_full_perfherder_data( + self, framework, lowerisbetter=True, alertthreshold=2.0 + ): + """Returns a list of complete perfherder data blobs compiled from the + partial perfherder data blob returned from the measurer. Each key entry + (measurement type) in the partial perfherder data is parsed into its + own suite within a single perfherder data blob. + + For example, a partial perfherder data blob such as: + + :: + + { + 'utilization': {}, + 'power-usage': {} + } + + would produce two suites within a single perfherder data blobs - + one for utilization, and one for power-usage. + + Note that the 'values' entry must exist, otherwise the measurement + type is skipped. Furthermore, if 'name', 'unit', or 'type' is missing + we default to: + + :: + + { + 'name': 'mozpower', + 'unit': 'mWh', + 'type': 'power' + } + + Subtests produced for each sub-suite (measurement type), have the naming + pattern: - + + Utilization of cpu would have the following name: 'utilization-cpu' + Power-usage for cpu has the following name: 'power-usage-cpu' + + :param str framework: name of the framework being tested, i.e. 'raptor'. + :param bool lowerisbetter: if set to true, low values are better than high ones. + :param float alertthreshold: determines the crossing threshold at + which an alert is generated. + :returns: dict + """ + if self.measurer is None: + return + + # Get the partial data, and the measurers name for + # logging purposes. + partial_perfherder_data = self.get_perfherder_data() + measurer_name = self.measurer.__class__.__name__ + + suites = [] + perfherder_data = {"framework": {"name": framework}, "suites": suites} + + for measurement_type in partial_perfherder_data: + self._logger.info("Summarizing %s data" % measurement_type) + dataset = partial_perfherder_data[measurement_type] + + # Skip this measurement type if the 'values' entry + # doesn't exist, and output a warning. + if "values" not in dataset: + self._logger.warning( + "Missing 'values' entry in partial perfherder data for measurement type %s " + "obtained from %s. This measurement type will not be processed." + % (measurement_type, measurer_name) + ) + continue + + # Get the settings, if they exist, otherwise output + # a warning and use a default entry. + settings = {"test": "mozpower", "unit": "mWh", "type": "power"} + + for setting in settings: + if setting in dataset: + settings[setting] = dataset[setting] + else: + self._logger.warning( + "Missing '%s' entry in partial perfherder data for measurement type %s " + "obtained from %s, using %s as the default" + % (setting, measurement_type, measurer_name, settings[setting]) + ) + + subtests = [] + suite = { + "name": "%s-%s" % (settings["test"], measurement_type), + "type": settings["type"], + "value": 0, + "subtests": subtests, + "lowerIsBetter": lowerisbetter, + "unit": settings["unit"], + "alertThreshold": alertthreshold, + } + + # Parse the 'values' entries into subtests + values = [] + for measure in dataset["values"]: + value = dataset["values"][measure] + subtest = { + "name": "%s-%s" % (measurement_type, measure), + "value": float(value), + "lowerIsBetter": lowerisbetter, + "alertThreshold": alertthreshold, + "unit": settings["unit"], + } + values.append((value, measure)) + subtests.append(subtest) + + # Summarize the data based on the measurement type + if len(values) > 0: + suite["value"] = self._summarize_values(measurement_type, values) + suites.append(suite) + + return perfherder_data diff --git a/testing/mozbase/mozpower/mozpower/mozpowerutils.py b/testing/mozbase/mozpower/mozpower/mozpowerutils.py new file mode 100644 index 0000000000..bedf272a0e --- /dev/null +++ b/testing/mozbase/mozpower/mozpower/mozpowerutils.py @@ -0,0 +1,58 @@ +# This Source Code Form is subject to the terms of the Mozilla Public +# License, v. 2.0. If a copy of the MPL was not distributed with this +# file, You can obtain one at http://mozilla.org/MPL/2.0/. + + +def get_logger(logger_name): + """Returns the logger that should be used based on logger_name. + Defaults to the logging logger if mozlog cannot be imported. + + :returns: mozlog or logging logger object + """ + logger = None + try: + import mozlog + + logger = mozlog.get_default_logger(logger_name) + except ImportError: + pass + + if logger is None: + import logging + + logging.basicConfig() + logger = logging.getLogger(logger_name) + return logger + + +def average_summary(values): + """Averages all given values. + + :param list values: list of values to average. + :returns: float + """ + # pylint --py3k W1619 + return sum([float(v[0]) for v in values]) / len(values) + + +def sum_summary(values): + """Adds all values together. + + :param list values: list of values to sum. + :returns: float + """ + return sum([float(v[0]) for v in values]) + + +def frequency_summary(values): + """Returns the average frequency as the summary value. + + :param list values: list of values to search in. + :returns: float + """ + avgfreq = 0 + for val, name in values: + if "avg" in name: + avgfreq = float(val) + break + return avgfreq diff --git a/testing/mozbase/mozpower/mozpower/powerbase.py b/testing/mozbase/mozpower/mozpower/powerbase.py new file mode 100644 index 0000000000..3eb91e3e3b --- /dev/null +++ b/testing/mozbase/mozpower/mozpower/powerbase.py @@ -0,0 +1,122 @@ +# This Source Code Form is subject to the terms of the Mozilla Public +# License, v. 2.0. If a copy of the MPL was not distributed with this +# file, You can obtain one at http://mozilla.org/MPL/2.0/. +import os + +from .mozpowerutils import get_logger + + +class IPGExecutableMissingError(Exception): + """IPGExecutableMissingError is raised when we cannot find + the executable for Intel Power Gadget at the expected location. + """ + + pass + + +class PlatformUnsupportedError(Exception): + """PlatformUnsupportedError is raised when we cannot find + an expected IPG path for the OS being tested. + """ + + pass + + +class PowerBase(object): + """PowerBase provides an interface for power measurement objects + that depend on the os and cpu. When using this class as a base class + the `initialize_power_measurements`, `finalize_power_measurements`, + and `get_perfherder_data` functions must be implemented, otherwise + a NotImplementedError will be raised. + + PowerBase should only be used as the base class for other + classes and should not be instantiated directly. To enforce this + restriction calling PowerBase's constructor will raise a + NonImplementedError exception. + + :: + + from mozpower.powerbase import PowerBase + + try: + pb = PowerBase() + except NotImplementedError: + print "PowerBase cannot be instantiated." + + """ + + def __init__(self, logger_name="mozpower", os=None, cpu=None): + """Initializes the PowerBase object. + + :param str logger_name: logging logger name. Defaults to 'mozpower'. + :param str os: operating system being tested. Defaults to None. + :param str cpu: cpu type being tested (either intel or arm64). Defaults to None. + :raises: * NotImplementedError + """ + if self.__class__ == PowerBase: + raise NotImplementedError + + self._logger_name = logger_name + self._logger = get_logger(logger_name) + self._os = os + self._cpu = cpu + self._ipg_path = self.get_ipg_path() + + @property + def ipg_path(self): + return self._ipg_path + + @property + def logger_name(self): + return self._logger_name + + def initialize_power_measurements(self): + """Starts power measurement gathering, must be implemented by subclass. + + :raises: * NotImplementedError + """ + raise NotImplementedError + + def finalize_power_measurements(self, test_name="power-testing", **kwargs): + """Stops power measurement gathering, must be implemented by subclass. + + :raises: * NotImplementedError + """ + raise NotImplementedError + + def get_perfherder_data(self): + """Returns the perfherder data output produced from the tests, must + be implemented by subclass. + + :raises: * NotImplementedError + """ + raise NotImplementedError + + def get_ipg_path(self): + """Returns the path to where we expect to find Intel Power Gadget + depending on the OS being tested. Raises a PlatformUnsupportedError + if the OS being tested is unsupported, and raises a IPGExecutableMissingError + if the Intel Power Gadget executable cannot be found at the expected + location. + + :returns: str + :raises: * IPGExecutableMissingError + * PlatformUnsupportedError + """ + if self._cpu != "intel": + return None + + if self._os == "darwin": + exe_path = "/Applications/Intel Power Gadget/PowerLog" + else: + raise PlatformUnsupportedError( + "%s platform currently not supported for Intel Power Gadget measurements" + % self._os + ) + if not os.path.exists(exe_path): + raise IPGExecutableMissingError( + "Intel Power Gadget is not installed, or cannot be found at the location %s" + % exe_path + ) + + return exe_path diff --git a/testing/mozbase/mozpower/setup.cfg b/testing/mozbase/mozpower/setup.cfg new file mode 100644 index 0000000000..2a9acf13da --- /dev/null +++ b/testing/mozbase/mozpower/setup.cfg @@ -0,0 +1,2 @@ +[bdist_wheel] +universal = 1 diff --git a/testing/mozbase/mozpower/setup.py b/testing/mozbase/mozpower/setup.py new file mode 100644 index 0000000000..4d1cb0cb00 --- /dev/null +++ b/testing/mozbase/mozpower/setup.py @@ -0,0 +1,34 @@ +# This Source Code Form is subject to the terms of the Mozilla Public +# License, v. 2.0. If a copy of the MPL was not distributed with this file, +# You can obtain one at http://mozilla.org/MPL/2.0/. + +from setuptools import setup + +PACKAGE_NAME = "mozpower" +PACKAGE_VERSION = "1.1.2" + +deps = ["mozlog >= 6.0", "mozdevice >= 4.0.0,<5"] + +setup( + name=PACKAGE_NAME, + version=PACKAGE_VERSION, + description="Mozilla-authored power usage measurement tools", + long_description="see https://firefox-source-docs.mozilla.org/mozbase/index.html", + classifiers=[ + "Programming Language :: Python :: 2.7", + "Programming Language :: Python :: 3.5", + ], + # Get strings from http://pypi.python.org/pypi?%3Aaction=list_classifiers + keywords="", + author="Mozilla Performance Test Engineering Team", + author_email="tools@lists.mozilla.org", + url="https://wiki.mozilla.org/Auto-tools/Projects/Mozbase", + license="MPL", + packages=["mozpower"], + include_package_data=True, + zip_safe=False, + install_requires=deps, + entry_points=""" + # -*- Entry points: -*- + """, +) diff --git a/testing/mozbase/mozpower/tests/conftest.py b/testing/mozbase/mozpower/tests/conftest.py new file mode 100644 index 0000000000..9d81b0229b --- /dev/null +++ b/testing/mozbase/mozpower/tests/conftest.py @@ -0,0 +1,103 @@ +import os +import tempfile +import time +from unittest import mock + +import pytest +from mozpower import MozPower +from mozpower.intel_power_gadget import IntelPowerGadget, IPGResultsHandler +from mozpower.macintelpower import MacIntelPower +from mozpower.powerbase import PowerBase + + +def os_side_effect(*args, **kwargs): + """Used as a side effect to os.path.exists when + checking if the Intel Power Gadget executable exists. + """ + return True + + +def subprocess_side_effect(*args, **kwargs): + """Used as a side effect when running the Intel Power + Gadget tool. + """ + time.sleep(1) + + +@pytest.fixture(scope="function") +def powermeasurer(): + """Returns a testing subclass of the PowerBase class + for testing. + """ + + class PowerMeasurer(PowerBase): + pass + + return PowerMeasurer() + + +@pytest.fixture(scope="function") +def ipg_obj(): + """Returns an IntelPowerGadget object with the test + output file path. + """ + return IntelPowerGadget( + "ipg-path", + output_file_path=os.path.abspath(os.path.dirname(__file__)) + + "/files/raptor-tp6-amazon-firefox_powerlog", + ) + + +@pytest.fixture(scope="function") +def ipg_rh_obj(): + """Returns an IPGResultsHandler object set up with the + test files and cleans up the directory after the tests + are complete. + """ + base_path = os.path.abspath(os.path.dirname(__file__)) + "/files/" + tmpdir = tempfile.mkdtemp() + + # Return the results handler for the test + yield IPGResultsHandler( + [ + base_path + "raptor-tp6-amazon-firefox_powerlog_1_.txt", + base_path + "raptor-tp6-amazon-firefox_powerlog_2_.txt", + base_path + "raptor-tp6-amazon-firefox_powerlog_3_.txt", + ], + tmpdir, + ) + + +@pytest.fixture(scope="function") +def macintelpower_obj(): + """Returns a MacIntelPower object with subprocess.check_output + and os.path.exists calls patched with side effects. + """ + with mock.patch("subprocess.check_output") as subprocess_mock: + with mock.patch("os.path.exists") as os_mock: + subprocess_mock.side_effect = subprocess_side_effect + os_mock.side_effect = os_side_effect + + yield MacIntelPower(ipg_measure_duration=2) + + +@pytest.fixture(scope="function") +def mozpower_obj(): + """Returns a MozPower object with subprocess.check_output + and os.path.exists calls patched with side effects. + """ + with mock.patch.object( + MozPower, "_get_os", return_value="Darwin" + ) as _, mock.patch.object( + MozPower, "_get_processor_info", return_value="GenuineIntel" + ) as _, mock.patch.object( + MacIntelPower, "get_ipg_path", return_value="/" + ) as _, mock.patch( + "subprocess.check_output" + ) as subprocess_mock, mock.patch( + "os.path.exists" + ) as os_mock: + subprocess_mock.side_effect = subprocess_side_effect + os_mock.side_effect = os_side_effect + + yield MozPower(ipg_measure_duration=2) diff --git a/testing/mozbase/mozpower/tests/files/emptyfile.txt b/testing/mozbase/mozpower/tests/files/emptyfile.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/testing/mozbase/mozpower/tests/files/raptor-tp6-amazon-firefox_powerlog_1_.txt b/testing/mozbase/mozpower/tests/files/raptor-tp6-amazon-firefox_powerlog_1_.txt new file mode 100644 index 0000000000..d5cc3f91a5 --- /dev/null +++ b/testing/mozbase/mozpower/tests/files/raptor-tp6-amazon-firefox_powerlog_1_.txt @@ -0,0 +1,30 @@ +"System Time","RDTSC","Elapsed Time (sec)","CPU Utilization(%)","CPU Frequency_0(MHz)","Processor Power_0(Watt)","Cumulative Processor Energy_0(Joules)","Cumulative Processor Energy_0(mWh)","IA Power_0(Watt)","Cumulative IA Energy_0(Joules)","Cumulative IA Energy_0(mWh)","Package Temperature_0(C)","Package Hot_0","DRAM Power_0(Watt)","Cumulative DRAM Energy_0(Joules)","Cumulative DRAM Energy_0(mWh)","GT Power_0(Watt)","Cumulative GT Energy_0(Joules)","Cumulative GT Energy_0(mWh)","Package Power Limit_0(Watt)","GT Frequency(MHz)" +"12:11:05:769","61075218263548"," 2.002"," 14.000"," 3400"," 23.427"," 23.460"," 6.517"," 21.019"," 21.048"," 5.847"," 75","0"," 0.877"," 0.878"," 0.244"," 0.020"," 0.020"," 0.006"," 45.000"," 0" +"12:11:06:774","61077822279584"," 3.007"," 20.000"," 3000"," 25.014"," 48.590"," 13.497"," 22.386"," 43.538"," 12.094"," 74","0"," 1.194"," 2.078"," 0.577"," 0.029"," 0.049"," 0.014"," 45.000"," 0" +"12:11:07:778","61080424421708"," 4.011"," 8.000"," 1300"," 9.512"," 58.140"," 16.150"," 6.904"," 50.469"," 14.019"," 65","0"," 0.836"," 2.917"," 0.810"," 0.007"," 0.057"," 0.016"," 45.000"," 0" +"12:11:08:781","61083023535972"," 5.013"," 1.000"," 1300"," 1.786"," 59.931"," 16.647"," 0.687"," 51.158"," 14.210"," 63","0"," 0.585"," 3.504"," 0.973"," 0.000"," 0.057"," 0.016"," 45.000"," 0" +"12:11:09:784","61085623402302"," 6.016"," 4.000"," 4000"," 5.249"," 65.195"," 18.110"," 3.743"," 54.912"," 15.253"," 75","0"," 0.660"," 4.166"," 1.157"," 0.003"," 0.059"," 0.017"," 45.000"," 0" +"12:11:10:787","61088224087008"," 7.020"," 20.000"," 3000"," 35.118"," 100.432"," 27.898"," 31.647"," 86.666"," 24.074"," 72","0"," 1.048"," 5.218"," 1.449"," 0.016"," 0.076"," 0.021"," 45.000"," 0" +"12:11:11:791","61090825821126"," 8.024"," 13.000"," 3000"," 25.436"," 125.965"," 34.990"," 22.228"," 108.979"," 30.272"," 71","0"," 0.868"," 6.089"," 1.691"," 0.004"," 0.080"," 0.022"," 45.000"," 0" +"12:11:12:795","61093429020836"," 9.028"," 5.000"," 1300"," 5.266"," 131.253"," 36.459"," 3.270"," 112.263"," 31.184"," 64","0"," 0.711"," 6.802"," 1.890"," 0.000"," 0.080"," 0.022"," 45.000"," 0" +"12:11:13:796","61096024160928"," 10.029"," 5.000"," 4000"," 11.070"," 142.338"," 39.538"," 9.613"," 121.888"," 33.858"," 78","0"," 0.650"," 7.453"," 2.070"," 0.000"," 0.080"," 0.022"," 45.000"," 0" +"12:11:13:796","61096024279264"," 10.029"," 57.000"," 4000"," 0.000"," 142.338"," 39.538"," 0.000"," 121.888"," 33.858"," 78","0"," 0.000"," 7.453"," 2.070"," 0.000"," 0.080"," 0.022"," 45.000"," 0" + +"Total Elapsed Time (sec) = 10.029232" +"Measured RDTSC Frequency (GHz) = 2.592" + +"Cumulative Processor Energy_0 (Joules) = 142.337524" +"Cumulative Processor Energy_0 (mWh) = 39.538201" +"Average Processor Power_0 (Watt) = 14.192265" + +"Cumulative IA Energy_0 (Joules) = 121.888000" +"Cumulative IA Energy_0 (mWh) = 33.857778" +"Average IA Power_0 (Watt) = 12.153273" + +"Cumulative DRAM Energy_0 (Joules) = 7.453308" +"Cumulative DRAM Energy_0 (mWh) = 2.070363" +"Average DRAM Power_0 (Watt) = 0.743158" + +"Cumulative GT Energy_0 (Joules) = 0.079834" +"Cumulative GT Energy_0 (mWh) = 0.022176" +"Average GT Power_0 (Watt) = 0.007960" diff --git a/testing/mozbase/mozpower/tests/files/raptor-tp6-amazon-firefox_powerlog_2_.txt b/testing/mozbase/mozpower/tests/files/raptor-tp6-amazon-firefox_powerlog_2_.txt new file mode 100644 index 0000000000..9157ad1fad --- /dev/null +++ b/testing/mozbase/mozpower/tests/files/raptor-tp6-amazon-firefox_powerlog_2_.txt @@ -0,0 +1,30 @@ +"System Time","RDTSC","Elapsed Time (sec)","CPU Utilization(%)","CPU Frequency_0(MHz)","Processor Power_0(Watt)","Cumulative Processor Energy_0(Joules)","Cumulative Processor Energy_0(mWh)","IA Power_0(Watt)","Cumulative IA Energy_0(Joules)","Cumulative IA Energy_0(mWh)","Package Temperature_0(C)","Package Hot_0","DRAM Power_0(Watt)","Cumulative DRAM Energy_0(Joules)","Cumulative DRAM Energy_0(mWh)","GT Power_0(Watt)","Cumulative GT Energy_0(Joules)","Cumulative GT Energy_0(mWh)","Package Power Limit_0(Watt)","GT Frequency(MHz)" +"12:11:15:821","61101270635674"," 2.007"," 9.000"," 4200"," 10.341"," 10.382"," 2.884"," 7.710"," 7.740"," 2.150"," 80","0"," 0.828"," 0.831"," 0.231"," 0.000"," 0.000"," 0.000"," 45.000"," 0" +"12:11:16:823","61103869919264"," 3.010"," 4.000"," 1300"," 9.353"," 19.762"," 5.489"," 8.079"," 15.842"," 4.400"," 64","0"," 0.597"," 1.430"," 0.397"," 0.000"," 0.000"," 0.000"," 45.000"," 0" +"12:11:17:826","61106469262970"," 4.013"," 19.000"," 2500"," 21.127"," 40.950"," 11.375"," 17.753"," 33.645"," 9.346"," 69","0"," 1.091"," 2.524"," 0.701"," 0.011"," 0.011"," 0.003"," 45.000"," 0" +"12:11:18:827","61109063770516"," 5.014"," 11.000"," 2000"," 11.620"," 52.581"," 14.606"," 8.333"," 41.986"," 11.663"," 64","0"," 0.961"," 3.486"," 0.968"," 0.000"," 0.011"," 0.003"," 45.000"," 0" +"12:11:19:831","61111666134444"," 6.018"," 3.000"," 1300"," 2.722"," 55.314"," 15.365"," 1.497"," 43.489"," 12.080"," 64","0"," 0.620"," 4.108"," 1.141"," 0.000"," 0.011"," 0.003"," 45.000"," 0" +"12:11:20:835","61114266619236"," 7.021"," 14.000"," 3400"," 17.108"," 72.478"," 20.133"," 14.538"," 58.075"," 16.132"," 79","0"," 0.918"," 5.029"," 1.397"," 0.004"," 0.016"," 0.004"," 45.000"," 0" +"12:11:21:835","61116859007218"," 8.021"," 15.000"," 3000"," 16.651"," 89.132"," 24.759"," 13.055"," 71.132"," 19.759"," 70","0"," 1.103"," 6.132"," 1.703"," 0.005"," 0.020"," 0.006"," 45.000"," 0" +"12:11:22:836","61119453982614"," 9.023"," 4.000"," 2000"," 3.334"," 92.470"," 25.686"," 1.974"," 73.109"," 20.308"," 64","0"," 0.654"," 6.787"," 1.885"," 0.000"," 0.020"," 0.006"," 45.000"," 0" +"12:11:23:840","61122057636318"," 10.027"," 12.000"," 3400"," 13.925"," 106.458"," 29.572"," 11.603"," 84.764"," 23.546"," 79","0"," 0.856"," 7.647"," 2.124"," 0.006"," 0.027"," 0.007"," 45.000"," 0" +"12:11:23:840","61122057733984"," 10.027"," 66.000"," 3400"," 0.000"," 106.458"," 29.572"," 0.000"," 84.764"," 23.546"," 79","0"," 0.000"," 7.647"," 2.124"," 0.000"," 0.027"," 0.007"," 45.000"," 0" + +"Total Elapsed Time (sec) = 10.027134" +"Measured RDTSC Frequency (GHz) = 2.592" + +"Cumulative Processor Energy_0 (Joules) = 106.457581" +"Cumulative Processor Energy_0 (mWh) = 29.571550" +"Average Processor Power_0 (Watt) = 10.616950" + +"Cumulative IA Energy_0 (Joules) = 84.764404" +"Cumulative IA Energy_0 (mWh) = 23.545668" +"Average IA Power_0 (Watt) = 8.453503" + +"Cumulative DRAM Energy_0 (Joules) = 7.647095" +"Cumulative DRAM Energy_0 (mWh) = 2.124193" +"Average DRAM Power_0 (Watt) = 0.762640" + +"Cumulative GT Energy_0 (Joules) = 0.026550" +"Cumulative GT Energy_0 (mWh) = 0.007375" +"Average GT Power_0 (Watt) = 0.002648" diff --git a/testing/mozbase/mozpower/tests/files/raptor-tp6-amazon-firefox_powerlog_3_.txt b/testing/mozbase/mozpower/tests/files/raptor-tp6-amazon-firefox_powerlog_3_.txt new file mode 100644 index 0000000000..a2779d93a1 --- /dev/null +++ b/testing/mozbase/mozpower/tests/files/raptor-tp6-amazon-firefox_powerlog_3_.txt @@ -0,0 +1,30 @@ +"System Time","RDTSC","Elapsed Time (sec)","CPU Utilization(%)","CPU Frequency_0(MHz)","Processor Power_0(Watt)","Cumulative Processor Energy_0(Joules)","Cumulative Processor Energy_0(mWh)","IA Power_0(Watt)","Cumulative IA Energy_0(Joules)","Cumulative IA Energy_0(mWh)","Package Temperature_0(C)","Package Hot_0","DRAM Power_0(Watt)","Cumulative DRAM Energy_0(Joules)","Cumulative DRAM Energy_0(mWh)","GT Power_0(Watt)","Cumulative GT Energy_0(Joules)","Cumulative GT Energy_0(mWh)","Package Power Limit_0(Watt)","GT Frequency(MHz)" +"12:11:25:867","61127310813944"," 2.006"," 6.000"," 2000"," 4.862"," 4.879"," 1.355"," 3.087"," 3.097"," 0.860"," 65","0"," 0.774"," 0.776"," 0.216"," 0.021"," 0.022"," 0.006"," 45.000"," 0" +"12:11:26:867","61129903677124"," 3.006"," 2.000"," 1300"," 2.883"," 7.763"," 2.156"," 1.253"," 4.350"," 1.208"," 63","0"," 0.644"," 1.421"," 0.395"," 0.018"," 0.039"," 0.011"," 45.000"," 0" +"12:11:27:873","61132509307964"," 4.011"," 2.000"," 1300"," 1.788"," 9.561"," 2.656"," 0.699"," 5.054"," 1.404"," 63","0"," 0.538"," 1.961"," 0.545"," 0.000"," 0.039"," 0.011"," 45.000"," 0" +"12:11:28:877","61135111021262"," 5.015"," 0.000"," 1300"," 1.177"," 10.743"," 2.984"," 0.321"," 5.375"," 1.493"," 63","0"," 0.535"," 2.499"," 0.694"," 0.000"," 0.039"," 0.011"," 45.000"," 0" +"12:11:29:881","61137714179976"," 6.020"," 0.000"," 1300"," 1.064"," 11.811"," 3.281"," 0.251"," 5.627"," 1.563"," 61","0"," 0.520"," 3.021"," 0.839"," 0.000"," 0.039"," 0.011"," 45.000"," 0" +"12:11:30:881","61140307250904"," 7.020"," 0.000"," 1300"," 1.053"," 12.864"," 3.573"," 0.256"," 5.884"," 1.634"," 61","0"," 0.528"," 3.550"," 0.986"," 0.000"," 0.039"," 0.011"," 45.000"," 0" +"12:11:31:885","61142907976768"," 8.023"," 0.000"," 1300"," 1.069"," 13.937"," 3.871"," 0.274"," 6.159"," 1.711"," 61","0"," 0.524"," 4.075"," 1.132"," 0.000"," 0.039"," 0.011"," 45.000"," 0" +"12:11:32:886","61145503940512"," 9.025"," 0.000"," 1300"," 1.008"," 14.947"," 4.152"," 0.228"," 6.387"," 1.774"," 60","0"," 0.522"," 4.598"," 1.277"," 0.000"," 0.039"," 0.011"," 45.000"," 0" +"12:11:33:891","61148109378824"," 10.030"," 0.000"," 1300"," 1.007"," 15.959"," 4.433"," 0.230"," 6.618"," 1.838"," 61","0"," 0.522"," 5.123"," 1.423"," 0.000"," 0.039"," 0.011"," 45.000"," 0" +"12:11:33:892","61148109766160"," 10.030"," 27.000"," 1300"," 0.000"," 15.959"," 4.433"," 0.000"," 6.618"," 1.838"," 61","0"," 2.448"," 5.123"," 1.423"," 0.000"," 0.039"," 0.011"," 45.000"," 0" + +"Total Elapsed Time (sec) = 10.030310" +"Measured RDTSC Frequency (GHz) = 2.592" + +"Cumulative Processor Energy_0 (Joules) = 15.958862" +"Cumulative Processor Energy_0 (mWh) = 4.433017" +"Average Processor Power_0 (Watt) = 1.591064" + +"Cumulative IA Energy_0 (Joules) = 6.618042" +"Cumulative IA Energy_0 (mWh) = 1.838345" +"Average IA Power_0 (Watt) = 0.659804" + +"Cumulative DRAM Energy_0 (Joules) = 5.122925" +"Cumulative DRAM Energy_0 (mWh) = 1.423035" +"Average DRAM Power_0 (Watt) = 0.510744" + +"Cumulative GT Energy_0 (Joules) = 0.039490" +"Cumulative GT Energy_0 (mWh) = 0.010969" +"Average GT Power_0 (Watt) = 0.003937" diff --git a/testing/mozbase/mozpower/tests/files/valueerrorfile.txt b/testing/mozbase/mozpower/tests/files/valueerrorfile.txt new file mode 100644 index 0000000000..8f2d3485eb --- /dev/null +++ b/testing/mozbase/mozpower/tests/files/valueerrorfile.txt @@ -0,0 +1,30 @@ +"System Time","RDTSC","Elapsed Time (sec)","CPU Utilization(%)","CPU Frequency_0(MHz)","Processor Power_0(Watt)","Cumulative Processor Energy_0(Joules)","Cumulative Processor Energy_0(mWh)","IA Power_0(Watt)","Cumulative IA Energy_0(Joules)","Cumulative IA Energy_0(mWh)","Package Temperature_0(C)","Package Hot_0","DRAM Power_0(Watt)","Cumulative DRAM Energy_0(Joules)","Cumulative DRAM Energy_0(mWh)","GT Power_0(Watt)","Cumulative GT Energy_0(Joules)","Cumulative GT Energy_0(mWh)","Package Power Limit_0(Watt)","GT Frequency(MHz)" +"12:11:05:769","61075218263548"," 2.002"," 14.000"," 3400"," 23.427"," 23.460"," 6.517"," 21.019"," 21.048"," 5.847"," 75","0"," 0.877"," 0.878"," 0.244"," 0.020"," 0.020"," 0.006"," 45.000"," 0" +"12:11:06:774","61077822279584"," 3.007"," 20.000"," 3000"," 25.014"," 48.590"," 13.497"," 22.386"," 43.538"," 12.094"," 74","0"," 1.194"," 2.078"," 0.577"," 0.029"," 0.049"," 0.014"," 45.000"," 0" +"12:11:07:778","61080424421708"," 4.011"," 8.000"," 1300"," 9.512"," 58.140"," 16.150"," 6.904"," 50.469"," 14.019"," 65","0"," 0.836"," 2.917"," 0.810"," 0.007"," 0.057"," 0.016"," 45.000"," 0" +"12:11:08:781","61083023535972"," 5.013"," 1.000"," 1300"," 1.786"," 59.931"," 16.647"," 0.687"," 51.158"," 14.210"," 63","0"," 0.585"," 3.504"," 0.973"," 0.000"," 0.057"," 0.016"," 45.000"," 0" +"12:11:09:784","61085623402302"," none"," 4.000"," 4000"," 5.249"," 65.195"," 18.110"," 3.743"," 54.912"," 15.253"," 75","0"," 0.660"," 4.166"," 1.157"," 0.003"," 0.059"," 0.017"," 45.000"," 0" +"12:11:10:787","61088224087008"," 7.020"," 20.000"," 3000"," 35.118"," 100.432"," 27.898"," 31.647"," 86.666"," 24.074"," 72","0"," 1.048"," 5.218"," 1.449"," 0.016"," 0.076"," 0.021"," 45.000"," 0" +"12:11:11:791","61090825821126"," 8.024"," 13.000"," 3000"," 25.436"," 125.965"," 34.990"," 22.228"," 108.979"," 30.272"," 71","0"," 0.868"," 6.089"," 1.691"," 0.004"," 0.080"," 0.022"," 45.000"," 0" +"12:11:12:795","61093429020836"," 9.028"," 5.000"," 1300"," 5.266"," 131.253"," 36.459"," 3.270"," 112.263"," 31.184"," 64","0"," 0.711"," 6.802"," 1.890"," 0.000"," 0.080"," 0.022"," 45.000"," 0" +"12:11:13:796","61096024160928"," 10.029"," 5.000"," 4000"," 11.070"," 142.338"," 39.538"," 9.613"," 121.888"," 33.858"," 78","0"," 0.650"," 7.453"," 2.070"," 0.000"," 0.080"," 0.022"," 45.000"," 0" +"12:11:13:796","61096024279264"," 10.029"," 57.000"," 4000"," 0.000"," 142.338"," 39.538"," 0.000"," 121.888"," 33.858"," 78","0"," 0.000"," 7.453"," 2.070"," 0.000"," 0.080"," 0.022"," 45.000"," 0" + +"Total Elapsed Time (sec) = 10.029232" +"Measured RDTSC Frequency (GHz) = 2.592" + +"Cumulative Processor Energy_0 (Joules) = 142.337524" +"Cumulative Processor Energy_0 (mWh) = 39.538201" +"Average Processor Power_0 (Watt) = 14.192265" + +"Cumulative IA Energy_0 (Joules) = 121.888000" +"Cumulative IA Energy_0 (mWh) = 33.857778" +"Average IA Power_0 (Watt) = 12.153273" + +"Cumulative DRAM Energy_0 (Joules) = 7.453308" +"Cumulative DRAM Energy_0 (mWh) = 2.070363" +"Average DRAM Power_0 (Watt) = 0.743158" + +"Cumulative GT Energy_0 (Joules) = 0.079834" +"Cumulative GT Energy_0 (mWh) = 0.022176" +"Average GT Power_0 (Watt) = 0.007960" diff --git a/testing/mozbase/mozpower/tests/manifest.ini b/testing/mozbase/mozpower/tests/manifest.ini new file mode 100644 index 0000000000..2e825e2fa5 --- /dev/null +++ b/testing/mozbase/mozpower/tests/manifest.ini @@ -0,0 +1,6 @@ +[DEFAULT] +subsuite = mozbase +[test_powerbase.py] +[test_intelpowergadget.py] +[test_macintelpower.py] +[test_mozpower.py] diff --git a/testing/mozbase/mozpower/tests/test_intelpowergadget.py b/testing/mozbase/mozpower/tests/test_intelpowergadget.py new file mode 100644 index 0000000000..9be01cb720 --- /dev/null +++ b/testing/mozbase/mozpower/tests/test_intelpowergadget.py @@ -0,0 +1,348 @@ +#!/usr/bin/env python + +import datetime +import os +import time +from unittest import mock + +import mozunit +import pytest +import six +from mozpower.intel_power_gadget import ( + IPGEmptyFileError, + IPGMissingOutputFileError, + IPGTimeoutError, + IPGUnknownValueTypeError, +) + + +def thread_is_alive(thread): + if six.PY2: + return thread.isAlive() + return thread.is_alive() + + +def test_ipg_pathsplitting(ipg_obj): + """Tests that the output file path and prefix was properly split. + This test assumes that it is in the same directory as the conftest.py file. + """ + assert ( + ipg_obj.output_dir_path == os.path.abspath(os.path.dirname(__file__)) + "/files" + ) + assert ipg_obj.output_file_prefix == "raptor-tp6-amazon-firefox_powerlog" + + +def test_ipg_get_output_file_path(ipg_obj): + """Tests that the output file path is constantly changing + based on the file_counter value. + """ + test_path = "/test_path/" + test_ext = ".txt" + ipg_obj._file_counter = 1 + ipg_obj._output_dir_path = test_path + ipg_obj._output_file_ext = test_ext + + for i in range(1, 6): + fpath = ipg_obj._get_output_file_path() + + assert fpath.startswith(test_path) + assert fpath.endswith(test_ext) + assert str(i) in fpath + + +def test_ipg_start_and_stop(ipg_obj): + """Tests that the IPG thread can start and stop properly.""" + + def subprocess_side_effect(*args, **kwargs): + time.sleep(1) + + with mock.patch("subprocess.check_output") as m: + m.side_effect = subprocess_side_effect + + # Start recording IPG measurements + ipg_obj.start_ipg() + assert not ipg_obj._stop + + # Wait a bit for thread to start, then check it + timeout = 10 + start = time.time() + while time.time() - start < timeout and not ipg_obj._running: + time.sleep(1) + + assert ipg_obj._running + assert thread_is_alive(ipg_obj._thread) + + # Stop recording IPG measurements + ipg_obj.stop_ipg(wait_interval=1, timeout=30) + assert ipg_obj._stop + assert not ipg_obj._running + + +def test_ipg_stopping_timeout(ipg_obj): + """Tests that an IPGTimeoutError is raised when + the thread is still "running" and the wait in _wait_for_ipg + has exceeded the timeout value. + """ + with pytest.raises(IPGTimeoutError): + ipg_obj._running = True + ipg_obj._wait_for_ipg(wait_interval=1, timeout=2) + + +def test_ipg_rh_combine_cumulatives(ipg_rh_obj): + """Tests that cumulatives are correctly combined in + the _combine_cumulative_rows function. + """ + cumulatives_to_combine = [ + [0, 1, 2, 3, 4, 5], + [0, 1, 2, 3, 4, 5], + [0, 1, 2, 3, 4, 5], + [0, 1, 2, 3, 4, 5], + ] + + combined_cumulatives = ipg_rh_obj._combine_cumulative_rows(cumulatives_to_combine) + + # Check that accumulation worked, final value must be the maximum + assert combined_cumulatives[-1] == max(combined_cumulatives) + + # Check that the cumulative values are monotonically increasing + for count, val in enumerate(combined_cumulatives[:-1]): + assert combined_cumulatives[count + 1] - val >= 0 + + +def test_ipg_rh_clean_file(ipg_rh_obj): + """Tests that IPGResultsHandler correctly cleans the data + from one file. + """ + file = ipg_rh_obj._output_files[0] + linecount = 0 + with open(file, "r") as f: + for line in f: + linecount += 1 + + results, summary, clean_file = ipg_rh_obj._clean_ipg_file(file) + + # Check that each measure from the csv header + # is in the results dict and that the clean file output + # exists. + for measure in results: + assert measure in ipg_rh_obj._csv_header + assert os.path.exists(clean_file) + + clean_rows = [] + with open(clean_file, "r") as f: + for line in f: + if line.strip(): + clean_rows.append(line) + + # Make sure that the results and summary entries + # have the expected lengths. + for measure in results: + # Add 6 for new lines that were removed + assert len(results[measure]) + len(summary) + 6 == linecount + # Subtract 1 for the csv header + assert len(results[measure]) == len(clean_rows) - 1 + + +def test_ipg_rh_clean_ipg_data_no_files(ipg_rh_obj): + """Tests that IPGResultsHandler correctly handles the case + when no output files exist. + """ + ipg_rh_obj._output_files = [] + clean_data = ipg_rh_obj.clean_ipg_data() + assert clean_data is None + + +def test_ipg_rh_clean_ipg_data(ipg_rh_obj): + """Tests that IPGResultsHandler correctly handles cleaning + all known files and that the results and the merged output + are correct. + """ + clean_data = ipg_rh_obj.clean_ipg_data() + clean_files = ipg_rh_obj.cleaned_files + merged_output_path = ipg_rh_obj.merged_output_path + + # Check that the expected output exists + assert clean_data is not None + assert len(clean_files) == len(ipg_rh_obj._output_files) + assert os.path.exists(merged_output_path) + + # Check that the merged file length and results length + # is correct, and that no lines were lost and no extra lines + # were added. + expected_merged_line_count = 0 + for file in clean_files: + with open(file, "r") as f: + for count, line in enumerate(f): + if count == 0: + continue + if line.strip(): + expected_merged_line_count += 1 + + merged_line_count = 0 + with open(merged_output_path, "r") as f: + for count, line in enumerate(f): + if count == 0: + continue + if line.strip(): + merged_line_count += 1 + + assert merged_line_count == expected_merged_line_count + for measure in clean_data: + assert len(clean_data[measure]) == merged_line_count + + # Check that the clean data rows are ordered in increasing time + times_in_seconds = [] + for sys_time in clean_data["System Time"]: + split_sys_time = sys_time.split(":") + hour_min_sec = ":".join(split_sys_time[:-1]) + millis = float(split_sys_time[-1]) / 1000 + + timestruct = time.strptime(hour_min_sec, "%H:%M:%S") + times_in_seconds.append( + datetime.timedelta( + hours=timestruct.tm_hour, + minutes=timestruct.tm_min, + seconds=timestruct.tm_sec, + ).total_seconds() + + millis + ) + + for count, val in enumerate(times_in_seconds[:-1]): + assert times_in_seconds[count + 1] - val >= 0 + + +def test_ipg_rh_format_to_perfherder_with_no_results(ipg_rh_obj): + """Tests that formatting the data to a perfherder-like format + fails when clean_ipg_data was not called beforehand. + """ + formatted_data = ipg_rh_obj.format_ipg_data_to_partial_perfherder( + 1000, ipg_rh_obj._output_file_prefix + ) + assert formatted_data is None + + +def test_ipg_rh_format_to_perfherder_without_cutoff(ipg_rh_obj): + """Tests that formatting the data to a perfherder-like format + works as expected. + """ + ipg_rh_obj.clean_ipg_data() + formatted_data = ipg_rh_obj.format_ipg_data_to_partial_perfherder( + 1000, ipg_rh_obj._output_file_prefix + ) + + # Check that the expected entries exist + assert len(formatted_data.keys()) == 5 + assert "utilization" in formatted_data and "power-usage" in formatted_data + + assert ( + formatted_data["power-usage"]["test"] + == ipg_rh_obj._output_file_prefix + "-cumulative" + ) + assert ( + formatted_data["utilization"]["test"] + == ipg_rh_obj._output_file_prefix + "-utilization" + ) + assert ( + formatted_data["frequency-gpu"]["test"] + == ipg_rh_obj._output_file_prefix + "-frequency-gpu" + ) + assert ( + formatted_data["frequency-cpu"]["test"] + == ipg_rh_obj._output_file_prefix + "-frequency-cpu" + ) + assert ( + formatted_data["power-watts"]["test"] + == ipg_rh_obj._output_file_prefix + "-watts" + ) + + for measure in formatted_data: + # Make sure that the data exists + assert len(formatted_data[measure]["values"]) >= 1 + + for valkey in formatted_data[measure]["values"]: + # Make sure the names were simplified + assert "(" not in valkey + assert ")" not in valkey + + # Check that gpu utilization doesn't exist but cpu does + utilization_vals = formatted_data["utilization"]["values"] + assert "cpu" in utilization_vals + assert "gpu" not in utilization_vals + + expected_fields = ["processor-cores", "processor-package", "gpu", "dram"] + consumption_vals = formatted_data["power-usage"]["values"] + + consumption_vals_measures = list(consumption_vals.keys()) + + # This assertion ensures that the consumption values contain the expected + # fields and nothing more. + assert not list(set(consumption_vals_measures) - set(expected_fields)) + + +def test_ipg_rh_format_to_perfherder_with_cutoff(ipg_rh_obj): + """Tests that formatting the data to a perfherder-like format + works as expected. + """ + ipg_rh_obj.clean_ipg_data() + formatted_data = ipg_rh_obj.format_ipg_data_to_partial_perfherder( + 2.5, ipg_rh_obj._output_file_prefix + ) + + # Check that the formatted data was cutoff at the correct point, + # expecting that only the first row of merged will exist. + utilization_vals = formatted_data["utilization"]["values"] + assert utilization_vals["cpu"] == 14 + + # Expected vals are ordered in this way: [processor, cores, dram, gpu] + expected_vals = [6.517, 5.847, 0.244, 0.006] + consumption_vals = [ + formatted_data["power-usage"]["values"][measure] + for measure in formatted_data["power-usage"]["values"] + ] + assert not list(set(expected_vals) - set(consumption_vals)) + + +def test_ipg_rh_missingoutputfile(ipg_rh_obj): + """Tests that the IPGMissingOutputFileError is raised + when a bad file path is passed to _clean_ipg_file. + """ + bad_files = ["non-existent-file"] + with pytest.raises(IPGMissingOutputFileError): + ipg_rh_obj._clean_ipg_file(bad_files[0]) + + ipg_rh_obj._output_files = bad_files + with pytest.raises(IPGMissingOutputFileError): + ipg_rh_obj.clean_ipg_data() + + +def test_ipg_rh_emptyfile(ipg_rh_obj): + """Tests that the empty file error is raised when + a file exists, but does not contain any results in + it. + """ + base_path = os.path.abspath(os.path.dirname(__file__)) + "/files/" + bad_files = [base_path + "emptyfile.txt"] + with pytest.raises(IPGEmptyFileError): + ipg_rh_obj._clean_ipg_file(bad_files[0]) + + ipg_rh_obj._output_files = bad_files + with pytest.raises(IPGEmptyFileError): + ipg_rh_obj.clean_ipg_data() + + +def test_ipg_rh_valuetypeerrorfile(ipg_rh_obj): + """Tests that the IPGUnknownValueTypeError is raised + when a bad entry is encountered in a file that is cleaned. + """ + base_path = os.path.abspath(os.path.dirname(__file__)) + "/files/" + bad_files = [base_path + "valueerrorfile.txt"] + with pytest.raises(IPGUnknownValueTypeError): + ipg_rh_obj._clean_ipg_file(bad_files[0]) + + ipg_rh_obj._output_files = bad_files + with pytest.raises(IPGUnknownValueTypeError): + ipg_rh_obj.clean_ipg_data() + + +if __name__ == "__main__": + mozunit.main() diff --git a/testing/mozbase/mozpower/tests/test_macintelpower.py b/testing/mozbase/mozpower/tests/test_macintelpower.py new file mode 100644 index 0000000000..2332c94c3e --- /dev/null +++ b/testing/mozbase/mozpower/tests/test_macintelpower.py @@ -0,0 +1,76 @@ +#!/usr/bin/env python + +import time +from unittest import mock + +import mozunit + + +def test_macintelpower_init(macintelpower_obj): + """Tests that the MacIntelPower object is correctly initialized.""" + assert macintelpower_obj.ipg_path + assert macintelpower_obj.ipg + assert macintelpower_obj._os == "darwin" + assert macintelpower_obj._cpu == "intel" + + +def test_macintelpower_measuring(macintelpower_obj): + """Tests that measurement initialization and finalization works + for the MacIntelPower object. + """ + assert not macintelpower_obj.start_time + assert not macintelpower_obj.ipg._running + assert not macintelpower_obj.ipg._output_files + macintelpower_obj.initialize_power_measurements() + + # Check that initialization set start_time, and started the + # IPG measurer thread. + + # Wait a bit for thread to start, then check it + timeout = 10 + start = time.time() + while time.time() - start < timeout and not macintelpower_obj.ipg._running: + time.sleep(1) + + assert macintelpower_obj.start_time + assert macintelpower_obj.ipg._running + + test_data = {"power-usage": "data"} + + def formatter_side_effect(*args, **kwargs): + return test_data + + with mock.patch( + "mozpower.intel_power_gadget.IPGResultsHandler.clean_ipg_data" + ) as _: + with mock.patch( + "mozpower.intel_power_gadget.IPGResultsHandler." + "format_ipg_data_to_partial_perfherder" + ) as formatter: + formatter.side_effect = formatter_side_effect + + macintelpower_obj.finalize_power_measurements(wait_interval=2, timeout=30) + + # Check that finalization set the end_time, stopped the IPG measurement + # thread, added atleast one output file name, and initialized + # an IPGResultsHandler object + assert macintelpower_obj.end_time + assert not macintelpower_obj.ipg._running + assert macintelpower_obj.ipg._output_files + assert macintelpower_obj.ipg_results_handler + + # Check that the IPGResultHandler's methods were + # called + macintelpower_obj.ipg_results_handler.clean_ipg_data.assert_called() + macintelpower_obj.ipg_results_handler.format_ipg_data_to_partial_perfherder.assert_called_once_with( # NOQA: E501 + macintelpower_obj.end_time - macintelpower_obj.start_time, + "power-testing", + ) + + # Make sure we can get the expected perfherder data + # after formatting + assert macintelpower_obj.get_perfherder_data() == test_data + + +if __name__ == "__main__": + mozunit.main() diff --git a/testing/mozbase/mozpower/tests/test_mozpower.py b/testing/mozbase/mozpower/tests/test_mozpower.py new file mode 100644 index 0000000000..fd513e836b --- /dev/null +++ b/testing/mozbase/mozpower/tests/test_mozpower.py @@ -0,0 +1,255 @@ +#!/usr/bin/env python + +import subprocess +import sys +from unittest import mock + +import mozunit +import pytest +from mozpower import MozPower +from mozpower.mozpower import MissingProcessorInfoError, OsCpuComboMissingError + + +def test_mozpower_android_init_failure(): + """Tests that the MozPower object fails when the android + flag is set. Remove this test once android is implemented. + """ + with pytest.raises(NotImplementedError): + MozPower(android=True) + + +def test_mozpower_oscpu_combo_missing_error(): + """Tests that the error OsCpuComboMissingError is raised + when we can't find a OS, and CPU combination (and, therefore, cannot + find a power measurer). + """ + with mock.patch.object( + MozPower, "_get_os", return_value="Not-An-OS" + ) as _, mock.patch.object( + MozPower, "_get_processor_info", return_value="Not-A-Processor" + ) as _: + with pytest.raises(OsCpuComboMissingError): + MozPower() + + +def test_mozpower_processor_info_missing_error(): + """Tests that the error MissingProcessorInfoError is raised + when failures occur during processor information parsing. + """ + # The builtins module name differs between python 2 and 3 + builtins_name = "__builtin__" + if sys.version_info[0] == 3: + builtins_name = "builtins" + + def os_side_effect_true(*args, **kwargs): + """Used as a passing side effect for os.path.exists calls.""" + return True + + def os_side_effect_false(*args, **kwargs): + """Used as a failing side effect for os.path.exists calls.""" + return False + + def subprocess_side_effect_fail(*args, **kwargs): + """Used to mock a failure in subprocess.check_output calls.""" + raise subprocess.CalledProcessError(1, "Testing failure") + + # Test failures in macos processor information parsing + with mock.patch.object(MozPower, "_get_os", return_value="Darwin") as _: + + with mock.patch("os.path.exists") as os_mock: + os_mock.side_effect = os_side_effect_false + + # Check that we fail properly if the processor + # information file doesn't exist. + with pytest.raises(MissingProcessorInfoError): + MozPower() + + # Check that we fail properly when an error occurs + # in the subprocess call. + os_mock.side_effect = os_side_effect_true + with mock.patch("subprocess.check_output") as subprocess_mock: + subprocess_mock.side_effect = subprocess_side_effect_fail + with pytest.raises(MissingProcessorInfoError): + MozPower() + + # Test failures in linux processor information parsing + with mock.patch.object(MozPower, "_get_os", return_value="Linux") as _: + + with mock.patch("os.path.exists") as os_mock: + os_mock.side_effect = os_side_effect_false + + # Check that we fail properly if the processor + # information file doesn't exist. + with pytest.raises(MissingProcessorInfoError): + MozPower() + + # Check that we fail properly when the model cannot be found + # with by searching for 'model name'. + os_mock.side_effect = os_side_effect_true + with mock.patch( + "%s.open" % builtins_name, mock.mock_open(read_data="") + ) as _: + with pytest.raises(MissingProcessorInfoError): + MozPower() + + +def test_mozpower_oscpu_combo(mozpower_obj): + """Tests that the correct class is instantiated for a given + OS and CPU combination (MacIntelPower in this case). + """ + assert mozpower_obj.measurer.__class__.__name__ == "MacIntelPower" + assert ( + mozpower_obj.measurer._os == "darwin" and mozpower_obj.measurer._cpu == "intel" + ) + + +def test_mozpower_measuring(mozpower_obj): + """Tests that measurers are properly called with each method.""" + with mock.patch( + "mozpower.macintelpower.MacIntelPower.initialize_power_measurements" + ) as _, mock.patch( + "mozpower.macintelpower.MacIntelPower.finalize_power_measurements" + ) as _, mock.patch( + "mozpower.macintelpower.MacIntelPower.get_perfherder_data" + ) as _: + mozpower_obj.initialize_power_measurements() + mozpower_obj.measurer.initialize_power_measurements.assert_called() + + mozpower_obj.finalize_power_measurements() + mozpower_obj.measurer.finalize_power_measurements.assert_called() + + mozpower_obj.get_perfherder_data() + mozpower_obj.measurer.get_perfherder_data.assert_called() + + +def test_mozpower_measuring_with_no_measurer(mozpower_obj): + """Tests that no errors occur when the measurer is None, and the + initialize, finalize, and get_perfherder_data functions are called. + """ + with mock.patch( + "mozpower.macintelpower.MacIntelPower.initialize_power_measurements" + ) as _, mock.patch( + "mozpower.macintelpower.MacIntelPower.finalize_power_measurements" + ) as _, mock.patch( + "mozpower.macintelpower.MacIntelPower.get_perfherder_data" + ) as _: + measurer = mozpower_obj.measurer + mozpower_obj.measurer = None + + mozpower_obj.initialize_power_measurements() + assert not measurer.initialize_power_measurements.called + + mozpower_obj.finalize_power_measurements() + assert not measurer.finalize_power_measurements.called + + mozpower_obj.get_perfherder_data() + assert not measurer.get_perfherder_data.called + + mozpower_obj.get_full_perfherder_data("mozpower") + assert not measurer.get_perfherder_data.called + + +def test_mozpower_get_full_perfherder_data(mozpower_obj): + """Tests that the full perfherder data blob is properly + produced given a partial perfherder data blob with correct + entries. + """ + partial_perfherder = { + "utilization": { + "type": "power", + "test": "mozpower", + "unit": "%", + "values": {"cpu": 50, "gpu": 0}, + }, + "power-usage": { + "type": "power", + "test": "mozpower", + "unit": "mWh", + "values": {"cpu": 2.0, "dram": 0.1, "gpu": 4.0}, + }, + "frequency-cpu": { + "type": "power", + "test": "mozpower", + "unit": "MHz", + "values": { + "cpu-favg": 2.0, + "cpu-fmax": 5.0, + "cpu-fmin": 0.0, + }, + }, + "frequency-gpu": { + "type": "power", + "test": "mozpower", + "unit": "MHz", + "values": {"gpu-favg": 3.0, "gpu-fmax": 6.0, "gpu-fmin": 0.0}, + }, + } + utilization_vals = [0, 50] + power_usage_vals = [2.0, 0.1, 4.0] + frequency_cpu_vals = [2.0, 5.0, 0.0] + frequency_gpu_vals = [3.0, 6.0, 0.0] + + with mock.patch("mozpower.macintelpower.MacIntelPower.get_perfherder_data") as gpd: + gpd.return_value = partial_perfherder + + full_perfherder = mozpower_obj.get_full_perfherder_data("mozpower") + assert full_perfherder["framework"]["name"] == "mozpower" + assert len(full_perfherder["suites"]) == 4 + + # Check that each of the two suites were created correctly. + suites = full_perfherder["suites"] + for suite in suites: + assert "subtests" in suite + + assert suite["type"] == "power" + assert suite["alertThreshold"] == 2.0 + assert suite["lowerIsBetter"] + + all_vals = [] + for subtest in suite["subtests"]: + assert "value" in subtest + + # Check that the subtest names were created correctly + if "utilization" in suite["name"]: + assert "utilization" in subtest["name"] + elif "power-usage" in suite["name"]: + assert "power-usage" in subtest["name"] + elif "frequency-cpu" in suite["name"]: + assert "frequency-cpu" in subtest["name"] + elif "frequency-gpu" in suite["name"]: + assert "frequency-gpu" in subtest["name"] + else: + assert False, "Unknown subtest name %s" % subtest["name"] + + all_vals.append(subtest["value"]) + + if "utilization" in suite["name"]: + assert len(all_vals) == 2 + assert suite["unit"] == "%" + assert suite["name"] == "mozpower-utilization" + assert not list(set(all_vals) - set(utilization_vals)) + assert suite["value"] == float(25) + elif "power-usage" in suite["name"]: + assert len(all_vals) == 3 + assert suite["unit"] == "mWh" + assert suite["name"] == "mozpower-power-usage" + assert not list(set(all_vals) - set(power_usage_vals)) + assert suite["value"] == float(6.1) + elif "frequency-cpu" in suite["name"]: + assert len(all_vals) == 3 + assert suite["unit"] == "MHz" + assert suite["name"] == "mozpower-frequency-cpu" + assert not list(set(all_vals) - set(frequency_cpu_vals)) + assert suite["value"] == float(2.0) + elif "frequency-gpu" in suite["name"]: + assert len(all_vals) == 3 + assert suite["unit"] == "MHz" + assert suite["name"] == "mozpower-frequency-gpu" + assert not list(set(all_vals) - set(frequency_gpu_vals)) + assert suite["value"] == float(3.0) + else: + assert False, "Unknown suite name %s" % suite["name"] + + +if __name__ == "__main__": + mozunit.main() diff --git a/testing/mozbase/mozpower/tests/test_powerbase.py b/testing/mozbase/mozpower/tests/test_powerbase.py new file mode 100644 index 0000000000..46de941457 --- /dev/null +++ b/testing/mozbase/mozpower/tests/test_powerbase.py @@ -0,0 +1,91 @@ +#!/usr/bin/env python + +from unittest import mock + +import mozunit +import pytest +from mozpower.powerbase import ( + IPGExecutableMissingError, + PlatformUnsupportedError, + PowerBase, +) + + +def test_powerbase_intialization(): + """Tests that the PowerBase class correctly raises + a NotImplementedError when attempting to instantiate + it directly. + """ + with pytest.raises(NotImplementedError): + PowerBase() + + +def test_powerbase_missing_methods(powermeasurer): + """Tests that trying to call PowerBase methods + without an implementation in the subclass raises + the NotImplementedError. + """ + with pytest.raises(NotImplementedError): + powermeasurer.initialize_power_measurements() + + with pytest.raises(NotImplementedError): + powermeasurer.finalize_power_measurements() + + with pytest.raises(NotImplementedError): + powermeasurer.get_perfherder_data() + + +def test_powerbase_get_ipg_path_mac(powermeasurer): + """Tests that getting the IPG path returns the expected results.""" + powermeasurer._os = "darwin" + powermeasurer._cpu = "not-intel" + + def os_side_effect(arg): + """Used to get around the os.path.exists check in + get_ipg_path which raises an IPGExecutableMissingError + otherwise. + """ + return True + + with mock.patch("os.path.exists", return_value=True) as m: + m.side_effect = os_side_effect + + # None is returned when a non-intel based machine is + # tested. + ipg_path = powermeasurer.get_ipg_path() + assert ipg_path is None + + # Check the path returned for mac intel-based machines. + powermeasurer._cpu = "intel" + ipg_path = powermeasurer.get_ipg_path() + assert ipg_path == "/Applications/Intel Power Gadget/PowerLog" + + +def test_powerbase_get_ipg_path_errors(powermeasurer): + """Tests that the appropriate error is output when calling + get_ipg_path with invalid/unsupported _os and _cpu entries. + """ + + powermeasurer._cpu = "intel" + powermeasurer._os = "Not-An-OS" + + def os_side_effect(arg): + """Used to force the error IPGExecutableMissingError to occur + (in case a machine running these tests is a mac, and has intel + power gadget installed). + """ + return False + + with pytest.raises(PlatformUnsupportedError): + powermeasurer.get_ipg_path() + + with mock.patch("os.path.exists", return_value=False) as m: + m.side_effect = os_side_effect + + powermeasurer._os = "darwin" + with pytest.raises(IPGExecutableMissingError): + powermeasurer.get_ipg_path() + + +if __name__ == "__main__": + mozunit.main() -- cgit v1.2.3