Subversion Repositories shark

Compare Revisions

Ignore whitespace Rev 875 → Rev 876

/shark/trunk/ports/first/modules/edfstar.c
56,7 → 56,9
#include "fsf_configuration_parameters.h"
#include "fsf_core.h"
#include "fsf_server.h"
#include <modules/comm_message.h>
 
 
/*
* DEBUG stuffs begin
*/
122,6 → 124,9
int cap_lev;
struct timespec cap_lasttime;
 
int new_level[MAX_PROC];
int wcet[MAX_PROC]; /* save the wcet fields */
 
} EDFSTAR_level_des;
 
223,6 → 228,46
 
}
 
static int EDFSTAR_private_change_level(LEVEL l, PID p)
{
 
EDFSTAR_level_des *lev = (EDFSTAR_level_des *)(level_table[l]);
 
/* Change task level */
if (lev->flag[p] & EDFSTAR_CHANGE_LEVEL) {
STD_command_message msg;
proc_table[p].status = SLEEP;
level_table[lev->scheduling_level]->private_extract(lev->scheduling_level,p);
iq_extract(p,&lev->ready);
if (lev->deadline_timer[p] != -1)
kern_event_delete(lev->deadline_timer[p]);
EDFSTAR_check_preemption(lev);
lev->nact[p] = 0;
lev->budget[p] = -1;
proc_table[p].task_level = lev->new_level[p];
/* Send change level command to local scheduler */
 
msg.command = STD_ACTIVATE_TASK;
msg.param = NULL;
 
level_table[ lev->new_level[p] ]->public_message(lev->new_level[p],p,&msg);
return 1;
 
}
 
return 0;
 
}
 
 
static void EDFSTAR_timer_guest_deadline(void *par)
{
PID p = (PID) par;
335,11 → 380,13
lev->cap_lev=NIL;
}
 
 
if ( proc_table[exec].task_level==l ) {
if (proc_table[exec].avail_time > 0) EDFSTAR_account_capacity(lev,exec);
 
if (EDFSTAR_private_change_level(l, p)) return;
 
/* check if the wcet is finished... */
if (proc_table[exec].avail_time < 0) {
/* wcet finished: disable wcet event and count wcet miss */
440,6 → 487,8
 
EDFSTAR_level_des *lev = (EDFSTAR_level_des *)(level_table[l]);
struct timespec temp;
STD_command_message *msg;
HARD_TASK_MODEL *h;
 
#ifdef EDFSTAR_DEBUG
edfstar_printf("(E:ecy ");
450,6 → 499,8
/* Task EndCycle */
case (long)(NULL):
 
if (EDFSTAR_private_change_level(l,p)) return 0;
 
/* we call guest_end directly here because the same task may
be reinserted in the queue before calling the preemption check! */
level_table[ lev->scheduling_level ]->
517,7 → 568,51
break;
 
default:
msg = (STD_command_message *)m;
#ifdef EDFSTAR_DEBUG
edfstar_printf("(E:MSG %d)",msg->command);
#endif
switch(msg->command) {
case STD_SET_NEW_MODEL:
/* if the EDFSTAR_task_create is called, then the pclass must be a
valid pclass. */
h=(HARD_TASK_MODEL *)(msg->param);
/* now we know that m is a valid model */
lev->wcet[p] = h->wcet;
lev->period[p] = h->mit;
lev->flag[p] = 0;
lev->deadline_timer[p] = -1;
lev->dline_miss[p] = 0;
lev->wcet_miss[p] = 0;
lev->nact[p] = 0;
 
break;
 
case STD_SET_NEW_LEVEL:
lev->flag[p] |= EDFSTAR_CHANGE_LEVEL;
lev->new_level[p] = (int)(msg->param);
 
break;
 
case STD_ACTIVATE_TASK:
/* Enable wcet check */
proc_table[p].avail_time = lev->wcet[p];
proc_table[p].wcet = lev->wcet[p];
proc_table[p].control &= ~CONTROL_CAP;
EDFSTAR_public_activate(l, p,NULL);
break;
 
}
 
break;
}
/shark/trunk/ports/first/modules/posixstar.c
46,6 → 46,7
#include "fsf_configuration_parameters.h"
#include "fsf_core.h"
#include "fsf_server.h"
#include <modules/comm_message.h>
 
//#define POSIXSTAR_DEBUG
 
78,6 → 79,10
 
int flag[MAX_PROC];
 
int new_level[MAX_PROC];
int new_slice[MAX_PROC];
int new_control[MAX_PROC];
 
PID activated;
int scheduling_level;
int cap_lev;
266,6 → 271,38
}
 
