Subversion Repositories shark

Compare Revisions

Ignore whitespace Rev 252 → Rev 253

/shark/trunk/ports/first/include/grubstar.h
18,68 → 18,7
* http://shark.sssup.it
*/
 
 
/*
------------
CVS : $Id: grubstar.h,v 1.1 2003-09-30 09:26:57 giacomo Exp $
 
File: $File$
Revision: $Revision: 1.1 $
Last update: $Date: 2003-09-30 09:26:57 $
------------
 
This file contains the budget support for the multiapplication
scheduling algorithm proposed in the framework of the FIRST Project
 
Title:
CBSSTAR
 
Task Models Accepted:
None!
 
Guest Models Accepted:
BUDGET_TASK_MODEL - A task that is attached to a budget
int b; --> the number of the budget which the task is attached to
 
Description:
This module schedule its tasks following the CBS scheme.
Every task is inserted using the guest calls.
The module defines a limited set of budgets that the application
can use. Every guest task will use a particular budget; FIFO
scheduling is used inside a budget to schedule more than one ready
task attached to the same budget.
 
The tasks are inserted in an EDF level (or similar) with a JOB_TASK_MODEL,
and the CBS level expects that the task is scheduled with the absolute
deadline passed in the model.
 
This module tries to implement a simplified version of the guest
task interface:
- To insert a guest task, use guest_create
- When a task is dispatched, use guest_dispatch
- When a task have to be suspended, you have to use:
-> preemption: use guest_epilogue
-> synchronization, end: use guest_end
Remember: no check is done on the budget number passed with the model!!!
 
Exceptions raised:
XUNVALID_TASK
This level doesn't support normal tasks, but just guest tasks.
When a task operation is called, an exception is raised.
 
Restrictions & special features:
- This level doesn't manage the main task.
- At init time we have to specify:
. guarantee check
(when all task are created the system will check that the task_set
will not use more than the available bandwidth)
- A function to return the used bandwidth of the level is provided.
 
- A function is provided to allocate a buffer.
*/
 
/*
* Copyright (C) 2002 Paolo Gai
*
* This program is free software; you can redistribute it and/or modify
99,21 → 38,11
*/
 
 
#ifndef __CBSSTAR_H__
#define __CBSSTAR_H__
#ifndef __GRUBSTAR_H__
#define __GRUBSTAR_H__
 
#include <kernel/kern.h>
 
//#include <ll/ll.h>
//#include <kernel/config.h>
//#include <sys/types.h>
//#include <kernel/types.h>
//#include <modules/codes.h>
 
/* -----------------------------------------------------------------------
BUDGET_TASK_MODEL: a model for guest tasks
----------------------------------------------------------------------- */
 
