/shark/trunk/ports/first/modules/pistar.c |
---|
20,11 → 20,11 |
/** |
------------ |
CVS : $Id: pistar.c,v 1.8 2004-09-08 16:51:34 giacomo Exp $ |
CVS : $Id: pistar.c,v 1.9 2004-10-25 14:39:31 trimarchi Exp $ |
File: $File$ |
Revision: $Revision: 1.8 $ |
Last update: $Date: 2004-09-08 16:51:34 $ |
Revision: $Revision: 1.9 $ |
Last update: $Date: 2004-10-25 14:39:31 $ |
------------ |
Priority Inhertitance protocol. see pi.h for more details... |
61,8 → 61,9 |
#include <kernel/descr.h> |
#include <kernel/var.h> |
#include <kernel/func.h> |
#include <fsf_contract.h> |
#include <fsf_server.h> |
#include "fsf_configuration_parameters.h" |
#include "fsf_core.h" |
#include "fsf_server.h" |
#include <pistar.h> |
#include <tracer.h> |
158,7 → 159,7 |
return 0; |
} |
#if defined OLD_VERSION |
/* Note that in this approach, when unlocking we can't wake up only |
one thread, but we have to wake up all the blocked threads, because there |
is not a concept of priority between the task... Each woken thread have |
212,7 → 213,7 |
/* ... and reaquire the cli() before the test... */ |
kern_cli(); |
} |
fsf_get_server(&server, exec_shadow); |
fsf_get_server(exec_shadow, &server); |
if (fsf_get_remain_budget(server)>wcet) cond=0; |
else { |
SERVER_disable_server(fsf_get_server_level(),server); |
239,7 → 240,72 |
return 0; |
} |
#else |
int PISTAR_lock(RLEVEL l, mutex_t *m) |
{ |
PISTAR_mutex_resource_des *lev = (PISTAR_mutex_resource_des *)(resource_table[l]); |
PISTAR_mutex_t *p; |
SYS_FLAGS f; |
// return 0; |
int cond; |
cond = 1; |
fsf_server_id_t server; |
f = kern_fsave(); |
TRACER_LOGEVENT(FTrace_EVT_set_mutex_lock,(unsigned short int)proc_table[exec_shadow].context,(unsigned int)m); |
//kern_printf("(PISTAR lock)"); |
p = (PISTAR_mutex_t *)m->opt; |
if (!p) { |
/* if the mutex is not initialized, return an error! */ |
kern_frestore(f); |
return (EINVAL); |
} |
if (p->owner == exec_shadow) { |
/* the task already owns the mutex */ |
kern_frestore(f); |
return (EDEADLK); |
} |
while (p->owner != NIL) { |
/* the mutex is locked by someone, "block" the task ...*/ |
proc_table[exec_shadow].shadow = p->owner; |
lev->blocked[exec_shadow] = p->firstblocked; |
p->firstblocked = exec_shadow; |
p->nblocked++; |
// kern_printf("<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<"); |
/* ... call the scheduler... */ |
scheduler(); |
TRACER_LOGEVENT(FTrace_EVT_inheritance,(unsigned short int)proc_table[exec_shadow].context,(unsigned int)proc_table[exec].context); |
kern_context_load(proc_table[exec_shadow].context); |
/* ... and reaquire the cli() before the test... */ |
kern_cli(); |
} |
/* if we are here, we have budget for critical section */ |
/* Set the task no preemptive for the localscheduler */ |
//kern_printf("(PISTAR NP %d", exec_shadow); |
fsf_get_server(exec_shadow, &server); |
fsf_settask_nopreemptive(&server, exec_shadow); |
/* the mutex is free, We can lock it! */ |
lev->nlocked[exec_shadow]++; |
p->owner = exec_shadow; |
kern_frestore(f); |
return 0; |
} |
#endif |
static int PISTAR_trylock(RLEVEL l, mutex_t *m) |
{ |
PISTAR_mutex_t *p; |
317,7 → 383,7 |
}*/ |
/* Set the task preemptive for the localscheduler */ |
fsf_get_server(&server, exec_shadow); |
fsf_get_server(exec_shadow, &server); |
fsf_settask_preemptive(&server, exec_shadow); |
scheduler(); |
352,7 → 418,7 |
/* fill the mutex_resource_des descriptor */ |
m->m.init = PISTAR_init; |
m->m.destroy = PISTAR_destroy; |
m->m.lock = NULL; |
m->m.lock = PISTAR_lock; |
m->m.trylock = PISTAR_trylock; |
m->m.unlock = PISTAR_unlock; |
/shark/trunk/ports/first/modules/edfstar.c |
---|
53,7 → 53,8 |
#include <kernel/iqueue.h> |
/* for BUDGET_TASK_MODEL */ |
#include "fsf_contract.h" |
#include "fsf_configuration_parameters.h" |
#include "fsf_core.h" |
#include "fsf_server.h" |
/* |
/shark/trunk/ports/first/modules/rmstar.c |
---|
51,9 → 51,11 |
/* #include "iqueue.h" Now iqueues are the only queue type into the kernel */ |
/* for BUDGET_TASK_MODEL */ |
#include "fsf_contract.h" |
#include "fsf_configuration_parameters.h" |
#include "fsf_core.h" |
#include "fsf_server.h" |
/* |
* DEBUG stuffs begin |
*/ |
/shark/trunk/ports/first/modules/grubstar.c |
---|
47,6 → 47,12 |
TIME Q; /* Budget */ |
TIME T; /* Period */ |
TIME D; /* Deadline */ |
/* Negotiate parameter */ |
TIME N_Q; /* Negotiate budget */ |
TIME N_T; /* Negotiate Period */ |
TIME N_D; /* Negotiate Deadline */ |
bandwidth_t Ub; /* Bandwidth */ |
struct timespec dline; /* deadline */ |
63,6 → 69,7 |
PID current; /* the task currently put in execution */ |
int flags; |
int negotiation; |
IQUEUE tasks; /* a FIFO queue for the tasks handled |
using the budget */ |
87,6 → 94,7 |
int cap_lev; |
struct timespec cap_lasttime; |
int negotiation_in_progress; |
LEVEL scheduling_level; |
108,6 → 116,19 |
b->replenish_timer = NIL; |
b->last_reclaiming = 0; |
if (b->negotiation) { |
lev->negotiation_in_progress--; |
b->negotiation=0; |
b->Q=b->N_Q; |
b->T=b->N_T; |
b->D=b->N_D; |
b->N_Q=0; |
b->N_T=0; |
b->N_D=0; |
} |
b->avail += b->Q; |
if (b->avail > b->Q) b->avail = b->Q; |
214,6 → 235,18 |
ADDUSEC2TIMESPEC(b->T, &b->replenish); |
TIMESPEC_ASSIGN(&b->dline, acttime); |
ADDUSEC2TIMESPEC(b->D, &b->dline); |
if (b->negotiation) { |
lev->negotiation_in_progress--; |
b->negotiation=0; |
b->Q=b->N_Q; |
b->T=b->N_T; |
b->D=b->N_D; |
b->N_Q=0; |
b->N_T=0; |
b->N_D=0; |
} |
b->avail = b->Q; |
b->last_reclaiming = 0; |
} |
322,6 → 355,17 |
ADDUSEC2TIMESPEC(b->T, &b->replenish); |
/* and the capacity */ |
if (b->negotiation) { |
lev->negotiation_in_progress--; |
b->negotiation=0; |
b->Q=b->N_Q; |
b->T=b->N_T; |
b->D=b->N_D; |
b->N_Q=0; |
b->N_T=0; |
b->N_D=0; |
} |
b->avail = b->Q; |
b->last_reclaiming = 0; |
600,6 → 644,11 |
lev->b[i].Q = 0; |
lev->b[i].T = 0; |
lev->b[i].D = 0; |
lev->b[i].N_Q = 0; |
lev->b[i].N_T = 0; |
lev->b[i].N_D = 0; |
lev->b[i].Ub = 0; |
NULL_TIMESPEC(&lev->b[i].dline); |
NULL_TIMESPEC(&lev->b[i].replenish); |
610,6 → 659,7 |
lev->b[i].flags = GRUBSTAR_ACTIVE; |
lev->b[i].l = l; |
lev->b[i].last_reclaiming = 0; |
lev->b[i].negotiation = 0; |
iq_init(&lev->b[i].tasks, NULL, 0); |
} |
619,6 → 669,7 |
for (i=0; i<MAX_PROC; i++) |
lev->tb[i] = NIL; |
lev->negotiation_in_progress=0; |
lev->U = 0; |
lev->Uf = 0; |
lev->cap_lev = NIL; |
655,12 → 706,18 |
lev->b[r].Q = Q; |
lev->b[r].T = T; |
lev->b[r].D = D; |
lev->b[r].N_Q = 0; |
lev->b[r].N_T = 0; |
lev->b[r].N_D = 0; |
lev->b[r].negotiation=0; |
lev->b[r].Ub = b; |
lev->b[r].avail = Q; |
lev->b[r].flags = GRUBSTAR_RECLAIMING; |
lev->b[r].loc_sched_id = scheduler_id; |
lev->b[r].loc_sched_level = local_scheduler_level; |
lev->b[r].last_reclaiming = 0; |
lev->b[r].last_reclaiming = 0; |
return r; |
} |
686,6 → 743,13 |
lev->b[budget].Q = 0; |
lev->b[budget].T = 0; |
lev->b[budget].D = 0; |
lev->b[budget].N_Q = 0; |
lev->b[budget].N_T = 0; |
lev->b[budget].N_D = 0; |
lev->b[budget].negotiation=0; |
lev->b[budget].Ub = 0; |
NULL_TIMESPEC(&lev->b[budget].dline); |
NULL_TIMESPEC(&lev->b[budget].replenish); |
714,10 → 778,24 |
lev->U -= b; |
if (lev->b[budget].flags != GRUBSTAR_RECLAIMING) lev->Uf -= b; |
lev->b[budget].Q = Q; |
lev->b[budget].T = T; |
lev->b[budget].D = D; |
lev->b[budget].N_Q = Q; |
lev->b[budget].N_T = T; |
lev->b[budget].N_D = D; |
if (lev->b[budget].current!=NIL) { |
lev->b[budget].N_Q = Q; |
lev->b[budget].N_T = T; |
lev->b[budget].N_D = D; |
if (!lev->b[budget].negotiation) { |
lev->negotiation_in_progress++; |
lev->b[budget].negotiation=1; |
} |
} else { |
lev->b[budget].Q = Q; |
lev->b[budget].T = T; |
lev->b[budget].D = D; |
} |
mul32div32to32(MAX_BANDWIDTH,Q,T,lev->b[budget].Ub); |
lev->U += lev->b[budget].Ub; |
740,13 → 818,16 |
{ |
GRUBSTAR_level_des *lev = (GRUBSTAR_level_des *)(level_table[l]); |
*Q = lev->b[budget].Q; |
*T = lev->b[budget].T; |
*D = lev->b[budget].D; |
return 0; |
if (lev->b[budget].Q) { |
if (Q) *Q = lev->b[budget].Q; |
if (T) *T = lev->b[budget].T; |
if (D) *D = lev->b[budget].D; |
return 0; |
} |
return -1; |
} |
int GRUBSTAR_get_last_reclaiming(LEVEL l, PID p) |
835,4 → 916,10 |
} |
int GRUBSTAR_get_renegotiation_status(LEVEL l, int budget) |
{ |
GRUBSTAR_level_des *lev = (GRUBSTAR_level_des *)(level_table[l]); |
if (lev->negotiation_in_progress) return 1; |
else return 0; |
} |
/shark/trunk/ports/first/modules/nonestar.c |
---|
43,12 → 43,16 |
#include <kernel/var.h> |
#include <kernel/func.h> |
#include "nonestar.h" |
#include "fsf_contract.h" |
#include "fsf_configuration_parameters.h" |
#include "fsf_core.h" |
#include "fsf_server.h" |
#include "tracer.h" |
#include <modules/comm_message.h> |
#define NONESTAR_DEBUG |
//#define NONESTAR_DEBUG |
#define NONESTAR_CHANGE_LEVEL 1 |
/*+ Status used in the level +*/ |
#define NONESTAR_READY MODULE_STATUS_BASE |
63,8 → 67,10 |
int budget; |
int current; |
int status; |
int flag; |
int scheduling_level; |
int new_level[MAX_PROC]; |
} NONESTAR_level_des; |
80,16 → 86,18 |
static int NONESTAR_public_create(LEVEL l, PID p, TASK_MODEL *m) |
{ |
NONESTAR_level_des *lev = (NONESTAR_level_des *)(level_table[l]); |
#ifdef NONESTAR_DEBUG |
kern_printf("(NN:Crt:%d)",p); |
#endif |
if (m->pclass != DUMMY_PCLASS) return -1; |
if (m->level != 0 && m->level != l) return -1; |
if (lev->current != NIL) return -1; |
if (m->level != 0 && m->level != l) return -1; |
if (lev->current != NIL) return -1; |
lev->current = p; |
lev->flag = 0; |
lev->status = NONESTAR_IDLE; |
proc_table[p].avail_time = lev->server_Q; |
115,15 → 123,48 |
} |
static int NONESTAR_change_level(LEVEL l, PID p) |
{ |
NONESTAR_level_des *lev = (NONESTAR_level_des *)(level_table[l]); |
/* Change task level */ |
if (lev->flag & NONESTAR_CHANGE_LEVEL) { |
STD_command_message msg; |
proc_table[p].status = SLEEP; |
lev->current=NIL; |
lev->budget = -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 NONESTAR_public_epilogue(LEVEL l, PID p) |
{ |
NONESTAR_level_des *lev = (NONESTAR_level_des *)(level_table[l]); |
int r; |
//int r; |
#ifdef NONESTAR_DEBUG |
kern_printf("(NN:Epi:%d)",p); |
#endif |
if (NONESTAR_change_level(l, p)) return; |
level_table[ lev->scheduling_level ] -> |
private_epilogue(lev->scheduling_level,p); |
/* |
164,7 → 205,18 |
static void NONESTAR_public_unblock(LEVEL l, PID p) |
{ |
NONESTAR_level_des *lev = (NONESTAR_level_des *)(level_table[l]); |
BUDGET_TASK_MODEL b; |
#ifdef NONESTAR_DEBUG |
kern_printf("(NS:pu)"); |
#endif |
lev->current=p; |
budget_task_default_model(b, lev->budget); |
level_table[ lev->scheduling_level ]-> |
private_insert(lev->scheduling_level, p, (TASK_MODEL *)&b); |
} |
static void NONESTAR_public_block(LEVEL l, PID p) |
171,11 → 223,23 |
{ |
NONESTAR_level_des *lev = (NONESTAR_level_des *)(level_table[l]); |
#ifdef NONESTAR_DEBUG |
kern_printf("(NN:pb)"); |
#endif |
/* the task is blocked on a synchronization primitive. we have to |
remove it from the master module -and- from the local queue! */ |
lev->current=NIL; |
level_table[ lev->scheduling_level ]-> |
private_extract(lev->scheduling_level, p); |
} |
static int NONESTAR_public_message(LEVEL l, PID p, void *m) |
{ |
NONESTAR_level_des *lev = (NONESTAR_level_des *)(level_table[l]); |
NONESTAR_level_des *lev = (NONESTAR_level_des *)(level_table[l]); |
STD_command_message *msg; |
DUMMY_TASK_MODEL *h; |
switch ((long)(m)) { |
204,9 → 268,44 |
break; |
default: |
msg = (STD_command_message *)m; |
switch(msg->command) { |
case STD_SET_NEW_MODEL: |
/* if the NONESTAR_task_create is called, then the pclass must be a |
valid pclass. */ |
h=(DUMMY_TASK_MODEL *)(msg->param); |
/* now we know that m is a valid model */ |
lev->flag = 0; |
lev->current = p; |
lev->status = NONESTAR_IDLE; |
break; |
case STD_SET_NEW_LEVEL: |
lev->flag |= NONESTAR_CHANGE_LEVEL; |
lev->new_level[p] = (int)(msg->param); |
break; |
case STD_ACTIVATE_TASK: |
/* Enable wcet check */ |
proc_table[p].avail_time = lev->server_Q; |
proc_table[p].wcet = lev->server_Q; |
proc_table[p].control = (proc_table[p].control & ~CONTROL_CAP); |
NONESTAR_public_activate(l, p, NULL); |
break; |
} |
break; |
} |
255,6 → 354,7 |
lev->budget = NIL; |
lev->current = NIL; |
lev->flag = 0; |
lev->status = NONESTAR_IDLE; |
lev->server_Q = 0; |
lev->server_T = 0; |
/shark/trunk/ports/first/modules/posixstar.c |
---|
43,7 → 43,8 |
#include <kernel/var.h> |
#include <kernel/func.h> |
#include "posixstar.h" |
#include "fsf_contract.h" |
#include "fsf_configuration_parameters.h" |
#include "fsf_core.h" |
#include "fsf_server.h" |
//#define POSIXSTAR_DEBUG |