Subversion Repositories shark

Compare Revisions

Ignore whitespace Rev 866 → Rev 867

/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