#define BUDGET_PCLASS 0x0600
typedef struct {
128,27 → 57,12
 
 
/* some constants for registering the Module in the right place */
#define CBSSTAR_LEVELNAME "CBSSTAR"
#define CBSSTAR_LEVEL_CODE 106
#define CBSSTAR_LEVEL_VERSION 1
#define GRUBSTAR_LEVELNAME "GRUBSTAR"
#define GRUBSTAR_LEVEL_CODE 106
#define GRUBSTAR_LEVEL_VERSION 1
 
typedef struct {
int command;
void *param;
} CBSSTAR_command_message;
LEVEL GRUBSTAR_register_level(int n, LEVEL master);
 
typedef struct {
int budget;
TIME T,Q;
} CBSSTAR_mod_budget;
 
/* Registration function:
int N Maximum number of budgets allocated for the applications
LEVEL master the level that must be used as master level for the
CBS tasks
*/
LEVEL CBSSTAR_register_level(int n, LEVEL master);
 
/* Allocates a budget to be used for an application.
Input parameters:
Q The budget
159,24 → 73,25
-2 The budgets allocated locally to this module have bandwidth > 1
-3 wrong LEVEL id
*/
int CBSSTAR_setbudget(LEVEL l, TIME Q, TIME T, LEVEL local_scheduler_level, int scheduler_id);
int GRUBSTAR_setbudget(LEVEL l, TIME Q, TIME T, LEVEL local_scheduler_level, int scheduler_id);
 
int CBSSTAR_removebudget(LEVEL l, int budget);
int GRUBSTAR_removebudget(LEVEL l, int budget);
 
int CBSSTAR_adjust_budget(LEVEL l, TIME Q, TIME T, int budget);
int GRUBSTAR_adjust_budget(LEVEL l, TIME Q, TIME T, int budget);
 
int CBSSTAR_getbudgetinfo(LEVEL l, TIME *Q, TIME *T, int budget);
int GRUBSTAR_getbudgetinfo(LEVEL l, TIME *Q, TIME *T, int budget);
 
int CBSSTAR_was_budget_overran(LEVEL l, int budget);
int GRUBSTAR_was_budget_overran(LEVEL l, int budget);
 
int CBSSTAR_is_active(LEVEL l, int budget);
int GRUBSTAR_is_active(LEVEL l, int budget);
 
int CBSSTAR_get_local_scheduler_level_from_budget(LEVEL l, int budget);
int GRUBSTAR_get_local_scheduler_level_from_budget(LEVEL l, int budget);
 
int CBSSTAR_get_local_scheduler_level_from_pid(LEVEL l, PID p);
int GRUBSTAR_get_local_scheduler_level_from_pid(LEVEL l, PID p);
 
int CBSSTAR_get_local_scheduler_id_from_budget(LEVEL l, int budget);
int GRUBSTAR_get_local_scheduler_id_from_budget(LEVEL l, int budget);
 
int CBSSTAR_get_local_scheduler_id_from_pid(LEVEL l, PID p);
int GRUBSTAR_get_local_scheduler_id_from_pid(LEVEL l, PID p);
 
#endif
 
/shark/trunk/ports/first/include/fsf_server.h
1,7 → 1,7
#ifndef _FSF_SERVER_H_
#define _FSF_SERVER_H_
 
#define FSF_CBSSTAR
#define FSF_GRUBSTAR
 
#ifdef FSF_CBSSTAR
 
23,10 → 23,11
#define SERVER_setbudget GRUBSTAR_setbudget
#define SERVER_adjust_budget GRUBSTAR_adjust_budget
#define SERVER_removebudget GRUBSTAR_removebudget
#define SERVER_get_local_scheduler_id_from_server GRUBSTAR_get_local_scheduler_id_from_server
#define SERVER_get_local_scheduler_id_from_budget GRUBSTAR_get_local_scheduler_id_from_budget
#define SERVER_get_local_scheduler_id_from_pid GRUBSTAR_get_local_scheduler_id_from_pid
#define SERVER_get_local_scheduler_level_from_server GRUBSTAR_get_local_scheduler_level_from_server
#define SERVER_get_local_scheduler_level_from_budget GRUBSTAR_get_local_scheduler_level_from_budget
#define SERVER_get_local_scheduler_level_from_pid GRUBSTAR_get_local_scheduler_level_from_pid
#define SERVER_getbudgetinfo GRUBSTAR_getbudgetinfo
 
#endif
 
/shark/trunk/ports/first/modules/grubstar.c
37,29 → 37,10
*
*/
 
#include "cbsstar.h"
#include "grubstar.h"
 
/*
* DEBUG stuffs begin
*/
//#define CBSSTAR_DEBUG
#ifdef CBSSTAR_DEBUG
#define GRUBSTAR_DEBUG
 
static __inline__ void fake_printf(char *fmt, ...) {}
 
#define cbsstar_printf kern_printf
#define cbsstar_printf2 kern_printf
#define cbsstar_printf3 kern_printf
 
//#define cbsstar_printf fake_printf
//#define cbsstar_printf2 fake_printf
//#define cbsstar_printf3 fake_printf
 
#endif
/*
* DEBUG stuffs end
*/
 
/* this structure contains the status for a single budget */
struct budget_struct {
TIME Q; /* budget */
70,7 → 51,7
int vtimer;
int avail; /* current budget */
LEVEL l; /* Current CBSSTAR level */
LEVEL l; /* Current GRUBSTAR level */
int loc_sched_id; /* Local scheduler id */
LEVEL loc_sched_level; /* Local scheduler level */
82,9 → 63,9
 
};
 
#define CBSSTAR_NOACTIVE 0
#define CBSSTAR_ACTIVE 1
#define CBSSTAR_RECLAIMING 2
#define GRUBSTAR_NOACTIVE 0
#define GRUBSTAR_ACTIVE 1
#define GRUBSTAR_RECLAIMING 2
 
typedef struct {
level_des l; /* the standard level descriptor */
102,42 → 83,47
 
LEVEL scheduling_level;
 
} CBSSTAR_level_des;
} GRUBSTAR_level_des;
 
 
static void CBSSTAR_deadline_timer_hardreservation(void *a)
static void GRUBSTAR_deadline_timer_hardreservation(void *a)
{
struct budget_struct *b = a;
PID p;
#ifdef CBSSTAR_DEBUG
cbsstar_printf("(CS:HrdRes:");
GRUBSTAR_level_des *lev;
lev = (GRUBSTAR_level_des *)(level_table[b->l]);
 
#ifdef GRUBSTAR_DEBUG
kern_printf("(GS:HrdRes:");
#endif
 
b->dline_timer = NIL;
 
/* we modify the deadline according to rule 4 ... */
/* there is a while because if the wcet is << than the system tick
we need to postpone the deadline many times */
b->avail += b->Q;
if (b->avail > b->Q) b->avail = b->Q;
if (b->avail > 0) b->flags = CBSSTAR_ACTIVE;
if (b->flags==GRUBSTAR_RECLAIMING && b->avail>0) {
bandwidth_t bw;
bw = (MAX_BANDWIDTH / b->T) * b->Q;
 
/* avail may be <0 because a task executed via a shadow fo many time
b->current == NIL only if the prec task was finished and there
was not any other task to be put in the ready queue
... we are now activating the next task */
lev->Uf += bw;
 
#ifdef GRUBSTAR_DEBUG
kern_printf("BW=%ld, U=%u, Uf=%u",(long)bw, lev->U, lev->Uf);
#endif
}
 
if (b->avail > 0) b->flags = GRUBSTAR_ACTIVE;
 
if (b->current == NIL && b->flags) {
if (iq_query_first(&(b->tasks)) != NIL) {
CBSSTAR_level_des *lev;
JOB_TASK_MODEL job;
p = iq_getfirst(&b->tasks);
#ifdef CBSSTAR_DEBUG
cbsstar_printf("%d",p);
#ifdef GRUBSTAR_DEBUG
kern_printf("%d",p);
#endif
 
kern_gettime(&b->dline);
145,7 → 131,6
 
b->current = p;
 
lev = (CBSSTAR_level_des *)(level_table[b->l]);
job_task_default_model(job, b->dline);
job_task_def_noexc(job);
157,26 → 142,26
}
}
if (b->flags == CBSSTAR_NOACTIVE) {
if (b->flags == GRUBSTAR_NOACTIVE) {
kern_gettime(&b->dline);
ADDUSEC2TIMESPEC(b->T, &b->dline);
b->dline_timer=kern_event_post(&b->dline, CBSSTAR_deadline_timer_hardreservation, b);
b->dline_timer=kern_event_post(&b->dline, GRUBSTAR_deadline_timer_hardreservation, b);
}
 
#ifdef CBSSTAR_DEBUG
cbsstar_printf(")");
#ifdef GRUBSTAR_DEBUG
kern_printf(")");
#endif
 
}
 
void CBSSTAR_ANC(void *arg)
void GRUBSTAR_ANC(void *arg)
{
struct budget_struct *b = arg;
CBSSTAR_level_des *lev=(CBSSTAR_level_des *)level_table[b->l];
GRUBSTAR_level_des *lev=(GRUBSTAR_level_des *)level_table[b->l];
#ifdef CBSSTAR_DEBUG
cbsstar_printf("(CS:Rec:");
#ifdef GRUBSTAR_DEBUG
kern_printf("(GS:Rec:");
#endif
 
b->vtimer = NIL;
183,56 → 168,46
if (b->current != NIL && iq_query_first(&(b->tasks)) != NIL) {
bandwidth_t bw;
 
b->flags=CBSSTAR_RECLAIMING;
b->flags=GRUBSTAR_RECLAIMING;
 
bw = (MAX_BANDWIDTH / b->T) * b->Q;
 
lev->Uf -= bw;
#ifdef CBSSTAR_DEBUG
cbsstar_printf("%ld",(long)bw);
#ifdef GRUBSTAR_DEBUG
kern_printf("bw=%ld, U=%u, Uf=%u",(long)bw, lev->U, lev->Uf);
#endif
 
}
 
#ifdef CBSSTAR_DEBUG
cbsstar_printf(")");
#ifdef GRUBSTAR_DEBUG
kern_printf(")");
#endif
 
 
}
 
static void CBSSTAR_activation(CBSSTAR_level_des *lev,
static void GRUBSTAR_activation(GRUBSTAR_level_des *lev,
PID p,
struct timespec *acttime)
{
JOB_TASK_MODEL job;
struct budget_struct *b = &lev->b[lev->tb[p]];
/* we have to check if the deadline and the wcet are correct before
activating a new task or an old task... */
TIME t;
struct timespec t2,t3;
 
/* we have to check if the deadline and the wcet are correct before
* activating a new task or an old task... */
t = (b->T * b->avail) / b->Q;
t3.tv_sec = t / 1000000;
t3.tv_nsec = (t % 1000000) * 1000;
 
/* check 1: if the deadline is before than the actual scheduling time */
 
/* check 2: if ( avail_time >= (cbs_dline - acttime)* (wcet/period) )
* (rule 7 in the CBS article!) */
TIME t;
struct timespec t2,t3;
 
t = (b->T * b->avail) / b->Q;
t3.tv_sec = t / 1000000;
t3.tv_nsec = (t % 1000000) * 1000;
 
SUBTIMESPEC(&b->dline, acttime, &t2);
if (/* 1 */ TIMESPEC_A_LT_B(&b->dline, acttime) ||
SUBTIMESPEC(&b->dline, acttime, &t2);
if (/* 1 */ TIMESPEC_A_LT_B(&b->dline, acttime) ||
/* 2 */ TIMESPEC_A_GT_B(&t3, &t2) ) {
TIMESPEC_ASSIGN(&b->dline, acttime);
ADDUSEC2TIMESPEC(b->T, &b->dline);
b->avail=b->Q;
if (b->flags==CBSSTAR_RECLAIMING) {
if (b->flags==GRUBSTAR_RECLAIMING) {
bandwidth_t bw;
bw = (MAX_BANDWIDTH / b->T) * b->Q;
239,21 → 214,22
 
lev->Uf += bw;
#ifdef CBSSTAR_DEBUG
cbsstar_printf("BW=%ld",(long)bw);
#ifdef grubSTAR_DEBUG
kern_printf("BW=%ld, U=%u, Uf=%u",(long)bw, lev->U, lev->Uf);
#endif
}
 
 
b->flags=CBSSTAR_ACTIVE;
b->flags=GRUBSTAR_ACTIVE;
 
}
else {
SUBTIMESPEC(&b->dline, &t3, &t2);
b->vtimer = kern_event_post(&t2, CBSSTAR_ANC, (void *)&b);
}
 
SUBTIMESPEC(&b->dline, &t3, &t2);
if (b->vtimer!=NIL) kern_event_delete(b->vtimer);
b->vtimer=NIL;
b->vtimer = kern_event_post(&t2, GRUBSTAR_ANC, b);
 
 
/* record the current task inserted in the master module */
b->current = p;
 
264,7 → 240,7
 
}
 
static void CBSSTAR_account_capacity(CBSSTAR_level_des *lev, PID p)
static void GRUBSTAR_account_capacity(GRUBSTAR_level_des *lev, PID p)
{
struct timespec ty;
TIME tx;
277,13 → 253,13
 
SUBTIMESPEC(&schedule_time, &cap_lasttime, &ty);
tx = TIMESPEC2USEC(&ty);
b->avail -= tx;
b->avail -= (int)((long long)tx * (long long)lev->Uf / (int)lev->U);
 
#ifdef CBSSTAR_DEBUG
kern_printf("(CS:Cap p%d av=%d)", p, b->avail);
#ifdef GRUBSTAR_DEBUG
kern_printf("(GS:Cap p%d av=%d Uf=%u U=%u)", p, b->avail,lev->Uf, lev->U);
#endif
 
if (b->avail <= 0) b->flags = CBSSTAR_NOACTIVE;
if (b->avail <= 0) b->flags = GRUBSTAR_NOACTIVE;
 
if (TIMESPEC_A_LT_B(&b->dline, &schedule_time)) {
/* we modify the deadline ... */
291,8 → 267,8
ADDUSEC2TIMESPEC(b->T, &b->dline);
}
 
if (b->flags == CBSSTAR_NOACTIVE && b->dline_timer == NIL) {
b->dline_timer=kern_event_post(&b->dline, CBSSTAR_deadline_timer_hardreservation, b);
if (b->flags == GRUBSTAR_NOACTIVE && b->dline_timer == NIL) {
b->dline_timer=kern_event_post(&b->dline, GRUBSTAR_deadline_timer_hardreservation, b);
}
}
299,12 → 275,12
 
 
/* The on-line guarantee is enabled only if the appropriate flag is set... */
static int CBSSTAR_public_guarantee(LEVEL l, bandwidth_t *freebandwidth)
static int GRUBSTAR_public_guarantee(LEVEL l, bandwidth_t *freebandwidth)
{
CBSSTAR_level_des *lev = (CBSSTAR_level_des *)(level_table[l]);
GRUBSTAR_level_des *lev = (GRUBSTAR_level_des *)(level_table[l]);
 
#ifdef CBSSTAR_DEBUG
cbsstar_printf("(CS:Gua)");
#ifdef GRUBSTAR_DEBUG
kern_printf("(GS:Gua)");
#endif
 
if (*freebandwidth >= lev->U) {
318,24 → 294,18
static void capacity_handler(void *l)
{
CBSSTAR_level_des *lev = l;
GRUBSTAR_level_des *lev = l;
lev->cap_lev = NIL;
event_need_reschedule();
}
 
static int CBSSTAR_private_eligible(LEVEL l, PID p)
static int GRUBSTAR_private_eligible(LEVEL l, PID p)
{
CBSSTAR_level_des *lev = (CBSSTAR_level_des *)(level_table[l]);
GRUBSTAR_level_des *lev = (GRUBSTAR_level_des *)(level_table[l]);
struct budget_struct *b = &lev->b[lev->tb[p]];
JOB_TASK_MODEL job;
 
/* we have to check if the deadline and the wcet are correct...
if the CBSSTAR level schedules in background with respect to others
levels, there can be the case in witch a task is scheduled by
schedule_time > CBSSTAR_deadline; in this case (not covered in the
article because if there is only the standard scheduling policy
this never apply) we reassign the deadline */
if (b->current == p) {
if ( TIMESPEC_A_LT_B(&b->dline, &schedule_time)) {
if (lev->cap_lev!=NIL) {
352,7 → 322,7
 
/* and the capacity */
b->avail = b->Q;
b->flags = CBSSTAR_ACTIVE;
b->flags = GRUBSTAR_ACTIVE;
 
if (b->dline_timer!=NIL) {
kern_event_delete(b->dline_timer);
374,13 → 344,9
 
}
 
static void CBSSTAR_private_insert(LEVEL l, PID p, TASK_MODEL *m)
static void GRUBSTAR_private_insert(LEVEL l, PID p, TASK_MODEL *m)
{
/* A task has been activated for some reason. Basically, the task is
inserted in the queue if the queue is empty, otherwise the task is
inserted into the master module, and an oslib event is posted. */
 
CBSSTAR_level_des *lev = (CBSSTAR_level_des *)(level_table[l]);
GRUBSTAR_level_des *lev = (GRUBSTAR_level_des *)(level_table[l]);
BUDGET_TASK_MODEL *budget;
 
if (m->pclass != BUDGET_PCLASS ||
390,8 → 356,8
}
budget = (BUDGET_TASK_MODEL *)m;
 
#ifdef CBSSTAR_DEBUG
cbsstar_printf("(CS:PriIns:%d:%d", p, budget->b);
#ifdef GRUBSTAR_DEBUG
kern_printf("(GS:PriIns:%d:%d", p, budget->b);
#endif
if (budget->b == -1)
404,7 → 370,7
the task have to be inserted into the master module */
struct timespec t;
kern_gettime(&t);
CBSSTAR_activation(lev,p,&t);
GRUBSTAR_activation(lev,p,&t);
} else {
/* The budget is not empty, another task is already into the
master module, so the task is inserted at the end of the budget
412,18 → 378,18
iq_insertlast(p,&lev->b[budget->b].tasks);
}
 
#ifdef CBSSTAR_DEBUG
cbsstar_printf(")");
#ifdef GRUBSTAR_DEBUG
kern_printf(")");
#endif
 
}
 
static void CBSSTAR_private_extract(LEVEL l, PID p)
static void GRUBSTAR_private_extract(LEVEL l, PID p)
{
CBSSTAR_level_des *lev = (CBSSTAR_level_des *)(level_table[l]);
GRUBSTAR_level_des *lev = (GRUBSTAR_level_des *)(level_table[l]);
 
#ifdef CBSSTAR_DEBUG
kern_printf("(CS:Ext:%d)", p);
#ifdef GRUBSTAR_DEBUG
kern_printf("(GS:Ext:%d)", p);
#endif
 
/* a task is removed from execution for some reasons. It must be
433,7 → 399,7
/* remove the task from execution (or from the ready queue) */
if (lev->b[lev->tb[p]].current == p) {
 
CBSSTAR_account_capacity(lev,p);
GRUBSTAR_account_capacity(lev,p);
/* remove the task from the master module */
level_table[ lev->scheduling_level ]->
private_extract(lev->scheduling_level, p);
450,7 → 416,7
kern_gettime(&t);
n = iq_getfirst(&lev->b[lev->tb[p]].tasks);
CBSSTAR_activation(lev,n,&t); // it modifies b[lev->tb[p]].current
GRUBSTAR_activation(lev,n,&t); // it modifies b[lev->tb[p]].current
}
else
lev->b[lev->tb[p]].current=NIL;
461,13 → 427,13
}
}
 
static void CBSSTAR_private_dispatch(LEVEL l, PID p, int nostop)
static void GRUBSTAR_private_dispatch(LEVEL l, PID p, int nostop)
{
CBSSTAR_level_des *lev = (CBSSTAR_level_des *)(level_table[l]);
GRUBSTAR_level_des *lev = (GRUBSTAR_level_des *)(level_table[l]);
struct timespec ty;
 
#ifdef CBSSTAR_DEBUG
kern_printf("(CS:Dsp:%d)", p);
#ifdef GRUBSTAR_DEBUG
kern_printf("(GS:Dsp:%d)", p);
#endif
 
/* the current task (that is the only one inserted in the master module
488,18 → 454,18
}
 
static void CBSSTAR_private_epilogue(LEVEL l, PID p)
static void GRUBSTAR_private_epilogue(LEVEL l, PID p)
{
CBSSTAR_level_des *lev = (CBSSTAR_level_des *)(level_table[l]);
GRUBSTAR_level_des *lev = (GRUBSTAR_level_des *)(level_table[l]);
struct budget_struct *b = &lev->b[lev->tb[p]];
 
#ifdef CBSSTAR_DEBUG
#ifdef GRUBSTAR_DEBUG
kern_printf("(CS:Epi:%d)",p);
#endif
 
if (p==b->current) {
CBSSTAR_account_capacity(lev,p);
GRUBSTAR_account_capacity(lev,p);
 
// L'evento di capacità va cancellato perchè sarà ripristinato nella successiva dispatch
/* we have to check if the capacity is still available */
525,31 → 491,28
 
/* Registration functions }*/
 
/*+ Registration function:
int flags the init flags ... see CBSSTAR.h +*/
LEVEL CBSSTAR_register_level(int n, LEVEL master)
LEVEL GRUBSTAR_register_level(int n, LEVEL master)
{
LEVEL l; /* the level that we register */
CBSSTAR_level_des *lev; /* for readableness only */
GRUBSTAR_level_des *lev; /* for readableness only */
PID i; /* a counter */
 
kern_printf("CBSSTAR_register_level\n");
printk("GRUBSTAR_register_level\n");
 
/* request an entry in the level_table */
l = level_alloc_descriptor(sizeof(CBSSTAR_level_des));
l = level_alloc_descriptor(sizeof(GRUBSTAR_level_des));
 
lev = (CBSSTAR_level_des *)level_table[l];
lev = (GRUBSTAR_level_des *)level_table[l];
 
/* fill the standard descriptor */
lev->l.private_insert = CBSSTAR_private_insert;
lev->l.private_extract = CBSSTAR_private_extract;
lev->l.private_eligible = CBSSTAR_private_eligible;
lev->l.private_dispatch = CBSSTAR_private_dispatch;
lev->l.private_epilogue = CBSSTAR_private_epilogue;
lev->l.private_insert = GRUBSTAR_private_insert;
lev->l.private_extract = GRUBSTAR_private_extract;
lev->l.private_eligible = GRUBSTAR_private_eligible;
lev->l.private_dispatch = GRUBSTAR_private_dispatch;
lev->l.private_epilogue = GRUBSTAR_private_epilogue;
 
lev->l.public_guarantee = CBSSTAR_public_guarantee;
lev->l.public_guarantee = GRUBSTAR_public_guarantee;
 
/* fill the CBSSTAR descriptor part */
lev->b = (struct budget_struct *)kern_alloc(sizeof(struct budget_struct)*n);
 
for (i=0; i<n; i++) {
557,11 → 520,12
lev->b[i].T = 0;
NULL_TIMESPEC(&lev->b[i].dline);
lev->b[i].dline_timer = NIL;
lev->b[i].vtimer=NIL;
lev->b[i].avail = 0;
lev->b[i].current = -1;
lev->b[i].flags = CBSSTAR_ACTIVE;
lev->b[i].flags = GRUBSTAR_ACTIVE;
lev->b[i].l=l;
iq_init(&lev->b[i].tasks, /* &freedesc */NULL, 0);
iq_init(&lev->b[i].tasks, NULL, 0);
}
 
lev->n = n;
579,13 → 543,13
 
}
 
int CBSSTAR_setbudget(LEVEL l, TIME Q, TIME T, LEVEL local_scheduler_level, int scheduler_id)
int GRUBSTAR_setbudget(LEVEL l, TIME Q, TIME T, LEVEL local_scheduler_level, int scheduler_id)
{
CBSSTAR_level_des *lev = (CBSSTAR_level_des *)(level_table[l]);
GRUBSTAR_level_des *lev = (GRUBSTAR_level_des *)(level_table[l]);
int r;
 
#ifdef CBSSTAR_DEBUG
cbsstar_printf("(CS:SetBud)");
#ifdef GRUBSTAR_DEBUG
kern_printf("(GS:SetBud)");
#endif
 
for (r = 0; r < lev->n; r++)
605,7 → 569,7
lev->b[r].Q = Q;
lev->b[r].T = T;
lev->b[r].avail = Q;
lev->b[r].flags = CBSSTAR_ACTIVE;
lev->b[r].flags = GRUBSTAR_ACTIVE;
lev->b[r].loc_sched_id = scheduler_id;
lev->b[r].loc_sched_level = local_scheduler_level;
618,10 → 582,10
return -1;
}
 
int CBSSTAR_removebudget(LEVEL l, int budget)
int GRUBSTAR_removebudget(LEVEL l, int budget)
{
 
CBSSTAR_level_des *lev = (CBSSTAR_level_des *)(level_table[l]);
GRUBSTAR_level_des *lev = (GRUBSTAR_level_des *)(level_table[l]);
 
bandwidth_t b;
635,16 → 599,16
lev->b[budget].dline_timer = NIL;
lev->b[budget].avail = 0;
lev->b[budget].current = -1;
lev->b[budget].flags = CBSSTAR_ACTIVE;
lev->b[budget].flags = GRUBSTAR_ACTIVE;
 
return 0;
 
}
 
int CBSSTAR_adjust_budget(LEVEL l, TIME Q, TIME T, int budget)
int GRUBSTAR_adjust_budget(LEVEL l, TIME Q, TIME T, int budget)
{
 
CBSSTAR_level_des *lev = (CBSSTAR_level_des *)(level_table[l]);
GRUBSTAR_level_des *lev = (GRUBSTAR_level_des *)(level_table[l]);
 
lev->b[budget].Q = Q;
lev->b[budget].T = T;
653,10 → 617,10
 
}
 
int CBSSTAR_getbudgetinfo(LEVEL l, TIME *Q, TIME *T, int budget)
int GRUBSTAR_getbudgetinfo(LEVEL l, TIME *Q, TIME *T, int budget)
{
 
CBSSTAR_level_des *lev = (CBSSTAR_level_des *)(level_table[l]);
GRUBSTAR_level_des *lev = (GRUBSTAR_level_des *)(level_table[l]);
*Q = lev->b[budget].Q;
*T = lev->b[budget].T;
665,41 → 629,41
 
}
 
int CBSSTAR_is_active(LEVEL l, int budget)
int GRUBSTAR_is_active(LEVEL l, int budget)
{
CBSSTAR_level_des *lev = (CBSSTAR_level_des *)(level_table[l]);
GRUBSTAR_level_des *lev = (GRUBSTAR_level_des *)(level_table[l]);
 
return lev->b[budget].flags;
 
}
 
int CBSSTAR_get_local_scheduler_level_from_budget(LEVEL l, int budget)
int GRUBSTAR_get_local_scheduler_level_from_budget(LEVEL l, int budget)
{
CBSSTAR_level_des *lev = (CBSSTAR_level_des *)(level_table[l]);
GRUBSTAR_level_des *lev = (GRUBSTAR_level_des *)(level_table[l]);
 
return lev->b[budget].loc_sched_level;
 
}
 
int CBSSTAR_get_local_scheduler_level_from_pid(LEVEL l, PID p)
int GRUBSTAR_get_local_scheduler_level_from_pid(LEVEL l, PID p)
{
CBSSTAR_level_des *lev = (CBSSTAR_level_des *)(level_table[l]);
GRUBSTAR_level_des *lev = (GRUBSTAR_level_des *)(level_table[l]);
 
return lev->b[lev->tb[p]].loc_sched_level;
 
}
 
int CBSSTAR_get_local_scheduler_id_from_budget(LEVEL l, int budget)
int GRUBSTAR_get_local_scheduler_id_from_budget(LEVEL l, int budget)
{
CBSSTAR_level_des *lev = (CBSSTAR_level_des *)(level_table[l]);
GRUBSTAR_level_des *lev = (GRUBSTAR_level_des *)(level_table[l]);
 
return lev->b[budget].loc_sched_id;
 
}
 
int CBSSTAR_get_local_scheduler_id_from_pid(LEVEL l, PID p)
int GRUBSTAR_get_local_scheduler_id_from_pid(LEVEL l, PID p)
{
CBSSTAR_level_des *lev = (CBSSTAR_level_des *)(level_table[l]);
GRUBSTAR_level_des *lev = (GRUBSTAR_level_des *)(level_table[l]);
 
return lev->b[lev->tb[p]].loc_sched_id;
 
/shark/trunk/ports/first/makefile
11,7 → 11,7
OBJS_PATH = $(BASE)/ports/first
 
FIRST = first-contract.o first-server.o first-sync.o \
./modules/cbsstar.o ./modules/posixstar.o \
./modules/grubstar.o ./modules/posixstar.o \
./modules/edfstar.o ./modules/rmstar.o
 
OBJS = $(FIRST)