class SimSoSession(AbstractSession): def __init__(self, host, port): self.logger = logging.getLogger("SimSoSession") # choose a configuration self.configuration = Configuration() # set processsors self.configuration.add_processor(name="CPU 1", identifier=1) def start(self, taskset, scheduler_class = "simso.schedulers.RM"): # add tasks to simso for task in taskset: self.configuration.add_task( name = 'task_'+str(task['id']), identifier = task['id'], period = task['period'], activation_date = 0, wcet = 3, # ! deadline = 20 ) self.configuration.scheduler_info.clas = scheduler_class self.configuration.check_all() self.model = Model(self.configuration) def is_available(host): return True def is_running(self, taskset): # this method is called after the first `run`. So we are already done. return False def stop(self): pass def run(self, taskset): # run the model self.model.run_model() # update taskset for task in self.model.results.tasks: _task = self._get_task_by_id(taskset, task.identifier) for job in task.jobs: _job = Job() _job.start_date = job.activation_date _job.end_date = job.end_date _task.jobs.append(_job) def close(self): pass def _get_task_by_id(self, taskset, task_id): # the taskset is a list, we have to loop over all items... for task in taskset: if task.id == task_id: return task return None
def create_configuration(rts, slack_methods, instance_count): """ :param rts: :param slack_methods: :param instance_count: :return: """ # Create a SimSo configuration object. configuration = Configuration() # Simulate until the lower priority task has n instantiations. configuration.duration = ( rts["tasks"][-1]["T"] * (instance_count + 1)) * configuration.cycles_per_ms # Add some extra required fields for slack stealing simulation. for task in rts["tasks"]: # Each slack method needs its own copy of A, B, C and CC (computational cost). for ss_method in slack_methods: task["ss"][ss_method] = {'a': task["C"], 'b': task["T"], 'c': 0} # Create the tasks and add them to the SimSo configuration. for task in rts["tasks"]: configuration.add_task(name="T_{0}".format(int(task["nro"])), identifier=int(task["nro"]), period=task["T"], activation_date=0, deadline=task["D"], wcet=task["C"], data=task) # Add a processor. configuration.add_processor(name="CPU 1", identifier=1) # Add a scheduler. configuration.scheduler_info.filename = "schedulers/RM_mono_slack.py" #configuration.scheduler_info.clas = "simso.schedulers.RM" # Check the config before trying to run it. configuration.check_all() return configuration
def gensavetasksets(schedulers, n, nsets, u, min_p, max_p, outdir): # Manual configuration: configuration = Configuration() configuration.duration = 1000 * configuration.cycles_per_ms u = task_generator.StaffordRandFixedSum(n, u, nsets) periods = task_generator.gen_periods_uniform_ex(n, nsets, min_p, max_p, 10000000, True) # Add processors. for i in range(1, 5): configuration.add_processor(name="CPU " + str(i), identifier=i) if not os.path.exists(outdir): os.mkdir(outdir) for i, exp_set in enumerate(task_generator.gen_tasksets(u, periods)): for scheduler_name in schedulers: configuration.scheduler_info.clas = scheduler_name # print("{}:".format(scheduler_name)) while configuration.task_info_list: del configuration.task_info_list[0] id_ = 1 for (c, p) in exp_set: configuration.add_task(name="T{}".format(id_), identifier=id_, period=p, activation_date=0, wcet=c, deadline=p, abort_on_miss=True) id_ += 1 configuration.duration = configuration.get_hyperperiod( ) * configuration.cycles_per_ms # Vérification de la config. configuration.check_all() # save one taskset configuration.save(outdir + "/exp_{}.xml".format(i + 1))
def main(argv): if len(argv) == 1: # Chargement de la conf depuis un fichier. configuration = Configuration(argv[0]) else: # Configuration manuelle : configuration = Configuration() configuration.etm = "fixedpenalty" configuration.duration = 420 * configuration.cycles_per_ms # Ajout des tâches. configuration.add_task(name="T1", identifier=1, period=7, activation_date=0, wcet=3, deadline=7) configuration.add_task(name="T2", identifier=2, period=12, activation_date=0, wcet=3, deadline=12) configuration.add_task(name="T3", identifier=3, period=20, activation_date=0, wcet=5, deadline=20) # Ajout d'un processeur. configuration.add_processor(name="CPU 1", identifier=1) configuration.scheduler_info.set_name("schedulers/RM.py") # Vérification de la config. configuration.check_all() # Initialisation de la simu à partir de la config. model = Model(configuration) # Exécution de la simu. model.run_model() # Affichage des résultats. for log in model.logs: print(log)
def main(argv): if len(argv) == 2: # Configuration load from a file. configuration = Configuration(argv[1]) else: # Manual configuration: configuration = Configuration() configuration.duration = 420 * configuration.cycles_per_ms # Add tasks: configuration.add_task( name="T1", identifier=1, period=7, activation_date=0, wcet=np.array([[1, 2, 3], [.1, .2, .7]]), deadline=7) # add a task with a probabilistic WCET configuration.add_task(name="T2", identifier=2, period=12, activation_date=0, wcet=3, deadline=12) configuration.add_task(name="T3", identifier=3, period=20, activation_date=0, wcet=5, deadline=20) # Add a processor: configuration.add_processor(name="CPU 1", identifier=1) # Add a scheduler: #configuration.scheduler_info.filename = "../simso/schedulers/RM.py" configuration.scheduler_info.clas = "simso.schedulers.RM" # Check the config before trying to run it. configuration.check_all() # Init a model from the configuration. model = Model(configuration) # Execute the simulation. model.run_model() # Print logs. for log in model.logs: print(log)
def main(argv): if len(argv) == 2: # Configuration load from a file. configuration = Configuration(argv[1]) else: # Manual configuration: configuration = Configuration() configuration.duration = 420 * configuration.cycles_per_ms # Add tasks: configuration.add_task(name="T1", identifier=1, period=7, activation_date=0, wcet=3, deadline=7) configuration.add_task(name="T2", identifier=2, period=12, activation_date=0, wcet=3, deadline=12) configuration.add_task(name="T3", identifier=3, period=20, activation_date=0, wcet=5, deadline=20) # Add a processor: configuration.add_processor(name="CPU 1", identifier=1) # Add a scheduler: #configuration.scheduler_info.filename = "../simso/schedulers/RM.py" configuration.scheduler_info.clas = "simso.schedulers.RM" # Check the config before trying to run it. configuration.check_all() # Init a model from the configuration. model = Model(configuration) # Execute the simulation. model.run_model() # Print logs. for log in model.logs: print(log)
def main(argv): global procCount if len(argv) == 8: # Configuration load from a file. nrOfRuns = int(argv[1]) nrOfProc = int(argv[2]) minNrOfPeriodicTasks = int(argv[3]) maxNrOfPeriodicTasks = int(argv[4]) minNrOfSporadicTasks = int(argv[5]) maxNrOfSporadicTasks = int(argv[6]) tasksFileName = argv[7] else: raise Exception("Configuration is not correct.") schedulingAlgos = [ 'simso.schedulers.EDCL', 'simso.schedulers.EDF', # 'simso.schedulers.EDF_US', 'simso.schedulers.EDHS', # 'simso.schedulers.EDZL', 'simso.schedulers.G_FL', # 'simso.schedulers.G_FL_ZL', 'simso.schedulers.LB_P_EDF', # 'simso.schedulers.LLF', # 'simso.schedulers.MLLF', # 'simso.schedulers.PD2', # 'simso.schedulers.P_EDF2', # 'simso.schedulers.P_EDF', # 'simso.schedulers.P_EDF_WF', # 'simso.schedulers.PriD', 'simso.schedulers.P_RM', 'simso.schedulers.RM', 'simso.schedulers.RUN', # 'simso.schedulers.Static_EDF', ] with open(tasksFileName, 'w+') as csvfile: fieldnames = ['Index', 'Successful', 'Algo', 'NrOfProc', 'Utilization', 'NrOfPeriodic', 'NrOfSporadic', 'AvgPeriod_Periodic', 'AvgActivation_Sporadic', 'TaskName', 'TaskType', 'RespTime', 'Avg_CPU'] writer = csv.DictWriter(csvfile, fieldnames=fieldnames) writer.writeheader() for runCounter in range(1, nrOfRuns + 1): nrOfPeriodic = random.randint(minNrOfPeriodicTasks, maxNrOfPeriodicTasks) nrOfSporadic = random.randint(minNrOfSporadicTasks, maxNrOfSporadicTasks) utilization = round(random.uniform(nrOfProc/2, nrOfProc), 1) u = StaffordRandFixedSum(nrOfPeriodic + nrOfSporadic, utilization, 1) p_types = get_periods() p = gen_periods_loguniform(nrOfPeriodic + nrOfSporadic, 1, p_types[1], p_types[2], p_types[3]) if u and p: taskset = gen_tasksets(u, p)[0] print ( "Generating configuration with id " + str(runCounter) + " NrOfPeriodic: " + str(nrOfPeriodic) + ", NrOfSporadic: " + str(nrOfSporadic) + ", Utilization: " + str(utilization)) configuration = Configuration() configuration.duration = 100 * configuration.cycles_per_ms for procCount in range(1, nrOfProc+1): configuration.add_processor(name = "CPU_" + procCount.__str__(), identifier=procCount) i = 0 sumOfPeriods_Periodic = 0 sumOfActivations_Sporadic = 0 for ci, pi in taskset: i += 1 if i <= nrOfPeriodic: configuration.add_task( "Task " + str(i), i, period=pi, wcet=ci, deadline=pi) sumOfPeriods_Periodic += pi else: list_activation_dates = gen_arrivals(pi, 0, configuration.duration_ms) configuration.add_task( "Task " + str(i), i, period=pi, wcet=ci, deadline=pi, task_type="Sporadic", list_activation_dates=list_activation_dates) if (len(list_activation_dates) == 0): sumOfActivations_Sporadic += 0 else: sumOfActivations_Sporadic += sum(list_activation_dates) / len(list_activation_dates) for scheduler in schedulingAlgos: configuration.scheduler_info.clas = scheduler # Init a model from the configuration. model = Model(configuration) # Execute the simulation. successFul = False try: model.run_model() successFul = True except: print('Algorithm ' + scheduler + " failed!") successFul = False print("Finished for algo: " + scheduler) if(successFul): # Print response times for measurement in model._measurements: taskName = measurement._taskName taskType = measurement._taskType respTime = measurement._respTime averageCPULoad = model.getAverageLoad() writer.writerow({fieldnames[0]: runCounter, fieldnames[1]: successFul, fieldnames[2]: scheduler, fieldnames[3]: procCount, fieldnames[4]: utilization, fieldnames[5]: nrOfPeriodic, fieldnames[6]: nrOfSporadic, fieldnames[7]: sumOfPeriods_Periodic / nrOfPeriodic, fieldnames[8]: sumOfActivations_Sporadic / nrOfSporadic, fieldnames[9]: taskName, fieldnames[10]: taskType, fieldnames[11]: respTime, fieldnames[12]: averageCPULoad} ) else: print( "Incorrect configuration: NrOfPeriodic: " + str(nrOfPeriodic) + ", NrOfSporadic: " + str(nrOfSporadic) + ", Utilization: " + str(utilization)) csvfile.close()
def main(argv): schedulers = [ "schedulers/RM.py", "schedulers/EDF.py", "schedulers/PriD.py", "schedulers/EDF_US.py", "schedulers/EDZL.py", "schedulers/LLF.py", "schedulers/MLLF.py", "schedulers/P_EDF.py", "schedulers/LB_P_EDF.py", "schedulers/EDHS.py", "schedulers/EKG.py", "schedulers/LRE_TL.py", "schedulers/DP_WRAP.py", "schedulers/BF.py", "schedulers/LLREF.py", "schedulers/PD2.py", "schedulers/ER_PD2.py", "schedulers/RUN.py" ] schedulers = [ "schedulers/EDF.py", "schedulers/EDZL.py", "schedulers/MLLF.py", "schedulers/P_EDF.py", "schedulers/EDHS.py", "schedulers/EKG.py", "schedulers/LRE_TL.py", "schedulers/LLREF.py", "schedulers/ER_PD2.py", "schedulers/RUN.py" ] schedulers = ["schedulers/EDF.py", "schedulers/EDF2.py"] schedulers = [ "schedulers/WC_U_EDF.py", "schedulers/U_EDF.py", "schedulers/RUN.py", "schedulers/WC_RUN.py" ] schedulers = [ "schedulers/RUN.py", "schedulers/WC_RUN.py", "/home/max/Documents/These/RTCSA/experiments/schedulers/WC_RUN.py" ] schedulers = [ "schedulers/WC_U_EDF.py", "schedulers/U_EDF.py", "/home/max/Documents/These/RTCSA/experiments/schedulers/WC_U_EDF.py" ] schedulers = ["schedulers/PD2.py", "schedulers/ER_PD2.py"] output = input("Output directory: ") os.mkdir(output) wcet_file = open(output + "/wcet.csv", "w") csv_wcet = csv.writer(wcet_file) ResultExp.print_header(csv_wcet) acet_file = open(output + "/acet.csv", "w") csv_acet = csv.writer(acet_file) ResultExp.print_header(csv_acet) if argv: for i, f in enumerate(argv): configuration = Configuration(f) for scheduler_name in schedulers: print(scheduler_name) configuration.scheduler_info.set_name(scheduler_name, configuration.cur_dir) configuration.check_all() execute(configuration, "wcet", csv_wcet, wcet_file, i) execute(configuration, "acet", csv_acet, acet_file, i) else: # Manual configuration: configuration = Configuration() configuration.duration = 1000 * configuration.cycles_per_ms # Generate tasks: nsets = int(input("Number of experiments: ")) n = int(input("Number of tasks: ")) nb_proc = int(input("Number of processors: ")) u = float(input("Load: ")) u = task_generator.StaffordRandFixedSum(n, u, nsets) periods = task_generator.gen_periods_loguniform(n, nsets, 2, 100, round_to_int=True) # Add processors: for i in range(1, nb_proc + 1): configuration.add_processor(name="CPU {}".format(i), identifier=i) for i, exp_set in enumerate(task_generator.gen_tasksets(u, periods)): for scheduler_name in schedulers: print(scheduler_name) configuration.scheduler_info.set_name(scheduler_name, configuration.cur_dir) while configuration.task_info_list: del configuration.task_info_list[0] id_ = 1 for (c, p) in exp_set: configuration.add_task(name="T{}".format(id_), identifier=id_, period=p, activation_date=0, wcet=c, acet=c * .75, et_stddev=c * .1, deadline=p, abort_on_miss=True) id_ += 1 # Check the configuration: configuration.check_all() # Save the current exp: configuration.save(output + "/exp_{}.xml".format(i)) # Execute the simulation: execute(configuration, "wcet", csv_wcet, wcet_file, i) execute(configuration, "acet", csv_acet, acet_file, i)
def create_trace(scheduler="simso.schedulers.RM", n_tasks=3, seed=None, total_utilization=0.9, method='automotive', alpha=0, jitter=0, is_preemptive=True): redo = True scale = 1 while redo: # Manual configuration: configuration = Configuration() configuration.cycles_per_ms = 1 # Replicate the results for more scheduling policies if seed is not None: np.random.seed(seed) random.seed(seed) # Generate periods and executions according to the specified method periods, wcets = gen_periods_and_exec(n_tasks, total_utilization, method, is_preemptive) # Debugging if method == 'loguniform': divider = 1 / 10 else: divider = 1 / 1000 wcets = wcets / divider hyperperiod = np.lcm.reduce(np.array(periods)) / divider periods = periods / divider wcets = np.round(wcets / scale) * scale for i in range(len(wcets)): if wcets[i] == 0: wcets[i] = scale if alpha == 0: for i in range(n_tasks): configuration.add_task(name="T" + str(i + 1), identifier=i, period=periods[i] / scale, activation_date=0, wcet=wcets[i] / scale, deadline=periods[i] / scale, jitter=jitter) if jitter == 0: configuration.duration = 2 * hyperperiod * configuration.cycles_per_ms / scale # in seconds else: configuration.duration = 10 * hyperperiod * configuration.cycles_per_ms / scale # in seconds else: configuration.etm = 'ucet' ucets = (1 - alpha) * wcets for i in range(n_tasks): configuration.add_task(name="T" + str(i + 1), identifier=i, period=periods[i] / scale, activation_date=0, ucet=ucets[i], wcet=wcets[i] / scale, deadline=periods[i] / scale, jitter=jitter) configuration.duration = 10 * hyperperiod * configuration.cycles_per_ms / scale # in seconds if configuration.duration < 0: continue # Add a processor: configuration.add_processor(name="CPU 1", identifier=1) # Add a scheduler: configuration.scheduler_info.clas = scheduler # Check the config before trying to run it. configuration.check_all() # Init a model from the configuration. model = Model(configuration) # Execute the simulation. model.run_model() redo = False trace = [] prev_time = 0 prev_task = None for log in model.logs: crt_time = log[0] info = log[1][0].split("_") task = int(info[0].split('T')[1]) state = info[1].split(' ') if 'Preempted!' in state: for i in range(1, int((crt_time - prev_time))): trace.append(prev_task) prev_time = crt_time if 'Executing' in state: if prev_time != crt_time: for i in range(0, int((crt_time - prev_time))): trace.append(0) # append idle task prev_time = crt_time # reset counting time interval prev_task = task trace.append(task) if 'Terminated.' in state: for i in range(1, int((crt_time - prev_time))): trace.append(prev_task) prev_time = crt_time return trace, list(map(int, list(periods)))
def simulate(taskset): """Simulation. This method executes the simulation of a task-set. The simulation is run over the hyperperiod, which is the least common mean of all task periods. The task-set is schedulable if all jobs of all tasks in the hyperperiod can meet their deadlines. Args: taskset - the task-set that should be analyzed Return: True - the task-set is schedulable False - the task-set is not schedulable -1 - an error occured """ # create logger logger = logging.getLogger('traditional-SA.simulation.simulate') # Check input argument if taskset is None or not isinstance(taskset, Taskset): logger.error("Invalid input argument or no task-set given!") return -1 # Manual configuration: the configuration class stores all the details about a system configuration = Configuration() # Get the periods of the tasks periods = [] for task in taskset: if task.period not in periods: periods.append(task.period) # Calculate the hyperperiod of the tasks hyper_period = _lcm(periods) logger.debug("simulation.py/simulate(): Hyperperiod H = %d", hyper_period) # Define the length of simulation (= H) configuration.duration = hyper_period * configuration.cycles_per_ms # Add a property 'priority' to the task data fields configuration.task_data_fields[ 'priority'] = 'int' # 'priority' is of type int # Add the tasks to the list of tasks i = 1 for task in taskset: task_name = "T" + str(task.task_id) activation_dates = _get_activation_dates(hyper_period, task.period, task.number_of_jobs) configuration.add_task(name=task_name, identifier=i, task_type="Sporadic", period=task.period, activation_date=0, wcet=task.execution_time, deadline=task.deadline, list_activation_dates=activation_dates, data={'priority': task.priority}) i += 1 # Add a processor to the list of processors configuration.add_processor(name="CPU1", identifier=1) # Add a scheduler: configuration.scheduler_info.filename = "fp_edf_scheduler.py" # use a custom scheduler # Check the correctness of the configuration (without simulating it) before trying to run it configuration.check_all() # Init a model from the configuration model = Model(configuration) # Execute the simulation model.run_model() # Schedulability analysis: check for deadline miss of each job of every task for task in model.results.tasks: # print(task.name + ":") for job in task.jobs: if job.aborted: # deadline miss logger.debug( "simulation.py/simulate(): {0:s} Deadline miss".format( job.name)) return False return True
def main(argv): print("usage: ./exp [filename1] [filename2] ...") # outdir = input("Output directory: ") outdir = "results" if not os.path.exists(outdir): os.mkdir(outdir) result_file = open(outdir + "/result.csv", "w") csv_result = csv.writer(result_file) ResultExp.print_header(csv_result) schedulers = [ "simso.schedulers.RM"] # "simso.schedulers.EDF", # "simso.schedulers.RM_mono"] if not argv: for i in range (1, 11): argv.append("tasksets/exp_{}.xml".format(str(i))) if argv: for i, f in enumerate(argv): configuration = Configuration(f) for scheduler_name in schedulers: configuration.scheduler_info.clas = scheduler_name # configuration.check_all() execute(configuration, "ofrp", csv_result, result_file, i+1) else: # Manual configuration: configuration = Configuration() configuration.duration = 1000 * configuration.cycles_per_ms # Generate tasks: nsets = int(input("Number of experiments: ")) n = int(input("Number of tasks: ")) nb_proc = int(input("Number of processors: ")) u = float(input("Load: ")) u = task_generator.StaffordRandFixedSum(n, u, nsets) periods = task_generator.gen_periods_loguniform(n, nsets, 2, 100, round_to_int=True) # Add processors: for i in range(1, nb_proc + 1): configuration.add_processor(name="CPU {}".format(i), identifier=i) for i, exp_set in enumerate(task_generator.gen_tasksets(u, periods)): for scheduler_name in schedulers: print(scheduler_name) configuration.scheduler_info.clas = scheduler_name while configuration.task_info_list: del configuration.task_info_list[0] id_ = 1 for (c, p) in exp_set: configuration.add_task( name="T{}".format(id_), identifier=id_, period=p, activation_date=0, wcet=c, acet=c * .75, et_stddev=c * .1, deadline=p, abort_on_miss=True) id_ += 1 configuration.duration = configuration.get_hyperperiod * configuration.cycles_per_ms # Check the configuration: configuration.check_all() # Save the current exp: configuration.save(outdir + "/exp_{}.xml".format(i+1)) # Execute the simulation: execute(configuration, "ofrp", csv_result, result_file, i+1)
def main(argv): if len(argv) == 1: configuration = Configuration(argv[0]) else: # Configuration manuelle : configuration = Configuration() configuration.duration = 20 * configuration.cycles_per_ms # Ajout des tâches. configuration.add_task(name="T1", identifier=1, period=4, activation_date=0, wcet=2, deadline=4) configuration.add_task(name="T2", identifier=2, period=5, activation_date=0, wcet=1, deadline=5) configuration.add_task(name="T3", identifier=3, period=20, activation_date=0, wcet=3, deadline=20) # Ajout d'un processeur. configuration.add_processor(name="CPU 1", identifier=1) configuration.add_processor(name="CPU 2", identifier=2) configuration.scheduler_info.clas = "simso.schedulers.RM" configuration.save("test.xml") # Vérification de la config. configuration.check_all() # Initialisation de la simu à partir de la config. model = Model(configuration) # Exécution de la simu. model.run_model() # Affichage des résultats. for log in model.logs: print(log) # Affichage de quelques métriques. # Durée d'exec des jobs print("Job computation times") for task in model.results.tasks: print(task.name + ":") for job in task.jobs: print("%s %.3f ms" % (job.name, job.computation_time)) # Nombre de préemptions par task print("Preemption counts:") for task in model.results.tasks.values(): print("%s %d" % (task.name, task.preemption_count)) cxt = 0 for processor in model.processors: prev = None for evt in processor.monitor: if evt[1].event == ProcEvent.RUN: if prev is not None and prev != evt[1].args.task: cxt += 1 prev = evt[1].args.task print("Number of context switches (without counting the OS): " + str(cxt))
def main(argv): schedulers = [ "schedulers/RM.py", "schedulers/EDF.py", "schedulers/PriD.py", "schedulers/EDF_US.py", "schedulers/EDZL.py", "schedulers/LLF.py", "schedulers/MLLF.py", "schedulers/P_EDF.py", "schedulers/LB_P_EDF.py", "schedulers/EDHS.py", "schedulers/EKG.py", "schedulers/LRE_TL.py", "schedulers/DP_WRAP.py", "schedulers/BF.py", "schedulers/LLREF.py", "schedulers/PD2.py", "schedulers/ER_PD2.py", "schedulers/RUN.py"] schedulers = [ "schedulers/EDF.py", "schedulers/EDZL.py", "schedulers/MLLF.py", "schedulers/P_EDF.py", "schedulers/EDHS.py", "schedulers/EKG.py", "schedulers/LRE_TL.py", "schedulers/LLREF.py", "schedulers/ER_PD2.py", "schedulers/RUN.py"] schedulers = ["schedulers/EDF.py", "schedulers/EDF2.py"] schedulers = ["schedulers/WC_U_EDF.py", "schedulers/U_EDF.py", "schedulers/RUN.py", "schedulers/WC_RUN.py"] schedulers = ["schedulers/RUN.py", "schedulers/WC_RUN.py", "/home/max/Documents/These/RTCSA/experiments/schedulers/WC_RUN.py"] schedulers = ["schedulers/WC_U_EDF.py", "schedulers/U_EDF.py", "/home/max/Documents/These/RTCSA/experiments/schedulers/WC_U_EDF.py"] schedulers = ["schedulers/PD2.py", "schedulers/ER_PD2.py"] output = input("Output directory: ") os.mkdir(output) wcet_file = open(output + "/wcet.csv", "w") csv_wcet = csv.writer(wcet_file) ResultExp.print_header(csv_wcet) acet_file = open(output + "/acet.csv", "w") csv_acet = csv.writer(acet_file) ResultExp.print_header(csv_acet) if argv: for i, f in enumerate(argv): configuration = Configuration(f) for scheduler_name in schedulers: print(scheduler_name) configuration.scheduler_info.set_name(scheduler_name, configuration.cur_dir) configuration.check_all() execute(configuration, "wcet", csv_wcet, wcet_file, i) execute(configuration, "acet", csv_acet, acet_file, i) else: # Manual configuration: configuration = Configuration() configuration.duration = 1000 * configuration.cycles_per_ms # Generate tasks: nsets = int(input("Number of experiments: ")) n = int(input("Number of tasks: ")) nb_proc = int(input("Number of processors: ")) u = float(input("Load: ")) u = task_generator.StaffordRandFixedSum(n, u, nsets) periods = task_generator.gen_periods_loguniform(n, nsets, 2, 100, round_to_int=True) # Add processors: for i in range(1, nb_proc + 1): configuration.add_processor(name="CPU {}".format(i), identifier=i) for i, exp_set in enumerate(task_generator.gen_tasksets(u, periods)): for scheduler_name in schedulers: print(scheduler_name) configuration.scheduler_info.set_name(scheduler_name, configuration.cur_dir) while configuration.task_info_list: del configuration.task_info_list[0] id_ = 1 for (c, p) in exp_set: configuration.add_task( name="T{}".format(id_), identifier=id_, period=p, activation_date=0, wcet=c, acet=c * .75, et_stddev=c * .1, deadline=p, abort_on_miss=True) id_ += 1 # Check the configuration: configuration.check_all() # Save the current exp: configuration.save(output + "/exp_{}.xml".format(i)) # Execute the simulation: execute(configuration, "wcet", csv_wcet, wcet_file, i) execute(configuration, "acet", csv_acet, acet_file, i)