scheduleset.py

from lib.schedule import Schedule
from functools import reduce
import math

class ScheduleSet:

    def __init__(self, taskset, schedule_set):
        self.taskset = taskset
        self.schedule_set = schedule_set
        self.schedule_set_size = len(schedule_set)
        if self.schedule_set_size > 0:
            self.pro_sets = self.compute_probabilities()
            self.slot_entropy = self.compute_slot_entropy()
            self.upper_approximated_entropy = self.upper_approx_entropy()
        else:
            self.upper_approximated_entropy = 0

    """
    This function computes the probability that a task i is active at every time t, 0 <= t <= hyperperiod
    """
    def compute_probabilities(self):
        # potential values are 1..n and 0 for idle
        alternatives = self.taskset.numtasks
        hyperperiod = int(self.taskset.hyperperiod())

        # create a probability set for the idle task
        idle_pro_set = [0] * hyperperiod
        for i in range(hyperperiod):
            total_idles = sum([1 for x in self.schedule_set if x[i] == 0])
            idle_pro_set[i] = float(total_idles) / float(self.schedule_set_size)

        # create probability sets for the other values
        pro_sets = list()
        for val in range(1, alternatives + 1):
            val_pro_set = [0] * hyperperiod
            for i in range(hyperperiod):
                total_vals = sum([1 for x in self.schedule_set if x[i] == val])
                val_pro_set[i] = float(total_vals) / float(self.schedule_set_size)

            pro_sets.append(val_pro_set)

        # Add idle probability set to probability sets
        pro_sets.append(idle_pro_set)

        # order is 1..n and idle
        return pro_sets

    """
    This function computes the slot entropy H_Gamma at time each time t as the sum of all the task probabilities
    """
    def compute_slot_entropy(self):
        hyperperiod = int(self.taskset.hyperperiod())
        slot_entropy = [0] * hyperperiod
        for i in range(hyperperiod):
            for j in self.pro_sets:
                cur_set = j
                if cur_set[i] == 0.0:
                    slot_entropy[i] -= 0.0
                else:
                    slot_entropy[i] -= cur_set[i] * math.log(cur_set[i], 2)

        return slot_entropy

    def upper_approx_entropy(self):
        return reduce(lambda x, y: x+y, self.slot_entropy)