def get_cap_ratio()

in cluster-trace-gpu-v2020/simulator/cluster.py [0:0]

• 22 lines of code
• 7 McCabe index (conditional complexity)

    def get_cap_ratio(self, time, pattern=None, period=None):
        pattern = self.pattern if pattern is None else pattern
        period = self.period if period is None else period

        pattern_ratio_dict = {
            0: {1:(0,1000)}, # always maximum capacity
            1: {1:(0, 62), 0.6:(62, 124)},
            2: {0.6:[(0, 10), (62, 124)], 1:(10, 62)},
            3: {1:(0, 20), 0.9:(20, 40), 0.8:(40, 60), 0.7:(60, 80), 0.6:(80, 100), 0.5:(100, 124)},
            4: {0.5:(0, 20), 0.6:(20, 40), 0.7:(40, 60), 0.8:(60, 80), 0.9:(80, 100)},
            5: {1:[(0, 10), (110, 124)], 0.9:[(10, 20),(100, 110)], 0.8:[(20, 30),(90, 100)], 0.7:[(30, 40),(80, 90)], 0.6:(40, 50), 0.5:(50, 70), 0.4:(70, 80)},
            6: {1:[(0, 20), (50, 60), (110, 124)], 0.6:(20, 50), 0.4:(60, 110)},
            7: {1:[(0, 20), (50, 60), (110, 124)], 0.9:(20, 50), 0.8:(60, 110)}
        }  # { pattern1: {ratio1: [ (lower_bound1, upper_bound1), (lb2, ub2), ... ], ratio2: [...]},  pattern2: {...}  }

        t_mod_p = time % period
        ratio_dict = pattern_ratio_dict.get(pattern, {})
        for key, val in ratio_dict.items():
            if type(val) == tuple:
                val = [val]  # becomes a list
            for bound in val:
                if bound[0] <= t_mod_p < bound[1]:
                    return key
        return 1