def test_send_report_in_special_order_receive_right_pair( procfs_timeline, power_timeline): timedet = datetime.timedelta(250) sync = Sync(lambda x: isinstance(x, PowerReport), lambda x: isinstance(x, ProcfsReport), timedet) sum = 0 r = power_timeline[0] sync.add_report(PowerReport.from_json(r)) r = power_timeline[1] sync.add_report(PowerReport.from_json(r)) for i in range(len(power_timeline) - 2): r = power_timeline[i + 2] sync.add_report(PowerReport.from_json(r)) r = procfs_timeline[i] sync.add_report(ProcfsReport.from_json(r)) r = sync.request() assert r is not None report1, report2 = r assert abs(report1.timestamp - report2.timestamp) <= timedet sum += 1 r = procfs_timeline[-2] sync.add_report(ProcfsReport.from_json(r)) r = procfs_timeline[-1] sync.add_report(ProcfsReport.from_json(r)) assert sum == len(power_timeline) - 2
def test_handle_hwpc_report_with_two_rapl_event_and_other_groups(state): """ handle a HWPC report with two RAPL events and events from other groups The HWPC report contain two RAPL events and events from a group 'sys' with two cores The handle method must return two PowerReport containing each RAPL event """ socket_id = '1' raw_power_1 = 10 rapl_event_id_1 = 'RAPL_1' raw_power_2 = 20 rapl_event_id_2 = 'RAPL_2' events = {rapl_event_id_1: raw_power_1, rapl_event_id_2: raw_power_2} hwpc_report = create_report_root([ create_group_report('rapl', [ create_socket_report( socket_id, [create_core_report('1', None, None, events=events)]) ]), create_group_report('sys', [ create_socket_report(socket_id, [ create_core_report('1', 'e0', 0), create_core_report('2', 'e0', 0) ]) ]) ]) validation_report_1 = PowerReport(hwpc_report.timestamp, hwpc_report.sensor, hwpc_report.target, math.ldexp(raw_power_1, -32), { 'socket': socket_id, 'event': rapl_event_id_1 }) validation_report_2 = PowerReport(hwpc_report.timestamp, hwpc_report.sensor, hwpc_report.target, math.ldexp(raw_power_2, -32), { 'socket': socket_id, 'event': rapl_event_id_2 }) result = RAPLFormulaHWPCReportHandler(get_fake_pusher())._process_report( hwpc_report, state) assert len(result) == 2 assert validation_report_1 in result assert validation_report_2 in result
def gen_power_report(): global CPT CPT += 1 return PowerReport(CPT, "sensor", "target", 0, 0.11, { "metadata1": "truc", "metadata2": "oui" })
def power_report(): return PowerReport(timestamp_to_datetime(1), SENSOR_NAME, TARGET_NAME, 0.11, { 'socket': 1, 'metadata1': 'azerty', 'metadata2': 'qwerty' })
def gen_power_report(): global CPT CPT += 1 return PowerReport(timestamp_to_datetime(CPT), SENSOR, TARGET, -1, 0.11, { "metadata1": "truc", "metadata2": "oui" })
def test_handle_hwpc_report_with_one_rapl_event(state): """ handle a HWPC report with a simple RAPL event The HWPC report contain only one RAPL event and no other groups The handle method must return a PowerReport containing only the RAPL event """ raw_power = 10 socket_id = '1' rapl_event_id = 'RAPL_1' hwpc_report = create_report_root([ create_group_report('rapl', [ create_socket_report( socket_id, [create_core_report('1', rapl_event_id, raw_power)]) ]) ]) validation_report = PowerReport(hwpc_report.timestamp, hwpc_report.sensor, hwpc_report.target, math.ldexp(raw_power, -32), { 'socket': socket_id, 'event': rapl_event_id }) result = RAPLHandler(state)._estimate(hwpc_report) assert [validation_report] == result
def _estimate(self, report): """ Method that estimate the power consumption from an input report :param report: Input Report :return: List of PowerReport """ result_msg = PowerReport(report.timestamp, report.sensor, report.target, {}, 42) return [result_msg]
def test_handle_hwpc_report_with_two_rapl_event(state): """ handle a HWPC report with two RAPL events The HWPC report contain only two RAPL events and no other groups The handle method must return two PowerReport containing each RAPL event """ socket_id = '1' raw_power_1 = 10 rapl_event_id_1 = 'RAPL_1' raw_power_2 = 20 rapl_event_id_2 = 'RAPL_2' events = {rapl_event_id_1: raw_power_1, rapl_event_id_2: raw_power_2} hwpc_report = create_report_root([ create_group_report('rapl', [ create_socket_report( socket_id, [create_core_report('1', None, None, events=events)]) ]) ]) validation_report_1 = PowerReport(hwpc_report.timestamp, hwpc_report.sensor, hwpc_report.target, math.ldexp(raw_power_1, -32), { 'socket': socket_id, 'event': rapl_event_id_1 }) validation_report_2 = PowerReport(hwpc_report.timestamp, hwpc_report.sensor, hwpc_report.target, math.ldexp(raw_power_2, -32), { 'socket': socket_id, 'event': rapl_event_id_2 }) result = RAPLHandler(state)._estimate(hwpc_report) assert len(result) == 2 assert validation_report_1 in result assert validation_report_2 in result
def _estimate(self, report): """ Method that estimate the power consumption from an input report :param report: Input Report :return: List of PowerReport """ metadata = {'formula_name': self.state.actor.name} result_msg = PowerReport(report.timestamp, report.sensor, report.target, 42, metadata) return [result_msg]
def receiveMsg_Report(self, message: Report, sender: ActorAddress): print((self.name, message)) if message.timestamp == datetime.strptime("2021-07-12T11:33:16.521", "%Y-%m-%dT%H:%M:%S.%f"): raise Exception() time.sleep(self.sleeping_time) power_report = PowerReport(message.timestamp, message.sensor, message.target, 42, {'socket': self.socket}) for _, pusher in self.pushers.items(): self.send(pusher, power_report)
def test_create_power_report_from_csv_with_one_lines_create_an_power_report(): csv_lines = [("power", { "timestamp": "2021-09-14T12:37:37.168817", "sensor": "formula_group", "target": "all", "power": 42 } ) ] report = PowerReport.from_csv_lines(csv_lines) assert isinstance(report, PowerReport)
def test_create_power_report_from_csv_with_bad_timestamp_format_raise_BadInputData(): csv_lines = [("power", { "timestamp": '1970-09-01T090909.543', "sensor": "formula_group", "target": "all", "power": 42 } ) ] with pytest.raises(BadInputData): report = PowerReport.from_csv_lines(csv_lines)
def receiveMsg_Report(self, message: Report, _: ActorAddress): """ When receiving a report sleep for a given time and produce a power report with a power consumption of 42W """ self.log_debug('received message ' + str(message)) time.sleep(self.sleeping_time) metadata = dict(message.metadata) metadata["socket"] = self.socket power_report = PowerReport(message.timestamp, message.sensor, message.target, 42, metadata) for _, pusher in self.pushers.items(): self.send(pusher, power_report)
def _gen_power_report(report, socket, event, counter): """ Generate a power report for a RAPL event. :param report: HWPC report :param socket: Socket ID :param event: RAPL event name :param counter: RAPL event counter """ power = math.ldexp(counter, -32) metadata = {'socket': socket, 'event': event} return PowerReport(report.timestamp, report.sensor, report.target, power, metadata)
def _estimate(self, report): if self.state.nb_reports >= self.state.nb_reports_max: raise self.state.exception() self.state.nb_reports += 1 metadata = {'formula_name': self.state.actor.name} socket_id = self.state.metadata[ 'socket'] if 'socket' in self.state.metadata else -1 result_msg = PowerReport(report.timestamp, report.sensor, report.target, socket_id, 42, metadata) return [result_msg]
def test_create_report_from_csv_with_metadata(): csv_lines = [("power", { "timestamp": "2021-09-14T12:37:37.168817", "sensor": "formula_group", "target": "all", "power": 42, "tag":1 } ) ] report = PowerReport.from_csv_lines(csv_lines) assert report.metadata["tag"] == 1
def _process_report(self, report): """ Wait 1 second and return a power report containing 42 :param powerapi.Report report: Received report :return: A power report containing consumption estimation :rtype: powerapi.PowerReport """ time.sleep(1) result_msg = PowerReport(report.timestamp, report.sensor, report.target, {}, 42) return result_msg
def _gen_power_report(self, timestamp: datetime, target: str, formula: str, power: float, ratio: float) -> PowerReport: """ Generate a power report using the given parameters. :param timestamp: Timestamp of the measurements :param target: Target name :param formula: Formula identifier :param power: Power estimation :return: Power report filled with the given parameters """ metadata = { 'scope': self.state.config.scope.value, 'socket': self.state.socket, 'formula': formula, 'ratio': ratio } return PowerReport(timestamp, self.state.sensor, target, power, metadata)
def _gen_power_report(self, timestamp, target, counter): """ Generate a power report using the given parameters. :param timestamp: Timestamp of the measurements :param target: Target name :param formula: Formula identifier :param power: Power estimation :return: Power report filled with the given parameters """ metadata = { 'scope': self.config.scope.value, 'socket': self.socket, } power = ldexp(counter, -32) report = PowerReport(timestamp, self.sensor, target, power, metadata) return report
def test_create_power_report_from_csv_with_two_lines_raise_BadInputData(): csv_lines = [("power", { "timestamp": "2021-09-14T12:37:37.168817", "sensor": "formula_group", "target": "all", "power": 42 } ), ("power", { "timestamp": "2021-09-14T12:37:37.168817", "sensor": "formula_group", "target": "all", "power": 42 } ) ] with pytest.raises(BadInputData): report = PowerReport.from_csv_lines(csv_lines)
def test_handle_hwpc_report_with_one_rapl_event_and_other_groups(state): """ handle a HWPC report with a simple RAPL event and events from other groups The HWPC report contain one RAPL event and events from a group 'sys' with two cores The handle method must return a PowerReport containing only the RAPL event """ raw_power = 10 socket_id = '1' rapl_event_id = 'RAPL_1' hwpc_report = create_report_root([ create_group_report('rapl', [ create_socket_report( socket_id, [create_core_report('1', rapl_event_id, raw_power)]) ]), create_group_report('sys', [ create_socket_report(socket_id, [ create_core_report('1', 'e0', 0), create_core_report('2', 'e0', 0) ]) ]) ]) validation_report = PowerReport(hwpc_report.timestamp, hwpc_report.sensor, hwpc_report.target, math.ldexp(raw_power, -32), { 'socket': socket_id, 'event': rapl_event_id }) result = RAPLFormulaHWPCReportHandler(get_fake_pusher())._process_report( hwpc_report, state) assert [validation_report] == result
def test_pusher_power_handler(self): """ Test the PowerHandler of PusherActor """ # Define PusherState fake_database = get_fake_db() fake_socket_interface = get_fake_socket_interface() pusher_state = PusherState(Actor._initial_behaviour, fake_socket_interface, fake_database, mock.Mock()) assert pusher_state.initialized is False # Define PowerHandler power_handler = PowerHandler() # Test Random message when state is not initialized to_send = [OKMessage(), ErrorMessage("Error"), create_report_root({})] for msg in to_send: power_handler.handle(msg, pusher_state) assert pusher_state.database.method_calls == [] assert pusher_state.initialized is False pusher_state.initialized = True # Test Random message when state is initialized to_send = [OKMessage(), ErrorMessage("Error"), create_report_root({})] for msg in to_send: power_handler.handle(msg, pusher_state) assert pusher_state.database.method_calls == [] # Test with a PowerMessage for _ in range(101): power_handler.handle( PowerReport("10", "test", "test", "test", "test"), pusher_state) assert len(pusher_state.buffer) == 101
def test_create_report_from_json_with_metadata(): json_input = gen_json_power_report(1)[0] json_input["metadata"] = {} json_input["metadata"]["tag"] = 1 report = PowerReport.from_json(json_input) assert report.metadata["tag"] == 1
def test_creating_report_with_metadata(): report = PowerReport(('1970-09-01T09:09:10.543'), 'toto', 'all',42, {"tag": 1}) assert report.metadata["tag"] == 1
from powerapi.database import InfluxDB, CantConnectToInfluxDBException from powerapi.report_model import PowerModel, BadInputData from powerapi.report import PowerReport from tests.influx_utils import generate_power_report, create_empty_db from tests.influx_utils import create_non_empty_db, delete_db, get_all_reports INFLUX_URI = 'localhost' INFLUX_PORT = 8086 INFLUX_DBNAME = 'unit_test' SENSOR_NAME = 'sensor_test' TARGET_NAME = 'target_test' POWER_REPORT_0 = PowerReport(datetime.datetime.fromtimestamp(0), SENSOR_NAME, TARGET_NAME, 0, 100, {}) POWER_REPORT_1 = PowerReport(datetime.datetime.fromtimestamp(1), SENSOR_NAME, TARGET_NAME, 0, 100, {}) POWER_REPORT_2 = PowerReport(datetime.datetime.fromtimestamp(2), SENSOR_NAME, TARGET_NAME, 0, 100, {}) def bad_serialize(): return { 'measurement': 'power_consumption', 'tags': {'target': TARGET_NAME}, 'time': str(datetime.datetime.fromtimestamp(100)), 'fields': { 'power': 100 }}
def test_create_power_report_from_json_wit_str_timestamp_create_a_PowerReport(): json_input = gen_json_power_report(1)[0] report = PowerReport.from_json(json_input) assert isinstance(report, PowerReport)
def test_create_power_report_from_json_with_datetime_timestamp_format_create_a_PowerReport(): json_input = gen_json_power_report(1)[0] json_input['timestamp'] = datetime.strptime(json_input['timestamp'], "%Y-%m-%dT%H:%M:%S.%f") report = PowerReport.from_json(json_input) assert isinstance(report, PowerReport)
def gen_power_report(): return PowerReport(1, "sensor", "target", 0, 0.11, { "metadata1": "truc", "metadata2": "oui" })
def test_create_power_report_from_json_with_str_timestamp_with_bad_format_raise_BadInputData(): json_input = gen_json_power_report(1)[0] json_input['timestamp'] = '1970-09-01T090909.543' with pytest.raises(BadInputData): report = PowerReport.from_json(json_input)
def test_create_power_report_from_json_without_sensor_field_raise_BadInputData(): json_input = gen_json_power_report(1)[0] del json_input['sensor'] with pytest.raises(BadInputData): report = PowerReport.from_json(json_input)