linux edf

start ¡ûclock();
while (true)
{
execute();
start¡ûstart +period;
delay until start;
}

...
menu "CASIO scheduler"
config SCHED_EDF_POLICY

bool "EDF scheduling policy"
default y
endmenu
...
#define SCHED_NORMAL    0
#define SCHED_FIFO      1
#define SCHED_RR        2
...
#ifdef CONFIG_SCHED_EDF_POLICY
#define SCHED_EDF       6
#endif
...

struct task_struct{
...
#ifdef CONFIG_SCHED_EDF_POLICY
unsigned int edf_id;
unsigned long long deadline;
#endif // CONFIG_SCHED_EDF_POLICY
};
#ifdef CONFIG_SCHED_EDF_POLICY
struct edf_task{
struct rb_node edf_node;
unsigned long long cl;
unsigned long long ch;
unsigned long long period;
int level;
struct task_struct *task;

};
struct edf_rq{
struct rb_root edf_root;
struct list_head edf_list;
atomic_t nr_running;
};
#endif // CONFIG_SCHED_EDF_POLICY
struct rq{
...
#ifdef CONFIG_SCHED_EDF_POLICY
struct edf_rq edf_rq;
#endif // CONFIG_SCHED_EDF_POLICY
...
};
void __init sched_init(void)
{
...
for_each_possible_cpu(1){
...
struct rq *rq;
...

rq=cpu_rq(1);
...
#ifdef CONFIG_SCHED_EDF_POLICY
init_edf_rq(&rq->edf_rq);
#endif // CONFIG_SCHED_EDF_POLICY
...
}
}
const struct shced_class edf_sched_class={
.next      =&rt_sched_class,
.enqueue_task =enqueue_task_edf,
.dequeue_task =dequeue_task_edf,
.check_preempt_curr=check_preempt_curr_edf,
.pick_next_task=pick_next_task_edf,
...
};
static void enqueue_task_edf(struct rq*rq ,struct task-struct *p,int wakeup)
{
struct edf_task *t=NULL;
if(p)
{
t=find_edf_task_list(&rq->edf_rq,p);
if(t)
{
t->deadline=sched_clock()+p->period;
Insert_edf_task_rb_tree(&rq->edf_rq,t);
atomic_inc(&rq->edf_rq,nr_running);
}
}

}
static void dequeue_task_edf(struct rq *rq,struct task_struct *p,int sleep)
{
struct edf_task *t=NULL;
if(p){
t=find_edf_task_list(rq->edf_rq,p);
if(t){
remove_edf_task_rb_tree(&rq->edf_rq,t);
atomic_dec(&rq->edf_rq,nr_running);
if(t->task->state==Task_DEAD||t->task->state==EXIT_DEAD||
t->task->state==EXIT_ZOMBIE)
{
rem_edf_task_list(&rq->edf_rq,t->task);
}
}
}
}

static void check_preempt_curr_edf(struct rq *rq, struct task_struct *p)
{
struct edf_task *t=NULL,*curr=NULL;
if(rq->curr->policy!=SCHED_EDF){
resched_task(rq->curr);
}
else{
t=earliest_deadline_edf_task_rb_tree(&rq->edf_rq);
if(t){
curr=find_edf_task_list(&rq->edf_rq,rq->curr);
if(curr){
if(t->deadline < curr->deadline)
resched_task(rq->curr);
}
else{
printk(KERN_ALERT "check_preempt_curr_edf\n");
}
}
}

}

static struct task_struct *pick_next_task_edf(struct rq *rq)
{

struct edf_task *t=NULL;
t=earliest_deadline_edf_task_rb_tree(&rq->edf_rq);
if(t){
return t->task;
}
return NULL;
}
...
#ifdef CONFIG_SCHED_EDF_POLICY
#include "sched_edf.c"
#endif // CONFIG_SCHED_EDF_POLICY

#ifdef CONFIG_SCHED_EDF_POLICY
#define sched_class_highest(&edf_sched_class)
#else
#define sched_class_highest(&rt_sched_class)
#endif // CONFIG_SCHED_EDF_POLICY

struct sched_param{
int sched_priorty;
#ifdef CONFIG_SCHED_EDF_POLICY
unsigned int edf_id;
unsigned long long deadline;
unsigned int level;
#endif // CONFIG_SCHED_EDF_POLICY

};
static inline int rt_policy(int policy)
{
if(unlikely(policy==SCHED_FIFO)
||unlikely(policy==SCHED_FIFO)
#ifdef CONFIG_SCHED_EDF_POLICY
||unlikely(policy==SCHED_EDF)
#endif // CONFIG_SCHED_EDF_POLICY
)
return 1;
return 0;
}
static void __setscheduler(struct rq *rq,struct task_struct *p,int policy,int prio)
{
...
p->policy=policy;
switch(p->policy){
...
#ifdef CONFIG_SCHED_EDF_POLICY
case SCHED_EDF:
p->sched_class=&edf_sched_class;
break;
#endif // CONFIG_SCHED_EDF_POLICY
}
...
}