static int POSIXSTAR_private_change_level(LEVEL l, PID p)
{
 
POSIXSTAR_level_des *lev = (POSIXSTAR_level_des *)(level_table[l]);
 
/* Change task level */
if (lev->flag[p] & POSIXSTAR_CHANGE_LEVEL) {
STD_command_message msg;
proc_table[p].status = SLEEP;
 
level_table[lev->scheduling_level]->private_extract(lev->scheduling_level,p);
iq_extract(p,&lev->ready[lev->priority[p]]);
 
POSIXSTAR_private_scheduler(lev);
 
lev->nact[p] = 0;
lev->budget[p] = -1;
proc_table[p].task_level = lev->new_level[p];
msg.command = STD_ACTIVATE_TASK;
level_table[lev->new_level[p]] -> public_message(lev->new_level[p],p,&msg);
 
return 1;
 
}
 
return 0;
 
}
 
static void POSIXSTAR_public_epilogue(LEVEL l, PID p)
{
POSIXSTAR_level_des *lev = (POSIXSTAR_level_des *)(level_table[l]);
282,6 → 319,8
if (proc_table[exec].task_level==l ) {
POSIXSTAR_account_capacity(lev,exec);
 
if (POSIXSTAR_private_change_level(l,p)) return;
if (lev->yielding) {
lev->yielding = 0;
389,6 → 428,8
static int POSIXSTAR_public_message(LEVEL l, PID p, void *m)
{
POSIXSTAR_level_des *lev = (POSIXSTAR_level_des *)(level_table[l]);
STD_command_message *msg;
NRT_TASK_MODEL *nrt;
 
#ifdef POSIXSTAR_DEBUG
kern_printf("(PS:Msg:%d)",p);
399,6 → 440,8
/* Task EndCycle */
case (long)(NULL):
 
if (POSIXSTAR_private_change_level(l,p)) return 0;
 
if (lev->nact[p] > 0) {
/* continue!!!! */
lev->nact[p]--;
423,6 → 466,56
 
default:
 
msg = (STD_command_message *)m;
 
switch(msg->command) {
case STD_SET_NEW_LEVEL:
lev->flag[p] |= POSIXSTAR_CHANGE_LEVEL;
lev->new_level[p] = (int)(msg->param);
 
break;
case STD_SET_NEW_MODEL:
 
nrt = (NRT_TASK_MODEL *)(msg->param);
 
lev->priority[p] = nrt->weight;
if (nrt->slice) {
lev->new_slice[p] = nrt->slice;
} else {
lev->new_slice[p] = 0;
}
if (nrt->policy == NRT_RR_POLICY)
lev->new_control[p] &= ~CONTROL_CAP;
if (nrt->arrivals == SAVE_ARRIVALS)
lev->nact[p] = 0;
else
lev->nact[p] = -1;
lev->flag[p] = 0;
 
break;
case STD_ACTIVATE_TASK:
 
if (lev->new_slice[p]) {
proc_table[p].avail_time = lev->new_slice[p];
proc_table[p].wcet = lev->new_slice[p];
} else {
proc_table[p].avail_time = lev->slice;
proc_table[p].wcet = lev->slice;
}
 
proc_table[p].control |= lev->new_control[p];
 
POSIXSTAR_public_activate(l,p,NULL);
 
break;
}
 
break;
}
485,6 → 578,12
for (i = 0; i < MAX_PROC; i++) {
lev->nact[i] = -1;
lev->budget[i] = -1;
 
lev->flag[i] = 0;
lev->new_level[i] = 0;
lev->new_slice[i] = 0;
lev->new_control[i] = 0;
}
 
lev->maxpriority = prioritylevels - 1;