python实现的EDF(earliest deadline first)算法

  1 #!/user/bin/env python
  2 # -*- coding:utf-8 -*-
  3 
  4 
  5 class GetCloseTime:
  6     def __init__(self, dictionary):
  7         self.dictionary = dictionary
  8 
  9     def greatest_common_divisor(self, _left, _right):
 10         return _left if _right == 0 else self.greatest_common_divisor(_right, _left % _right)
 11 
 12     def lowest_common_multiple(self):
 13         temp_result = 1
 14         for value in self.dictionary.values():
 15             temp_result = value[1] * temp_result / self.greatest_common_divisor(value[1], temp_result)
 16         return temp_result
 17 
 18 
 19 class TaskControlBlock:
 20     CURRENT_TIME = 0
 21 
 22     def __init__(self, dictionary,
 23                  name_list,
 24                  period_time,
 25                  central_processing_unit_time,
 26                  remain_time,
 27                  current_period):
 28         for key in dictionary.keys():
 29             name_list.append(key)
 30             period_time.append(dictionary.get(key)[1])
 31             central_processing_unit_time.append(dictionary.get(key)[0])
 32             remain_time.append(dictionary.get(key)[0])
 33             current_period.append(1)
 34 
 35     def get_index_of_min(self, earliest_deadline_task_list, minimum):
 36         return earliest_deadline_task_list.index(minimum)
 37 
 38     def get_another_index_of_min(self, earliest_deadline_task_list, minimum):
 39         earliest_deadline_task_list[earliest_deadline_task_list.index(minimum)] = 100000
 40         return earliest_deadline_task_list.index(min(earliest_deadline_task_list))
 41 
 42     def is_execute(self, central_processing_unit_time, period_time):
 43         temp_list = [a / b for a, b in zip(central_processing_unit_time, period_time)]
 44         return sum(temp_list)
 45 
 46     def scheduling(self, name_list,
 47                    period_time,
 48                    central_processing_unit_time,
 49                    remain_time,
 50                    current_period):
 51         if self.is_execute(central_processing_unit_time, period_time) > 1:
 52             print("error, scheduling finish!")
 53             exit(0)
 54         earliest_deadline_task = self.get_index_of_min(
 55             [a * b for a, b in zip(period_time, current_period)],
 56             min(a * b for a, b in zip(period_time, current_period)))
 57 
 58         if self.CURRENT_TIME < period_time[earliest_deadline_task] * (current_period[earliest_deadline_task] - 1):
 59             current_period_p = period_time[earliest_deadline_task] * (current_period[earliest_deadline_task] - 1)
 60             temp_list = [a * b for a, b in zip(period_time, current_period)]
 61             while self.CURRENT_TIME < period_time[earliest_deadline_task] *  62                     (current_period[earliest_deadline_task] - 1):
 63                 earliest_deadline_task = self.get_another_index_of_min(temp_list, min(temp_list))
 64 
 65             if remain_time[earliest_deadline_task] <= current_period_p - self.CURRENT_TIME:
 66                 running_time = remain_time[earliest_deadline_task]
 67             else:
 68                 running_time = current_period_p - self.CURRENT_TIME
 69 #            current_period_p = period_time[earliest_deadline_task] * current_period[earliest_deadline_task]
 70             remain_time[earliest_deadline_task] -= running_time
 71             print(name_list[earliest_deadline_task], self.CURRENT_TIME, running_time)
 72             self.CURRENT_TIME += running_time
 73             if remain_time[earliest_deadline_task] == 0:
 74                 current_period[earliest_deadline_task] += 1
 75                 remain_time[earliest_deadline_task] = central_processing_unit_time[earliest_deadline_task]
 76         else:
 77             current_period_p = period_time[earliest_deadline_task] * current_period[earliest_deadline_task]
 78             if remain_time[earliest_deadline_task] <= current_period_p - self.CURRENT_TIME:
 79                 running_time = remain_time[earliest_deadline_task]
 80             else:
 81                 running_time = current_period_p - self.CURRENT_TIME
 82             remain_time[earliest_deadline_task] -= running_time
 83             print(name_list[earliest_deadline_task], self.CURRENT_TIME, running_time)
 84             self.CURRENT_TIME += running_time
 85             if remain_time[earliest_deadline_task] == 0:
 86                 current_period[earliest_deadline_task] += 1
 87                 remain_time[earliest_deadline_task] = central_processing_unit_time[earliest_deadline_task]
 88 
 89 
 90 if __name__ == "__main__":
 91     task_dictionary = {"A": [10, 30],
 92                        "B": [20, 60],
 93                        "C": [30, 90]}
 94     close_time_object = GetCloseTime(task_dictionary)
 95     close_time = close_time_object.lowest_common_multiple()
 96 
 97     current_time = 0
 98     name_list = []
 99     period_time = []
100     central_processing_unit_time = []
101     remain_time = []
102     current_period = []
103     tcb = TaskControlBlock(task_dictionary,
104                            name_list,
105                            period_time,
106                            central_processing_unit_time,
107                            remain_time,
108                            current_period)
109 
110     while tcb.CURRENT_TIME < close_time:
111         tcb.scheduling(name_list,
112                        period_time,
113                        central_processing_unit_time,
114                        remain_time,
115                        current_period)