def test_find_prev_sample(self):
# Create objects to test with
host_stats = host_cpu.HostCPUMetricCache(self.adpt, 'host_uuid')
mock_lpar_4A = mock.Mock()
mock_lpar_4A.configure_mock(id=4, name='A')
mock_lpar_4A.processor = mock.MagicMock(entitled_proc_cycles=500000)
mock_lpar_6A = mock.Mock()
mock_lpar_6A.configure_mock(id=6, name='A')
mock_lpar_6B = mock.Mock()
mock_lpar_6B.configure_mock(id=6, name='B')
mock_phyp = mock.MagicMock(sample=mock.MagicMock(
lpars=[mock_lpar_4A, mock_lpar_6A]))
mock_prev_phyp = mock.MagicMock(sample=mock.MagicMock(
lpars=[mock_lpar_4A, mock_lpar_6B]))
# Sample 6 in the current shouldn't match the previous. It has the
# same LPAR ID, but a different name. This is considered different
new_elem = self._get_sample(6, mock_phyp.sample)
prev = host_stats._find_prev_sample(new_elem,
mock_prev_phyp.sample.lpars)
self.assertIsNone(prev)
# Lpar 4 should be in the old one. Match that up.
new_elem = self._get_sample(4, mock_phyp.sample)
prev = host_stats._find_prev_sample(new_elem,
mock_prev_phyp.sample.lpars)
self.assertIsNotNone(prev)
self.assertEqual(500000, prev.processor.entitled_proc_cycles)
# Test that we get None back if there are no previous samples
prev = host_stats._find_prev_sample(new_elem, None)
self.assertIsNone(prev)
def test_delta_proc_cycles(self):
# Create objects to test with
host_stats = host_cpu.HostCPUMetricCache(self.adpt, 'host_uuid')
mock_phyp, mock_prev_phyp = self._get_mock_phyps()
# Test that a previous sample allows us to gather the delta across all
# of the VMs. This should take into account the scenario where a LPAR
# is deleted and a new one takes its place (LPAR ID 6)
delta = host_stats._delta_proc_cycles(mock_phyp.sample.lpars,
mock_prev_phyp.sample.lpars)
self.assertEqual(10010000000, delta)
# Now test as if there is no previous data. This results in 0 as they
# could have all been LPMs with months of cycles (rather than 30
# seconds delta).
delta2 = host_stats._delta_proc_cycles(mock_phyp.sample.lpars, None)
self.assertEqual(0, delta2)
self.assertNotEqual(delta2, delta)
# Test that if previous sample had 0 values, the sample is not
# considered for evaluation, and resultant delta cycles is 0.
prev_lpar_sample = mock_prev_phyp.sample.lpars[0].processor
prev_lpar_sample.util_cap_proc_cycles = 0
prev_lpar_sample.util_uncap_proc_cycles = 0
prev_lpar_sample.idle_proc_cycles = 0
delta3 = host_stats._delta_proc_cycles(mock_phyp.sample.lpars,
mock_prev_phyp.sample.lpars)
self.assertEqual(0, delta3)
def test_update_internal_metric_bad_total(self, mock_user_cycles,
mock_tot_cycles, mock_fw_cycles):
"""Validates that if the total cycles are off, we handle."""
host_stats = host_cpu.HostCPUMetricCache(self.adpt, 'host_uuid')
mock_user_cycles.return_value = 30010090000
mock_fw_cycles.return_value = 58599310268
# Mock the total cycles to some really low number.
mock_tot_cycles.return_value = 5
# Create mock phyp objects to test with
mock_phyp = mock.MagicMock()
mock_prev_phyp = mock.MagicMock()
mock_phyp.sample.system_firmware.utilized_proc_cycles = 58599310268
# Run the actual test - 'increment' it with a new current/previous
host_stats.cur_phyp = mock_phyp
host_stats.prev_phyp = mock_prev_phyp
host_stats._update_internal_metric()
# Validate the results. The total cycles are set to the sum of user
# and fw when the total is bad.
self.assertEqual(host_stats.total_cycles, 88609400268)
self.assertEqual(host_stats.total_user_cycles, 30010090000)
self.assertEqual(host_stats.total_fw_cycles, 58599310268)
def test_get_cpu_freq(self):
# _get_cpu_freq() should return an int based on the clock line of the
# file
m = mock.mock_open(
read_data='processor : 12\nclock : 4116.000000MHz\n')
m.return_value.__iter__ = lambda self: iter(self.readline, '')
with mock.patch('pypowervm.tasks.monitor.host_cpu.open', m):
host_stats = host_cpu.HostCPUMetricCache(self.adpt, 'host_uuid')
self.assertEqual(host_stats.cpu_freq, 4116)
def test_get_total_cycles(self):
# Mock objects to test with
host_stats = host_cpu.HostCPUMetricCache(self.adpt, 'host_uuid')
mock_phyp = mock.MagicMock()
mock_phyp.sample = mock.MagicMock()
mock_phyp.sample.processor.configurable_proc_units = 5
mock_phyp.sample.time_based_cycles = 500
host_stats.cur_phyp = mock_phyp
# Make sure we get the full system cycles.
max_cycles = host_stats._get_total_cycles_delta()
self.assertEqual(2500, max_cycles)
def test_get_firmware_cycles(self):
# Mock objects to test with
host_stats = host_cpu.HostCPUMetricCache(self.adpt, 'host_uuid')
# Latest Sample
mock_phyp = mock.MagicMock(sample=mock.MagicMock())
mock_phyp.sample.system_firmware.utilized_proc_cycles = 2000
# Previous Sample
prev_phyp = mock.MagicMock(sample=mock.MagicMock())
prev_phyp.sample.system_firmware.utilized_proc_cycles = 1000
host_stats.cur_phyp = mock_phyp
host_stats.prev_phyp = prev_phyp
# Get delta
delta_firmware_cycles = host_stats._get_fw_cycles_delta()
self.assertEqual(1000, delta_firmware_cycles)
def test_update_internal_metric(self, mock_user_cycles, mock_total_cycles,
mock_fw_cycles):
host_stats = host_cpu.HostCPUMetricCache(self.adpt, 'host_uuid')
# Make sure totals are 0 if there is no data.
host_stats.cur_phyp = None
host_stats._update_internal_metric()
self.assertEqual(host_stats.total_cycles, 0)
self.assertEqual(host_stats.total_user_cycles, 0)
self.assertEqual(host_stats.total_fw_cycles, 0)
# Create mock phyp objects to test with
mock_phyp = mock.MagicMock()
mock_fw_cycles.return_value = 58599310268
mock_prev_phyp = mock.MagicMock()
# Mock methods not currently under test
mock_user_cycles.return_value = 50
mock_total_cycles.return_value = 1.6125945178663e+16
# Make the 'prev' the current...for the first pass
host_stats.cur_phyp = mock_prev_phyp
host_stats.prev_phyp = None
host_stats._update_internal_metric()
self.assertEqual(host_stats.total_cycles, 1.6125945178663e+16)
self.assertEqual(host_stats.total_user_cycles, 50)
self.assertEqual(host_stats.total_fw_cycles, 58599310268)
# Mock methods not currently under test
mock_user_cycles.return_value = 30010090000
mock_total_cycles.return_value = 1.6125945178663e+16
# Now 'increment' it with a new current/previous
host_stats.cur_phyp = mock_phyp
host_stats.prev_phyp = mock_prev_phyp
mock_user_cycles.return_value = 100000
host_stats._update_internal_metric()
# Validate the new values. Note that these values are 'higher' because
# they are running totals.
new_fw = 58599310268 * 2
new_total = 1.6125945178663e+16 * 2
self.assertEqual(host_stats.total_cycles, new_total)
self.assertEqual(host_stats.total_user_cycles, 100050)
self.assertEqual(host_stats.total_fw_cycles, new_fw)
def test_get_total_cycles_diff_cores(self):
# Mock objects to test with
host_stats = host_cpu.HostCPUMetricCache(self.adpt, 'host_uuid')
# Latest Sample
mock_phyp = mock.MagicMock(sample=mock.MagicMock())
mock_phyp.sample.processor.configurable_proc_units = 48
mock_phyp.sample.time_based_cycles = 1000
host_stats.cur_phyp = mock_phyp
# Earlier sample. Use a higher proc unit sample
mock_phyp = mock.MagicMock(sample=mock.MagicMock())
mock_phyp.sample.processor.configurable_proc_units = 1
mock_phyp.sample.time_based_cycles = 500
host_stats.prev_phyp = mock_phyp
# Make sure we get the full system cycles.
max_cycles = host_stats._get_total_cycles_delta()
self.assertEqual(24000, max_cycles)
def test_gather_user_cycles_delta(self, mock_cycles):
# Crete objects to test with
host_stats = host_cpu.HostCPUMetricCache(self.adpt, 'host_uuid')
mock_phyp = mock.MagicMock()
mock_prev_phyp = mock.MagicMock()
# Mock methods not currently under test
mock_cycles.return_value = 15005045000
# Test that we can run with previous samples and then without.
host_stats.cur_phyp = mock_phyp
host_stats.prev_phyp = mock_prev_phyp
resp = host_stats._gather_user_cycles_delta()
self.assertEqual(30010090000, resp)
# Now test if there is no previous sample. Since there are no previous
# samples, it will be 0.
host_stats.prev_phyp = None
mock_cycles.return_value = 0
resp = host_stats._gather_user_cycles_delta()
self.assertEqual(0, resp)
def test_delta_user_cycles(self):
# Create objects to test with
host_stats = host_cpu.HostCPUMetricCache(self.adpt, 'host_uuid')
mock_phyp, mock_prev_phyp = self._get_mock_phyps()
mock_phyp.sample.lpars[0].processor.util_cap_proc_cycles = 250000
mock_phyp.sample.lpars[0].processor.util_uncap_proc_cycles = 250000
mock_phyp.sample.lpars[0].processor.idle_proc_cycles = 500
mock_prev_phyp.sample.lpars[0].processor.util_cap_proc_cycles = 0
num = 455000
mock_prev_phyp.sample.lpars[0].processor.util_uncap_proc_cycles = num
mock_prev_phyp.sample.lpars[0].processor.idle_proc_cycles = 1000
# Test that a previous sample allows us to gather just the delta.
new_elem = self._get_sample(4, mock_phyp.sample)
old_elem = self._get_sample(4, mock_prev_phyp.sample)
delta = host_stats._delta_user_cycles(new_elem, old_elem)
self.assertEqual(45500, delta)
# Validate the scenario where we don't have a previous. Should default
# to 0, given no context of why the previous sample did not have the
# data.
delta = host_stats._delta_user_cycles(new_elem, None)
self.assertEqual(0, delta)
def test_refresh(self):
host_stats = host_cpu.HostCPUMetricCache(self.adpt, 'host_uuid')
host_stats.refresh()
# Called once in init and once in refesh()
self.assertEqual(self.mock_refresh_if_needed.call_count, 2)