aboutsummaryrefslogtreecommitdiffstats
path: root/native/src/edf/sim.cpp
blob: 1510d052a2c20f49f38145a98c0f86c16dc22118 (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
#include "tasks.h"
#include "edf/sim.h"

#include "schedule_sim.h"

#include <algorithm>

typedef GlobalScheduler<EarliestDeadlineFirst> GedfSim;

class DeadlineMissSearch : public GedfSim
{
  private:
    bool dmissed;

  public:
    simtime_t when_missed;
    simtime_t when_completed;

    DeadlineMissSearch(int m) : GedfSim(m), dmissed(false) {};

    virtual void job_completed(int proc, Job *job)
    {
        if (this->get_current_time() > job->get_deadline())
        {
            dmissed = true;
            when_missed    = job->get_deadline();
            when_completed = this->get_current_time();
            abort();
        }
    };

    bool deadline_was_missed()
    {
        return dmissed;
    }
};

class Tardiness : public GedfSim
{
  public:
    Stats stats;

    Tardiness(int m) : GedfSim(m)
    {
        stats.num_tardy_jobs = 0;
        stats.num_ok_jobs = 0;
        stats.total_tardiness = 0;
        stats.max_tardiness = 0;
        stats.first_miss = 0;
    };

    virtual void job_completed(int proc, Job *job)
    {
        if (this->get_current_time() > job->get_deadline())
        {
            simtime_t tardiness;
            tardiness = this->get_current_time() - job->get_deadline();
            stats.num_tardy_jobs++;
            stats.total_tardiness += tardiness;
            stats.max_tardiness = std::max(tardiness, stats.max_tardiness);
            if (!stats.first_miss)
                stats.first_miss = job->get_deadline();
        }
        else
            stats.num_ok_jobs++;
    };
};

unsigned long edf_first_violation(unsigned int num_procs,
                                  TaskSet &ts,
                                  unsigned long end_of_simulation)
{
    DeadlineMissSearch sim(num_procs);

    run_periodic_simulation(sim, ts, end_of_simulation);
    if (sim.deadline_was_missed())
        return sim.when_missed;
    else
        return 0;
}

bool edf_misses_deadline(unsigned int num_procs,
                         TaskSet &ts,
                         unsigned long end_of_simulation)
{
    DeadlineMissSearch sim(num_procs);

    run_periodic_simulation(sim, ts, end_of_simulation);
    return sim.deadline_was_missed();
}


Stats edf_observe_tardiness(unsigned int num_procs,
                            TaskSet &ts,
                            unsigned long end_of_simulation)
{
    Tardiness sim(num_procs);

    run_periodic_simulation(sim, ts, end_of_simulation);

    return sim.stats;
}