18,11 → 18,11 |
|
/** |
------------ |
CVS : $Id: static.c,v 1.1.1.1 2002-09-02 09:37:48 pj Exp $ |
CVS : $Id: static.c,v 1.4 2003-01-07 17:10:18 pj Exp $ |
|
File: $File$ |
Revision: $Revision: 1.1.1.1 $ |
Last update: $Date: 2002-09-02 09:37:48 $ |
Revision: $Revision: 1.4 $ |
Last update: $Date: 2003-01-07 17:10:18 $ |
------------ |
**/ |
|
68,7 → 68,7 |
typedef struct { |
level_des l; /*+ the standard level descriptor +*/ |
|
QUEUE mytable; |
IQUEUE mytable; |
|
PID currenttask; |
|
87,7 → 87,7 |
lev->currenttask = p; |
event_need_reschedule(); |
|
STATIC_printf("(o p%d t%d)", p, (int)proc_table[p].timespec_priority.tv_sec); |
// STATIC_printf("(o p%d t%d)", p, (int)proc_table[p].timespec_priority.tv_sec); |
} |
|
static void STATIC_activateall(STATIC_level_des *lev) |
97,15 → 97,15 |
|
STATIC_printf("(A "); |
|
for (my_table_index = (PID)lev->mytable; |
for (my_table_index = iq_query_first(&lev->mytable); |
my_table_index != NIL; |
my_table_index = proc_table[my_table_index].next) { |
ADDTIMESPEC(&lev->ref,&proc_table[my_table_index].timespec_priority,&x); |
my_table_index = iq_query_next(my_table_index, &lev->mytable)) { |
ADDTIMESPEC(&lev->ref,iq_query_timespec(my_table_index, &lev->mytable),&x); |
kern_event_post(&x, STATIC_offset_activate,(void *)my_table_index); |
|
STATIC_printf("|p%d t%d ", |
my_table_index, |
(int)proc_table[my_table_index].timespec_priority.tv_sec); |
(int)iq_query_timespec(my_table_index, &lev->mytable)->tv_sec); |
} |
|
STATIC_printf(")"); |
130,26 → 130,8 |
} |
|
|
static int STATIC_level_accept_task_model(LEVEL l, TASK_MODEL *m) |
{ |
if (m->pclass == STATIC_PCLASS || m->pclass == (STATIC_PCLASS | l)) |
return 0; |
|
return -1; |
} |
|
static int STATIC_level_accept_guest_model(LEVEL l, TASK_MODEL *m) |
{ |
return -1; |
} |
|
|
|
static void STATIC_level_status(LEVEL l) |
{ kern_raise(XUNVALID_TASK,exec_shadow); } |
|
/* The scheduler only gets the first task in the queue */ |
static PID STATIC_level_scheduler(LEVEL l) |
static PID STATIC_public_scheduler(LEVEL l) |
{ |
STATIC_level_des *lev = (STATIC_level_des *)(level_table[l]); |
|
156,14 → 138,8 |
return lev->currenttask; |
} |
|
/* The on-line guarantee is enabled only if the appropriate flag is set... */ |
static int STATIC_level_guarantee(LEVEL l, bandwidth_t *freebandwidth) |
static int STATIC_public_create(LEVEL l, PID p, TASK_MODEL *m) |
{ |
return 1; |
} |
|
static int STATIC_task_create(LEVEL l, PID p, TASK_MODEL *m) |
{ |
STATIC_level_des *lev = (STATIC_level_des *)(level_table[l]); |
|
/* if the STATIC_task_create is called, then the pclass must be a |
171,110 → 147,66 |
|
STATIC_TASK_MODEL *h = (STATIC_TASK_MODEL *)m; |
|
proc_table[p].timespec_priority.tv_sec = h->offset.tv_sec; |
proc_table[p].timespec_priority.tv_nsec = h->offset.tv_nsec; |
q_timespec_insert(p,&lev->mytable); |
if (m->pclass != STATIC_PCLASS) return -1; |
if (m->level != 0 && m->level != l) return -1; |
|
iq_query_timespec(p, &lev->mytable)->tv_sec = h->offset.tv_sec; |
iq_query_timespec(p, &lev->mytable)->tv_nsec = h->offset.tv_nsec; |
iq_timespec_insert(p,&lev->mytable); |
|
return 0; /* OK, also if the task cannot be guaranteed... */ |
} |
|
static void STATIC_task_detach(LEVEL l, PID p) |
static void STATIC_public_dispatch(LEVEL l, PID p, int nostop) |
{ |
} |
|
static int STATIC_task_eligible(LEVEL l, PID p) |
static void STATIC_public_epilogue(LEVEL l, PID p) |
{ |
return 0; /* if the task p is chosen, it is always eligible */ |
} |
|
static void STATIC_task_dispatch(LEVEL l, PID p, int nostop) |
static void STATIC_public_activate(LEVEL l, PID p) |
{ |
} |
|
static void STATIC_task_epilogue(LEVEL l, PID p) |
static void STATIC_public_unblock(LEVEL l, PID p) |
{ |
} |
|
static void STATIC_task_activate(LEVEL l, PID p) |
static void STATIC_public_block(LEVEL l, PID p) |
{ |
} |
|
static void STATIC_task_insert(LEVEL l, PID p) |
static int STATIC_public_message(LEVEL l, PID p, void *m) |
{ |
} |
STATIC_level_des *lev = (STATIC_level_des *)(level_table[l]); |
|
static void STATIC_task_extract(LEVEL l, PID p) |
{ |
} |
lev->currenttask = NIL; |
|
static void STATIC_task_endcycle(LEVEL l, PID p) |
{ |
STATIC_level_des *lev = (STATIC_level_des *)(level_table[l]); |
jet_update_endcycle(); /* Update the Jet data... */ |
trc_logevent(TRC_ENDCYCLE,&exec_shadow); /* tracer stuff */ |
|
lev->currenttask = NIL; |
return 0; |
} |
|
static void STATIC_task_end(LEVEL l, PID p) |
static void STATIC_public_end(LEVEL l, PID p) |
{ |
STATIC_level_des *lev = (STATIC_level_des *)(level_table[l]); |
|
lev->currenttask = NIL; |
|
q_extract(p,&lev->mytable); |
iq_extract(p,&lev->mytable); |
|
/* we finally put the task in the ready queue */ |
proc_table[p].status = FREE; |
q_insertfirst(p,&freedesc); |
iq_insertfirst(p,&freedesc); |
} |
|
static void STATIC_task_sleep(LEVEL l, PID p) |
{ kern_raise(XUNVALID_TASK,exec_shadow); } |
|
static void STATIC_task_delay(LEVEL l, PID p, TIME usdelay) |
{ kern_raise(XUNVALID_TASK,exec_shadow); } |
|
/* Guest Functions |
These functions manages a JOB_TASK_MODEL, that is used to put |
a guest task in the STATIC ready queue. */ |
|
static int STATIC_guest_create(LEVEL l, PID p, TASK_MODEL *m) |
{ kern_raise(XUNVALID_GUEST,exec_shadow); return 0; } |
|
static void STATIC_guest_detach(LEVEL l, PID p) |
{ kern_raise(XUNVALID_GUEST,exec_shadow); } |
|
static void STATIC_guest_dispatch(LEVEL l, PID p, int nostop) |
{ kern_raise(XUNVALID_GUEST,exec_shadow); } |
|
static void STATIC_guest_epilogue(LEVEL l, PID p) |
{ kern_raise(XUNVALID_GUEST,exec_shadow); } |
|
static void STATIC_guest_activate(LEVEL l, PID p) |
{ kern_raise(XUNVALID_GUEST,exec_shadow); } |
|
static void STATIC_guest_insert(LEVEL l, PID p) |
{ kern_raise(XUNVALID_GUEST,exec_shadow); } |
|
static void STATIC_guest_extract(LEVEL l, PID p) |
{ kern_raise(XUNVALID_GUEST,exec_shadow); } |
|
static void STATIC_guest_endcycle(LEVEL l, PID p) |
{ kern_raise(XUNVALID_GUEST,exec_shadow); } |
|
static void STATIC_guest_end(LEVEL l, PID p) |
{ kern_raise(XUNVALID_GUEST,exec_shadow); } |
|
static void STATIC_guest_sleep(LEVEL l, PID p) |
{ kern_raise(XUNVALID_GUEST,exec_shadow); } |
|
static void STATIC_guest_delay(LEVEL l, PID p, TIME usdelay) |
{ kern_raise(XUNVALID_GUEST,exec_shadow); } |
|
/* Registration functions */ |
|
/*+ Registration function: |
int flags the init flags ... see STATIC.h +*/ |
void STATIC_register_level() |
LEVEL STATIC_register_level() |
{ |
LEVEL l; /* the level that we register */ |
STATIC_level_des *lev; /* for readableness only */ |
282,62 → 214,32 |
printk("STATIC_register_level\n"); |
|
/* request an entry in the level_table */ |
l = level_alloc_descriptor(); |
l = level_alloc_descriptor(sizeof(STATIC_level_des)); |
|
printk(" alloco descrittore %d %d\n",l,(int)sizeof(STATIC_level_des)); |
lev = (STATIC_level_des *)level_table[l]; |
|
/* alloc the space needed for the STATIC_level_des */ |
lev = (STATIC_level_des *)kern_alloc(sizeof(STATIC_level_des)); |
|
printk(" lev=%d\n",(int)lev); |
|
/* update the level_table with the new entry */ |
level_table[l] = (level_des *)lev; |
|
/* fill the standard descriptor */ |
strncpy(lev->l.level_name, STATIC_LEVELNAME, MAX_LEVELNAME); |
lev->l.level_code = STATIC_LEVEL_CODE; |
lev->l.level_version = STATIC_LEVEL_VERSION; |
lev->l.public_scheduler = STATIC_public_scheduler; |
lev->l.public_create = STATIC_public_create; |
lev->l.public_end = STATIC_public_end; |
lev->l.public_dispatch = STATIC_public_dispatch; |
lev->l.public_epilogue = STATIC_public_epilogue; |
lev->l.public_activate = STATIC_public_activate; |
lev->l.public_unblock = STATIC_public_unblock; |
lev->l.public_block = STATIC_public_block; |
lev->l.public_message = STATIC_public_message; |
|
lev->l.level_accept_task_model = STATIC_level_accept_task_model; |
lev->l.level_accept_guest_model = STATIC_level_accept_guest_model; |
lev->l.level_status = STATIC_level_status; |
lev->l.level_scheduler = STATIC_level_scheduler; |
|
lev->l.level_guarantee = NULL; |
|
lev->l.task_create = STATIC_task_create; |
lev->l.task_detach = STATIC_task_detach; |
lev->l.task_eligible = STATIC_task_eligible; |
lev->l.task_dispatch = STATIC_task_dispatch; |
lev->l.task_epilogue = STATIC_task_epilogue; |
lev->l.task_activate = STATIC_task_activate; |
lev->l.task_insert = STATIC_task_insert; |
lev->l.task_extract = STATIC_task_extract; |
lev->l.task_endcycle = STATIC_task_endcycle; |
lev->l.task_end = STATIC_task_end; |
lev->l.task_sleep = STATIC_task_sleep; |
lev->l.task_delay = STATIC_task_delay; |
|
lev->l.guest_create = STATIC_guest_create; |
lev->l.guest_detach = STATIC_guest_detach; |
lev->l.guest_dispatch = STATIC_guest_dispatch; |
lev->l.guest_epilogue = STATIC_guest_epilogue; |
lev->l.guest_activate = STATIC_guest_activate; |
lev->l.guest_insert = STATIC_guest_insert; |
lev->l.guest_extract = STATIC_guest_extract; |
lev->l.guest_endcycle = STATIC_guest_endcycle; |
lev->l.guest_end = STATIC_guest_end; |
lev->l.guest_sleep = STATIC_guest_sleep; |
lev->l.guest_delay = STATIC_guest_delay; |
|
/* fill the STATIC descriptor part */ |
|
lev->mytable = NIL; |
iq_init(&lev->mytable, &freedesc, 0); |
lev->currenttask = NIL; |
|
NULL_TIMESPEC(&lev->hp); |
NULL_TIMESPEC(&lev->ref); |
|
return l; |
} |
|
void STATIC_start(LEVEL l, struct timespec *h, struct timespec *o) |
346,7 → 248,7 |
struct timespec x; |
|
kern_cli(); |
ll_gettime(TIME_EXACT, &x); |
kern_gettime(&x); |
lev->hp = *h; |
|
ADDTIMESPEC(&x,o,&lev->ref); |