Subversion Repositories shark

Compare Revisions

Ignore whitespace Rev 337 → Rev 338

/shark/trunk/ports/first/include/mpegstar.h
49,5 → 49,7
int MPEGSTAR_getbudget(LEVEL l, PID p);
int MPEGSTAR_budget_has_thread(LEVEL l, int budget);
 
int MPEGSTAR_rescale(LEVEL l, TIME Q, TIME T);
 
#endif
 
/shark/trunk/ports/first/modules/mpegstar.c
46,7 → 46,7
#include "mpegstar.h"
#include "fsf_server.h"
 
#define MPEGSTAR_DEBUG
//#define MPEGSTAR_DEBUG
 
/*+ Status used in the level +*/
#define MPEGSTAR_READY MODULE_STATUS_BASE
58,12 → 58,23
int server_Q;
int server_T;
 
int budget[MAX_PROC];
int budget;
int current;
int scheduling_level;
int cap_lev;
 
} MPEGSTAR_level_des;
 
 
 
static void capacity_handler(void *l)
{
MPEGSTAR_level_des *lev = l;
lev->cap_lev = NIL;
event_need_reschedule();
}
 
static int MPEGSTAR_public_eligible(LEVEL l, PID p)
{
MPEGSTAR_level_des *lev = (MPEGSTAR_level_des *)(level_table[l]);
80,24 → 91,39
#ifdef MPEGSTAR_DEBUG
kern_printf("(MP:Crt:%d)",p);
#endif
if (m->pclass != NRT_PCLASS) return -1;
 
if (m->pclass != HARD_PCLASS) return -1;
if (m->level != 0 && m->level != l) return -1;
 
lev->current = p;
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);
proc_table[p].wcet = lev->server_Q;
proc_table[p].control = (proc_table[p].control & ~CONTROL_CAP);
return 0; /* OK */
 
}
 
static void MPEGSTAR_public_dispatch(LEVEL l, PID p, int nostop)
{
MPEGSTAR_level_des *lev = (MPEGSTAR_level_des *)(level_table[l]);
struct timespec ty;
 
#ifdef MPEGSTAR_DEBUG
kern_printf("(MS:Dsp:%d)",p);
#endif
 
if (!nostop) {
TIMESPEC_ASSIGN(&ty, &schedule_time);
 
/* ...and finally, we have to post a capacity event on exec task because the shadow_task consume
* capacity on exe task always */
ADDUSEC2TIMESPEC(proc_table[p].avail_time ,&ty);
lev->cap_lev = kern_event_post(&ty,capacity_handler, lev);
level_table[ lev->scheduling_level ] ->
private_dispatch(lev->scheduling_level, p, nostop);
}
 
}
 
