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)
