Beispiel #1
0
    def test_utlization_sotre_load(self):
        rt = ResultTrace()
        self.addCleanup(self._del_table, "usage_values")
        rt._get_utilization_result().create_table(self._db)

        rt._lists_start = {
            "job_db_inx": [2, 1],
            "account": ["account2", "account1"],
            "cpus_req": [96, 48],
            "cpus_alloc": [96, 48],
            "job_name": ["jobName2", "jobName1"],
            "id_job": [2, 1],
            "id_qos": [3, 2],
            "id_resv": [4, 3],
            "id_user": [5, 4],
            "nodes_alloc": [4, 2],
            "partition": ["partition2", "partition1"],
            "priority": [199, 99],
            "state": [2, 3],
            "timelimit": [200, 100],
            "time_submit": [3000, 3000],
            "time_start": [3001, 3003],
            "time_end": [3005, 3010]
        }

        rt._wf_extractor = FakeWFExtractor()
        (integrated_ut, utilization_timestamps, utilization_values, acc_waste,
         corrected_ut) = (rt.calculate_utilization(144,
                                                   do_preload_until=3003,
                                                   endCut=3010,
                                                   store=True,
                                                   db_obj=self._db,
                                                   trace_id=1))
        self.assertEqual(acc_waste, 24)

        self.assertEqual(utilization_timestamps,
                         [3003, 3005, 3006, 3007, 3008, 3010])
        self.assertEqual(utilization_values, [144, 48, 36, 24, 48, 0])
        rt_2 = ResultTrace()
        rt_2.load_utilization_results(self._db, 1)
        new_ut, new_acc, new_corrected_ut = rt_2.get_utilization_values()
        self.assertAlmostEqual(integrated_ut, new_ut)
        self.assertEqual(acc_waste, new_acc)
        print("new_corrected_ut", new_corrected_ut)
        self.assertAlmostEqual(corrected_ut, new_corrected_ut)
Beispiel #2
0
    def test_utlization_waste(self):
        rt = ResultTrace()
        rt._lists_start = {
            "job_db_inx": [2, 1],
            "account": ["account2", "account1"],
            "cpus_req": [96, 48],
            "cpus_alloc": [96, 48],
            "job_name": ["jobName2", "jobName1"],
            "id_job": [2, 1],
            "id_qos": [3, 2],
            "id_resv": [4, 3],
            "id_user": [5, 4],
            "nodes_alloc": [4, 2],
            "partition": ["partition2", "partition1"],
            "priority": [199, 99],
            "state": [2, 3],
            "timelimit": [200, 100],
            "time_submit": [3000, 3000],
            "time_start": [3001, 3003],
            "time_end": [3005, 3010]
        }

        (integrated_ut, utilization_timestamps, utilization_values, acc_waste,
         corrected_ut) = (rt.calculate_utilization(144, do_preload_until=3002))

        self.assertEqual(utilization_timestamps, [3002, 3003, 3005, 3010])
        self.assertEqual(utilization_values, [96, 144, 48, 0])
        self.assertEqual(acc_waste, 0)
        self.assertEqual(integrated_ut, corrected_ut)

        (integrated_ut, utilization_timestamps, utilization_values, acc_waste,
         corrected_ut) = (rt.calculate_utilization(144,
                                                   do_preload_until=3003,
                                                   endCut=3006))

        self.assertEqual(utilization_timestamps, [3003, 3005, 3006])
        self.assertEqual(utilization_values, [144, 48, 48])
        self.assertEqual(acc_waste, 0)
        self.assertEqual(integrated_ut, corrected_ut)

        self.assertEqual(integrated_ut, (2.0 * 144.0 + 48.0) / (3.0 * 144.0))

        (integrated_ut, utilization_timestamps, utilization_values, acc_waste,
         corrected_ut) = (rt.calculate_utilization(144,
                                                   do_preload_until=3003,
                                                   endCut=3010))

        self.assertEqual(utilization_timestamps, [3003, 3005, 3010])
        self.assertEqual(utilization_values, [144, 48, 0])
        self.assertAlmostEqual(integrated_ut, 0.523809, delta=0.001)
        self.assertEqual(acc_waste, 0)
        self.assertEqual(integrated_ut, corrected_ut)

        rt._wf_extractor = FakeWFExtractor()
        (integrated_ut, utilization_timestamps, utilization_values, acc_waste,
         corrected_ut) = (rt.calculate_utilization(144,
                                                   do_preload_until=3003,
                                                   endCut=3010))
        self.assertEqual(acc_waste, 24)

        self.assertEqual(utilization_timestamps,
                         [3003, 3005, 3006, 3007, 3008, 3010])
        self.assertEqual(utilization_values, [144, 48, 36, 24, 48, 0])
        self.assertAlmostEqual((integrated_ut - corrected_ut) * 7 * 144, 24)