Esempio n. 1
0
    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)
Esempio n. 2
0
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
Esempio n. 3
0
def main(args):

    # Load configuration file and check
    configPath = args.configPaths[args.currentConfigIdx]
    configuration = Configuration(configPath)
    configuration.check_all()

    # Init a model from the configuration.
    model = Model(configuration)

    # Execute the simulation.
    model.run_model()

    # Write results to csv file
    logger.log(15,"Total Migrations: " + str(model.results.total_migrations))
    logger.log(15,"Total Pre-emptions: " + str(model.results.total_preemptions))
    logger.log(15,"Total Exceeded Count: " + str(model.results.total_exceeded_count))
    logger.log(15,"Fitness Score: " + str(Fitness.getFitnessScoreStatic(
                                          model.results.total_exceeded_count,
                                          model.results.total_preemptions,
                                          model.results.total_migrations)))
    Results.outputDefResults(args,model)
Esempio n. 4
0
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
Esempio n. 5
0
def default_config(duration, cpu_count):
    config = Configuration()

    # Amount of ms for the experiment
    config.cycles_per_ms = 100000
    config.duration = duration * config.cycles_per_ms

    # Add a processor:
    for i in range(cpu_count):
        config.add_processor(name="CPU " + str(i), identifier=i)
    return config
Esempio n. 6
0
def main():

	remote = reciever("/tmp/ss_parser")

	configuration = Configuration()

	if remote == None:
		print "remote is none"
		#todo: this number should be generated randomly
		table = gen_slotshift_table(1, 10, 10, 10, .10)
		if table:
			remote = local_table(table[0], table[1],
				table[2], table[3])
		else:
			print "Cant Run because task set not generated"
			return
	else:
		remote.recieve_table()

	associate = association(remote)

	interval = associate.create_def_intr_list(associate)
	
	run_time = associate.get_running_time(interval)

	associate.create_relation_window(associate, interval)

	while 1:
		j = associate.create_tsk(associate, interval, configuration)
		if(j != 0):
			break

	configuration.duration = run_time * configuration.cycles_per_ms

	configuration.add_processor(name="CPU 1", identifier=1)

	configuration.scheduler_info.filename = "./SlotShifting.py"

	configuration.scheduler_info.data = interval

	configuration.check_all()

	model = Model(configuration)

	model.run_model()
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)))
Esempio n. 8
0
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
Esempio n. 9
0
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)
Esempio n. 10
0
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)
Esempio n. 11
0
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)
Esempio n. 12
0
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)
Esempio n. 13
0
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))
Esempio n. 14
0
def main(argv):
    if len(argv) == 3:
        # Configuration load from a file.
        configuration = Configuration(argv[1])
        outputFileName = argv[2]
    else:
        raise Exception("Configuration is not correct.")

        # SPORADIC TASKS ALGOS
    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',
    ]

    # Check the config before trying to run it.
    configuration.check_all()

    # open csv file
    with open(outputFileName, 'w') as csvfile:
        fieldnames = ['Algo'] + Measurement.fieldNames
        writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
        writer.writeheader()

        for scheduler in schedulingAlgos:
            # overwrite scheduling algorithm
            configuration.scheduler_info.clas = scheduler
            # Init a model from the configuration.
            model = Model(configuration)
            # Execute the simulation.
            model.run_model()
            configuration = Configuration(argv[1])

            print("Finished for algo: " + scheduler)

            # Print response times
            for measurement in model._measurements:
                writer.writerow({
                    fieldnames[0]: scheduler,
                    fieldnames[1]: measurement._taskName,
                    fieldnames[2]: measurement._taskType,
                    fieldnames[3]: measurement._activationTime,
                    fieldnames[4]: measurement._startTime,
                    fieldnames[5]: measurement._endTime,
                    fieldnames[6]: measurement._deadline,
                    fieldnames[7]: measurement._compTime,
                    fieldnames[8]: measurement._respTime
                })

    csvfile.close()
Esempio n. 15
0
def main(args):

    # Load configuration file and check
    configPath = args.configPaths[args.currentConfigIdx]
    configuration = Configuration(configPath)
    configuration.check_all()

    # Init a model from the configuration.
    model = Model(configuration)

    #initial population
    organism = Organism(args,
                        model.task_list,
                        args.numChrom,
                        shuffleTaskPriority=True,
                        elitePercent=args.ESCperc[0],
                        selectionPercent=args.ESCperc[1],
                        crossOverPercent=args.ESCperc[2],
                        mutationRate=args.mutRate)

    #Run genetic algorithm
    for gen in range(args.numGen):
        organism.checkValid()
        logger.log(15, "\n---------------\n" + \
                      f"Running generation {gen+1}..")
        runStartTime = time.time()
        for chromosome in organism.chromList:
            #set chromosome for model to use
            model = Model(configuration)
            model.scheduler.initializeChromosome(chromosome)
            # Execute the simulation.
            logger.log(
                3,
                Debug.getTaskListStr(chromosome.taskNameToPriority,
                                     name='Chromosome Task Priorities'))
            model.run_model()
            chromosome.fitness.updateAllFitnessMetrics(model)
            del model
        runEndTime = time.time()
        logger.log(
            15,
            f"..Gen {gen+1} running complete. (Time: {runEndTime-runStartTime:.2f} secs).\n"
        )
        ## After all chromosomes in organism has run...
        #  Record statistics via logging and internally
        bestChromList = organism.getSortedChromList()
        totFS, totMig, totPre, totNL, totEC, totChrom = 0.0, 0.0, 0.0, 0.0, 0.0, args.numChrom
        for rank, chrom in enumerate(bestChromList):
            chrom.addRank(rank)
            if rank < PRINTTOP:
                logger.log(15, f"Rank {rank+1} - Fitness: {chrom.fitness.getFitnessScore()}," \
                        f" Migrations: {chrom.fitness.getMigrations()}," \
                        f" Preemptions: {chrom.fitness.getPreemptions()}," \
                        f" NL: {chrom.fitness.getNormalizedLaxity():.4f}," \
                        f" Exceeded Count: {chrom.fitness.getExceededCount()}")
            totFS += chrom.fitness.getFitnessScore()
            totMig += chrom.fitness.getMigrations()
            totPre += chrom.fitness.getPreemptions()
            totNL += chrom.fitness.getNormalizedLaxity()
            totEC += chrom.fitness.getExceededCount()
        logger.log(15, f"AVERAGE - Fitness: {totFS/totChrom}," \
                        f" Migrations: {totMig/totChrom:.1f}," \
                        f" Preemptions: {totPre/totChrom:.1f}," \
                        f" NL: {totNL/totChrom:.4f}," \
                        f" Exceeded Count: {totEC/totChrom:.1f}")
        organism.avgFitnessDict['FitnessScore'].append(totFS / totChrom)
        organism.avgFitnessDict['Migrations'].append(totMig / totChrom)
        organism.avgFitnessDict['Preemptions'].append(totPre / totChrom)
        organism.avgFitnessDict['NormalizedLaxity'].append(totNL / totChrom)
        organism.avgFitnessDict['ExceededCount'].append(totEC / totChrom)

        #Perform the selection, crossover, and mutation
        organism.checkValid()
        organism.goNextGen(bestChromList=bestChromList)
        logger.log(
            15,
            f"\n(Organism & Chromosome overhead: {time.time()-runEndTime:.2f} secs)"
        )

    Results.outputStatsForRun(organism, args)
Esempio n. 16
0
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)
Esempio n. 17
0
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))
Esempio n. 18
0
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()
Esempio n. 19
0
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)