104,7 → 130,15
static void MPEGSTAR_public_epilogue(LEVEL l, PID p)
{
MPEGSTAR_level_des *lev = (MPEGSTAR_level_des *)(level_table[l]);
if (lev->cap_lev!=NIL) {
kern_event_delete(lev->cap_lev);
lev->cap_lev=NIL;
}
 
#ifdef MPEGSTAR_DEBUG
kern_printf("(MS:Epi:%d)",p);
#endif
 
level_table[ lev->scheduling_level ] ->
private_epilogue(lev->scheduling_level,p);
114,10 → 148,11
{
MPEGSTAR_level_des *lev = (MPEGSTAR_level_des *)(level_table[l]);
BUDGET_TASK_MODEL b;
budget_task_default_model(b, lev->budget[p]);
 
budget_task_default_model(b, lev->budget);
#ifdef MPEGSTAR_DEBUG
kern_printf("(MP:Act:%d:%d)",p,lev->budget[p]);
kern_printf("(MP:Act:%d:%d)",p,lev->budget);
#endif
 
level_table[ lev->scheduling_level ]->
146,7 → 181,19
/* Task EndCycle */
case (long)(NULL):
 
lev->current = NIL;
 
kern_printf("(Ext %d)",p);
 
if (lev->cap_lev != NIL) {
kern_event_delete(lev->cap_lev);
lev->cap_lev = NIL;
}
 
level_table[ lev->scheduling_level ]->
private_extract(lev->scheduling_level, p);
 
level_table[ lev->scheduling_level ]->
public_message(lev->scheduling_level, p, NULL);
 
break;
180,7 → 227,6
{
LEVEL l; /* the level that we register */
MPEGSTAR_level_des *lev; /* for readableness only */
int i;
l = level_alloc_descriptor(sizeof(MPEGSTAR_level_des));
 
197,8 → 243,8
lev->l.public_message = MPEGSTAR_public_message;
lev->l.public_eligible = MPEGSTAR_public_eligible;
 
for (i=0;i<MAX_PROC;i++)
lev->budget[i] = NIL;
lev->budget = NIL;
lev->current = NIL;
 
lev->scheduling_level = master;
 
211,7 → 257,7
MPEGSTAR_level_des *lev = (MPEGSTAR_level_des *)(level_table[l]);
lev->budget[p] = budget;
lev->budget = budget;
return 0;
222,19 → 268,30
MPEGSTAR_level_des *lev = (MPEGSTAR_level_des *)(level_table[l]);
return lev->budget[p];
return lev->budget;
}
 
int MPEGSTAR_budget_has_thread(LEVEL l, int budget)
{
MPEGSTAR_level_des *lev = (MPEGSTAR_level_des *)(level_table[l]);
if (lev->budget == budget) return 1;
return 0;
 
}
 
int MPEGSTAR_rescale(LEVEL l, TIME Q, TIME T)
{
MPEGSTAR_level_des *lev = (MPEGSTAR_level_des *)(level_table[l]);
int i;
for(i = 0; i< MAX_PROC; i++)
if (lev->budget[i] == budget) return 1;
 
SERVER_adjust_budget(lev->scheduling_level,Q,T,lev->budget);
lev->server_Q = Q;
lev->server_T = T;
if (lev->current != NIL) {
proc_table[lev->current].avail_time = Q;
proc_table[lev->current].wcet = Q;
}
 
return 0;
}
/shark/trunk/ports/first/modules/grubstar.c
185,6 → 185,8
t3.tv_sec = t / 1000000;
t3.tv_nsec = (t % 1000000) * 1000;
 
kern_printf("(GS:Act %d)",p);
 
if (b->vtimer!=NIL) kern_event_delete(b->vtimer);
b->vtimer=NIL;
338,9 → 340,9
}
budget = (BUDGET_TASK_MODEL *)m;
 
#ifdef GRUBSTAR_DEBUG
//#ifdef GRUBSTAR_DEBUG
kern_printf("(GS:PriIns:%d:%d", p, budget->b);
#endif
//#endif
if (budget->b == -1)
return;
347,6 → 349,8
 
lev->tb[p] = budget->b;
 
kern_printf("(GS:Curr:%d)", lev->b[budget->b].current);
 
if (lev->b[budget->b].current == NIL && lev->b[budget->b].flags ) {
/* This is the first task in the budget,
the task have to be inserted into the master module */
360,9 → 364,9
iq_insertlast(p,&lev->b[budget->b].tasks);
}
 
#ifdef GRUBSTAR_DEBUG
//#ifdef GRUBSTAR_DEBUG
kern_printf(")");
#endif
//#endif
 
}
 
370,9 → 374,9
{
GRUBSTAR_level_des *lev = (GRUBSTAR_level_des *)(level_table[l]);
 
#ifdef GRUBSTAR_DEBUG
//#ifdef GRUBSTAR_DEBUG
kern_printf("(GS:Ext:%d)", p);
#endif
//#endif
 
/* a task is removed from execution for some reasons. It must be
that it is the first in its budget queue (only the first task in
381,6 → 385,8
/* remove the task from execution (or from the ready queue) */
if (lev->b[lev->tb[p]].current == p) {
 
kern_printf("(GS:Ext2:%d)", p);
 
GRUBSTAR_account_capacity(lev,p);
/* remove the task from the master module */
level_table[ lev->scheduling_level ]->
395,6 → 401,8
/* if so, insert the new task into the master module */
PID n;
struct timespec t;
 
kern_printf("(GS:Ext3:%d)", p);
kern_gettime(&t);
n = iq_getfirst(&lev->b[lev->tb[p]].tasks);
491,6 → 499,10
switch((long)(m)) {
 
case (long)(NULL):
//#ifdef GRUBSTAR_DEBUG
kern_printf("(GS:EndCycle:%d:%d)",p,lev->tb[p]);
//#endif
 
if (b->current == NIL && iq_query_first(&(b->tasks)) == NIL && b->flags != GRUBSTAR_RECLAIMING) {
b->flags = GRUBSTAR_RECLAIMING;
572,9 → 584,9
GRUBSTAR_level_des *lev = (GRUBSTAR_level_des *)(level_table[l]);
int r;
 
#ifdef GRUBSTAR_DEBUG
//#ifdef GRUBSTAR_DEBUG
kern_printf("(GS:SetBud)");
#endif
//#endif
 
for (r = 0; r < lev->n; r++)
if (lev->b[r].Q == 0) break;
599,6 → 611,8
lev->b[r].loc_sched_level = local_scheduler_level;
lev->b[r].last_reclaiming = 0;
kern_printf("(GS:EndBud %d)",r);
 
return r;
}
else
/shark/trunk/ports/first/first-server.c
209,7 → 209,7
hard_task_def_arg(*(HARD_TASK_MODEL *)(local_scheduler_arg),arg);
hard_task_def_level(*(HARD_TASK_MODEL *)(local_scheduler_arg),local_scheduler_level);
*thread = task_create("RMSTAR", thread_code, local_scheduler_arg, NULL);
*thread = task_create("MPEGSTAR", thread_code, local_scheduler_arg, NULL);
if (*thread == NIL)
return FSF_ERR_CREATE_THREAD;