WebSVN - shark - Blame - Rev 1287 - /demos/trunk/cash/cash.c

Rev	Author	Line No.	Line
1085	pj	1	/*
		2	* Project: S.Ha.R.K.
		3	*
		4	* Coordinators:
		5	* Giorgio Buttazzo <giorgio@sssup.it>
		6	* Paolo Gai <pj@gandalf.sssup.it>
		7	*
		8	* Authors :
		9	* Paolo Gai <pj@gandalf.sssup.it>
		10	* Massimiliano Giorgi <massy@gandalf.sssup.it>
		11	* Luca Abeni <luca@gandalf.sssup.it>
		12	* (see the web pages for full authors list)
		13	*
		14	* ReTiS Lab (Scuola Superiore S.Anna - Pisa - Italy)
		15	*
		16	* http://www.sssup.it
		17	* http://retis.sssup.it
		18	* http://shark.sssup.it
		19	*/
		20
		21	/**
		22	------------
1287	giacomo	23	CVS : $Id: cash.c,v 1.5 2003-12-17 13:52:45 giacomo Exp $
1085	pj	24
		25	File: $File$
1287	giacomo	26	Revision: $Revision: 1.5 $
		27	Last update: $Date: 2003-12-17 13:52:45 $
1085	pj	28	------------
		29
		30	This file contains the aperiodic server CBS (Total Bandwidth Server)
		31
		32	Read CBS.h for further details.
		33
		34	**/
		35
		36	/*
		37	* Copyright (C) 2000 Paolo Gai
		38	*
		39	* This program is free software; you can redistribute it and/or modify
		40	* it under the terms of the GNU General Public License as published by
		41	* the Free Software Foundation; either version 2 of the License, or
		42	* (at your option) any later version.
		43	*
		44	* This program is distributed in the hope that it will be useful,
		45	* but WITHOUT ANY WARRANTY; without even the implied warranty of
		46	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		47	* GNU General Public License for more details.
		48	*
		49	* You should have received a copy of the GNU General Public License
		50	* along with this program; if not, write to the Free Software
		51	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
		52	*
		53	*/
		54
		55
		56	#include "cash.h"
		57	#include <ll/stdio.h>
		58	#include <ll/string.h>
		59	#include <kernel/model.h>
		60	#include <kernel/descr.h>
		61	#include <kernel/var.h>
		62	#include <kernel/func.h>
		63
		64	/+ Status used in the level +/
		65	#define CBSGHD_IDLE APER_STATUS_BASE /+ waiting the activation +/
		66	#define CBSGHD_ZOMBIE APER_STATUS_BASE+1 /+ waiting the period end +/
		67
		68	/* structure of an element of the capacity queue */
		69	struct cap_queue {
		70	int cap;
		71	struct timespec dead;
		72	struct cap_queue *next;
		73	};
		74
		75	/+ the level redefinition for the CBS_HD level +/
		76	typedef struct {
		77	level_des l; /+ the standard level descriptor +/
		78
		79	/* The wcet are stored in the task descriptor, but we need
		80	an array for the deadlines. We can't use the timespec_priority
		81	field because it is used by the master level!!!...
		82	Notice that however the use of the timespec_priority field
		83	does not cause any problem... */
		84
		85	struct timespec cbsghd_dline[MAX_PROC]; /+ CBSGHD deadlines +/
		86
		87	TIME period[MAX_PROC]; /+ CBSGHD activation period +/
		88
		89	TIME maxperiod[MAX_PROC]; /+ maximum period of each elastic task +/
		90
		91	int cremaining[MAX_PROC]; /+ instance remaining computation time +/
		92
		93	TIME act_period[MAX_PROC]; /*+ actual period of each elastic task: it
		94	must be less than maxperiod!!! +*/
		95
1123	pj	96	struct timespec request_time[MAX_PROC]; /* used for the response time */
1085	pj	97	TIME last_response_time[MAX_PROC]; /* response time of the last instance */
		98
		99	TIME cnormal[MAX_PROC]; /+ CBSGHD normal computation time +/
		100
		101	struct timespec reactivation_time[MAX_PROC];
		102	/+ the time at witch the reactivation timer is post +/
		103	int reactivation_timer[MAX_PROC];
		104	/+ the recativation timer +/
		105
		106	struct cap_queue queue; / pointer to the spare capacity queue */
		107
		108	int flags; /+ the init flags... +/
		109
		110	bandwidth_t U; /+ the used bandwidth by the server +/
		111
		112	int idle; /* the idle flag... */
		113
		114	struct timespec start_idle; /gives the start time of the last idle period /
		115
		116	LEVEL scheduling_level;
		117
		118	} CBSGHD_level_des;
		119
		120
		121	/* insert a capacity in the queue capacity ordering by deadline */
		122
		123	static int c_insert(struct timespec dead, int cap, struct cap_queue **que,
		124	PID p)
		125	{
		126	struct cap_queue prev, n, *new;
		127
		128	prev = NULL;
		129	n = *que;
		130
		131	while ((n != NULL) &&
		132	!TIMESPEC_A_LT_B(&dead, &n->dead)) {
		133	prev = n;
		134	n = n->next;
		135	}
		136
		137
		138	new = (struct cap_queue *)kern_alloc(sizeof(struct cap_queue));
		139	if (new == NULL) {
		140	kern_printf("\nNew cash_queue element failed\n");
1100	pj	141	kern_raise(XINVALID_TASK, p);
1085	pj	142	return -1;
		143	}
		144	new->next = NULL;
		145	new->cap = cap;
		146	new->dead = dead;
		147
		148	if (prev != NULL)
		149	prev->next = new;
		150	else
		151	*que = new;
		152
		153	if (n != NULL)
		154	new->next = n;
		155	return 0;
		156	}
		157
		158	/* extract the first element from the capacity queue */
		159
		160	static int c_extractfirst(struct cap_queue **que)
		161	{
		162	struct cap_queue p = que;
		163
		164
		165	if (*que == NULL) return(-1);
		166
		167	que = (que)->next;
		168
		169	kern_free(p, sizeof(struct cap_queue));
		170	return(1);
		171	}
		172
		173	/* read data of the first element from the capacity queue */
		174
		175	static void c_readfirst(struct timespec d, int c, struct cap_queue *que)
		176	{
		177	*d = que->dead;
		178	*c = que->cap;
		179	}
		180
		181	/* write data of the first element from the capacity queue */
		182
		183	static void c_writefirst(struct timespec dead, int cap, struct cap_queue *que)
		184	{
		185	que->dead = dead;
		186	que->cap = cap;
		187	}
		188
		189
		190	static void CBSGHD_activation(CBSGHD_level_des *lev,
		191	PID p,
		192	struct timespec *acttime)
		193	{
		194	JOB_TASK_MODEL job;
		195
		196
		197	/* This rule is used when we recharge the budget at initial task activation
		198	and each time a new task instance must be activated */
		199
		200	if (TIMESPEC_A_GT_B(acttime, &lev->cbsghd_dline[p])) {
		201	/* we modify the deadline ... */
		202	TIMESPEC_ASSIGN(&lev->cbsghd_dline[p], acttime);
		203	}
		204
		205	lev->act_period[p] = 0;
		206
		207	if (proc_table[p].avail_time > 0)
		208	proc_table[p].avail_time = 0;
		209
		210
		211
		212
		213	/* there is a while because if the wcet is << than the system tick
		214	we need to postpone the deadline many times */
		215	while (proc_table[p].avail_time <= 0) {
		216
		217	/* A spare capacity is inserted in the capacity queue!! */
		218	ADDUSEC2TIMESPEC(lev->period[p], &lev->cbsghd_dline[p]);
		219	lev->act_period[p] += lev->period[p];
		220	c_insert(lev->cbsghd_dline[p], lev->cnormal[p], &lev->queue, p);
		221
		222
		223	/* it exploits available capacities from the capacity queue */
		224	while (proc_table[p].avail_time < (int)lev->cnormal[p] &&
		225	lev->queue != NULL) {
		226	struct timespec dead;
		227	int cap, delta;
		228	delta = lev->cnormal[p] - proc_table[p].avail_time;
		229	c_readfirst(&dead, &cap, lev->queue);
		230	if (!TIMESPEC_A_GT_B(&dead, &lev->cbsghd_dline[p])) {
		231	if (cap > delta) {
		232	proc_table[p].avail_time += delta;
		233	c_writefirst(dead, cap - delta, lev->queue);
		234	}
		235	else {
		236	proc_table[p].avail_time += cap;
		237	c_extractfirst(&lev->queue);
		238	}
		239	}
		240	else
		241	break;
		242	}
		243	}
		244
		245	lev->cremaining[p] = proc_table[p].wcet - proc_table[p].avail_time;
		246
		247
		248	#ifdef TESTG
		249	if (starttime && p == 3) {
		250	oldx = x;
		251	x = ((lev->cbsghd_dline[p].tv_sec*1000000+lev->cbsghd_dline[p].tv_nsec/1000)/5000 - starttime) + 20;
		252	// kern_printf("(a%d)",lev->cbsghd_dline[p].tv_sec*1000000+lev->cbsghd_dline[p].tv_nsec/1000);
		253	if (oldx > x) sys_end();
		254	if (x<640)
		255	grx_plot(x, 15, 8);
		256	}
		257	#endif
		258
		259	/* and, finally, we reinsert the task in the master level */
		260	job_task_default_model(job, lev->cbsghd_dline[p]);
		261	job_task_def_yesexc(job);
		262	level_table[ lev->scheduling_level ]->
1123	pj	263	private_insert(lev->scheduling_level, p, (TASK_MODEL *)&job);
1085	pj	264	}
		265
		266
		267	/* this is the periodic reactivation of the task... */
		268	static void CBSGHD_timer_reactivate(void *par)
		269	{
		270	PID p = (PID) par;
		271	CBSGHD_level_des *lev;
		272
		273	lev = (CBSGHD_level_des *)level_table[proc_table[p].task_level];
		274
		275	if (proc_table[p].status == CBSGHD_IDLE) {
		276	/* the task has finished the current activation and must be
		277	reactivated */
		278
		279	/* request_time represents the time of the last instance release!! */
1123	pj	280	TIMESPEC_ASSIGN(&lev->request_time[p], &lev->reactivation_time[p]);
1085	pj	281
		282	/* If idle=1, then we have to discharge the capacities stored in
		283	the capacity queue up to the length of the idle interval */
		284	if (lev->idle == 1) {
		285	TIME interval;
		286	struct timespec delta;
		287	lev->idle = 0;
1123	pj	288	SUBTIMESPEC(&lev->request_time[p], &lev->start_idle, &delta);
1085	pj	289	/* length of the idle interval expressed in usec! */
		290	interval = TIMESPEC2NANOSEC(&delta) / 1000;
		291
		292	/* it discharge the available capacities from the capacity queue */
		293	while (interval > 0 && lev->queue != NULL) {
		294	struct timespec dead;
		295	int cap;
		296	c_readfirst(&dead, &cap, lev->queue);
		297	if (cap > interval) {
		298	c_writefirst(dead, cap - interval, lev->queue);
		299	interval = 0;
		300	}
		301	else {
		302	interval -= cap;
		303	c_extractfirst(&lev->queue);
		304	}
		305	}
		306	}
		307
		308	CBSGHD_activation(lev,p,&lev->reactivation_time[p]);
		309
		310	/* check the constraint on the maximum period permitted... */
		311	if (lev->act_period[p] > lev->maxperiod[p]) {
		312	kern_printf("Deadline miss(timer_react.! process:%d act_period:%lu maxperiod:%lu\n",
		313	p, lev->act_period[p], lev->maxperiod[p]);
		314	kern_raise(XDEADLINE_MISS,p);
		315	}
		316
		317
		318	/* Set the reactivation timer */
		319	TIMESPEC_ASSIGN(&lev->reactivation_time[p], &lev->cbsghd_dline[p]);
		320	lev->reactivation_timer[p] = kern_event_post(&lev->reactivation_time[p],
		321	CBSGHD_timer_reactivate,
		322	(void *)p);
		323	event_need_reschedule();
		324	}
		325	else {
		326	/* this situation cannot occur */
		327	kern_printf("Trying to reactivate a task which is not IDLE!!!/n");
1100	pj	328	kern_raise(XINVALID_TASK,p);
1085	pj	329	}
		330	}
		331
		332
		333
		334
		335
		336	static void CBSGHD_avail_time_check(CBSGHD_level_des *lev, PID p)
		337	{
		338
		339	/*+ if the capacity became negative the remaining computation time
		340	is diminuished.... +*/
		341	/* if (p==4)
		342	kern_printf("(old dead:%d av_time:%d crem:%d)\n",
		343	lev->cbsghd_dline[p].tv_sec*1000000+
		344	lev->cbsghd_dline[p].tv_nsec/1000, proc_table[p].avail_time,
		345	lev->cremaining[p]); */
		346
		347
		348	if (proc_table[p].avail_time < 0)
		349	lev->cremaining[p] += proc_table[p].avail_time;
		350
		351	if (lev->cremaining[p] <= 0) {
		352	kern_printf("Task:%d WCET violation \n", p);
		353	kern_raise(XWCET_VIOLATION, p);
		354	ll_abort(666);
		355	}
		356
		357
		358	/* there is a while because if the wcet is << than the system tick
		359	we need to postpone the deadline many times */
		360	while (proc_table[p].avail_time <= 0) {
		361	/* it exploits available capacities from the capacity queue */
		362	while (proc_table[p].avail_time < lev->cremaining[p]
		363	&& lev->queue != NULL) {
		364	struct timespec dead;
		365	int cap, delta;
		366	delta = lev->cremaining[p] - proc_table[p].avail_time;
		367	c_readfirst(&dead, &cap, lev->queue);
		368	if (!TIMESPEC_A_GT_B(&dead, &lev->cbsghd_dline[p])) {
		369	if (cap > delta) {
		370	proc_table[p].avail_time += delta;
		371	c_writefirst(dead, cap - delta, lev->queue);
		372	}
		373	else {
		374	proc_table[p].avail_time += cap;
		375	c_extractfirst(&lev->queue);
		376	}
		377	}
		378	else
		379	break;
		380	}
		381
		382	/* if (p==5 && proc_table[p].avail_time <= 0 &&
		383	lev->cremaining[p] > lev->cnormal[p])
		384	kern_printf("(inter dead:%d av_time:%d crem:%d)\n",
		385	lev->cbsghd_dline[p].tv_sec*1000000+
		386	lev->cbsghd_dline[p].tv_nsec/1000, proc_table[p].avail_time,
		387	lev->cremaining[p]); */
		388
		389
		390	/* The remaining computation time is modified according
		391	to the new budget! */
		392	if (proc_table[p].avail_time > 0)
		393	lev->cremaining[p] -= proc_table[p].avail_time;
		394	else {
		395	/* the CBSGHD rule for recharging the capacity: */
		396	if (lev->cremaining[p] > lev->cnormal[p]) {
		397	ADDUSEC2TIMESPEC(lev->period[p], &lev->cbsghd_dline[p]);
		398	lev->act_period[p] += lev->period[p];
		399	/* A spare capacity is inserted in the capacity queue!! */
		400	c_insert(lev->cbsghd_dline[p], lev->cnormal[p], &lev->queue, p);
		401	}
		402	else {
		403	TIME t;
		404	t = (lev->cremaining[p] * lev->period[p]) / lev->cnormal[p];
		405	ADDUSEC2TIMESPEC(t, &lev->cbsghd_dline[p]);
		406	lev->act_period[p] += t;
		407	/* A spare capacity is inserted in the capacity queue!! */
		408	c_insert(lev->cbsghd_dline[p], lev->cremaining[p], &lev->queue, p);
		409	}
		410	}
		411	}
		412
		413	/* if (p==4)
		414	kern_printf("n dead:%d av_time:%d crem:%d)\n",
		415	lev->cbsghd_dline[p].tv_sec*1000000+
		416	lev->cbsghd_dline[p].tv_nsec/1000, proc_table[p].avail_time,
		417	lev->cremaining[p]); */
		418
		419	/* check the constraint on the maximum period permitted... */
		420	if (lev->act_period[p] > lev->maxperiod[p]) {
		421	/*kern_printf("n dead:%d av_time:%d crem:%d)\n",
		422	lev->cbsghd_dline[p].tv_sec*1000000+
		423	lev->cbsghd_dline[p].tv_nsec/1000, proc_table[p].avail_time,
		424	lev->cremaining[p]); */
		425	kern_printf("Deadline miss(av.time_check! process:%d act_period:%lu maxperiod:%lu\n",
		426	p, lev->act_period[p], lev->maxperiod[p]);
		427	kern_raise(XDEADLINE_MISS,p);
		428	}
		429
		430
		431
		432	if (TIMESPEC_A_LT_B(&lev->reactivation_time[p], &lev->cbsghd_dline[p])) {
		433	/* we delete the reactivation timer */
1123	pj	434	kern_event_delete(lev->reactivation_timer[p]);
1085	pj	435	/* repost the event at the next instance deadline... */
		436	lev->reactivation_time[p] = lev->cbsghd_dline[p];
		437	lev->reactivation_timer[p] = kern_event_post(&lev->reactivation_time[p],
		438	CBSGHD_timer_reactivate,
		439	(void *)p);
		440	}
		441
		442	#ifdef TESTG
		443	if (starttime && p == 3) {
		444	oldx = x;
		445	x = ((lev->cbsghd_dline[p].tv_sec*1000000+
		446	lev->cbsghd_dline[p].tv_nsec/1000)/5000 - starttime) + 20;
		447	// kern_printf("(e%d avail%d)",lev->cbsghd_dline[p].tv_sec*1000000+
		448	lev->cbsghd_dline[p].tv_nsec/1000,proc_table[p].avail_time);
		449	if (oldx > x) sys_end();
		450	if (x<640)
		451	grx_plot(x, 15, 2);
		452	}
		453	#endif
		454
		455	}
		456
		457
		458	/*+ this function is called when a killed or ended task reach the
		459	period end +*/
		460	static void CBSGHD_timer_zombie(void *par)
		461	{
		462	PID p = (PID) par;
		463	CBSGHD_level_des *lev;
		464
		465	lev = (CBSGHD_level_des *)level_table[proc_table[p].task_level];
		466
		467	/* we finally put the task in the FREE status */
		468	proc_table[p].status = FREE;
1108	pj	469	iq_insertfirst(p,&freedesc);
1085	pj	470
		471	/* and free the allocated bandwidth */
		472	lev->U -= (MAX_BANDWIDTH/lev->period[p]) * lev->cnormal[p];
		473
		474	}
		475
1123	pj	476	static PID CBSGHD_public_scheduler(LEVEL l)
1085	pj	477	{
		478	CBSGHD_level_des lev = (CBSGHD_level_des )(level_table[l]);
		479
		480	/* it stores the actual time and set the IDLE flag in order to handle
		481	the capacity queue discharging!!! */
		482	lev->idle = 1;
1123	pj	483	kern_gettime(&lev->start_idle);
1085	pj	484
		485
		486	/* the CBSGHD don't schedule anything...
		487	it's an EDF level or similar that do it! */
		488	return NIL;
		489	}
		490
		491	/* The on-line guarantee is enabled only if the appropriate flag is set... */
1123	pj	492	static int CBSGHD_public_guarantee(LEVEL l, bandwidth_t *freebandwidth)
1085	pj	493	{
		494	CBSGHD_level_des lev = (CBSGHD_level_des )(level_table[l]);
		495
		496	if (lev->flags & CBSGHD_FAILED_GUARANTEE) {
		497	*freebandwidth = 0;
		498	//kern_printf("guarantee :garanzia fallita!!!!!!\n");
		499	return 0;
		500	}
		501	else if (*freebandwidth >= lev->U) {
		502	*freebandwidth -= lev->U;
		503	return 1;
		504	}
		505	else {
		506	//kern_printf("guarantee :garanzia fallita per mancanza di banda!!!!!!\n");
		507	//kern_printf("freeband: %d request band: %d", *freebandwidth, lev->U);
		508	return 0;
		509	}
		510	}
		511
1123	pj	512	static int CBSGHD_public_create(LEVEL l, PID p, TASK_MODEL *m)
1085	pj	513	{
		514	CBSGHD_level_des lev = (CBSGHD_level_des )(level_table[l]);
1123	pj	515	ELASTIC_HARD_TASK_MODEL *s;
		516	bandwidth_t b1, b2;
1085	pj	517
1123	pj	518	if (m->pclass != ELASTIC_HARD_PCLASS) return -1;
		519	if (m->level != 0 && m->level != l) return -1;
		520	s = (ELASTIC_HARD_TASK_MODEL *)m;
1085	pj	521
1123	pj	522	/* kern_printf("accept :ELASTIC TASK found!!!!!!\n"); */
		523	b1 = (MAX_BANDWIDTH / s->period) * s->cnormal;
		524	b2 = (MAX_BANDWIDTH / s->maxperiod) * s->wcet;
		525	if (!(s->wcet && s->cnormal && s->period && s->maxperiod &&
		526	s->wcet >= s->cnormal && b1 >= b2) )
		527	return -1;
		528	/* kern_printf("period: %d maxperiod: %d cnormal: %d wcet: %d, b1: %d b2:
		529	%d\n", s->period, s->maxperiod, s->cnormal, s->wcet, b1, b2); */
		530
		531	/* now we know that m is a valid model */
		532
		533
1085	pj	534	/* Enable wcet check */
		535	proc_table[p].avail_time = 0;
		536	proc_table[p].wcet = s->wcet;
		537	proc_table[p].control \|= CONTROL_CAP;
		538
		539	lev->period[p] = s->period;
		540	lev->maxperiod[p] = s->maxperiod;
		541	lev->cnormal[p] = s->cnormal;
		542	NULL_TIMESPEC(&lev->cbsghd_dline[p]);
1123	pj	543	NULL_TIMESPEC(&lev->request_time[p]);
1085	pj	544
1123	pj	545
1085	pj	546	/* update the bandwidth... */
		547	if (lev->flags & CBSGHD_ENABLE_GUARANTEE) {
		548	bandwidth_t b;
		549	b = (MAX_BANDWIDTH / s->period) * s->cnormal;
		550
		551	/* really update lev->U, checking an overflow... */
		552	if (MAX_BANDWIDTH - lev->U > b)
		553	lev->U += b;
		554	else
		555	/* The task can NOT be guaranteed (U>MAX_BANDWIDTH)...
		556	(see EDF.c) */
		557	lev->flags \|= CBSGHD_FAILED_GUARANTEE;
		558	}
		559
		560
		561
		562	return 0; /* OK, also if the task cannot be guaranteed... */
		563	}
		564
1123	pj	565	static void CBSGHD_public_detach(LEVEL l, PID p)
1085	pj	566	{
		567	/* the CBSGHD level doesn't introduce any dinamic allocated new field.
		568	we have only to reset the NO_GUARANTEE FIELD and decrement the allocated
		569	bandwidth */
		570
		571	CBSGHD_level_des lev = (CBSGHD_level_des )(level_table[l]);
		572
		573	if (lev->flags & CBSGHD_FAILED_GUARANTEE)
		574	lev->flags &= ~CBSGHD_FAILED_GUARANTEE;
		575	else
		576	lev->U -= (MAX_BANDWIDTH / lev->period[p]) * lev->cnormal[p];
		577
		578
		579	}
		580
1123	pj	581	static void CBSGHD_public_dispatch(LEVEL l, PID p, int nostop)
1085	pj	582	{
		583	CBSGHD_level_des lev = (CBSGHD_level_des )(level_table[l]);
		584	level_table[ lev->scheduling_level ]->
1123	pj	585	private_dispatch(lev->scheduling_level,p,nostop);
1085	pj	586
		587	}
		588
1123	pj	589	static void CBSGHD_public_epilogue(LEVEL l, PID p)
1085	pj	590	{
		591	CBSGHD_level_des lev = (CBSGHD_level_des )(level_table[l]);
		592	JOB_TASK_MODEL job;
		593
		594	/* check if the budget is finished... */
		595	if ( proc_table[p].avail_time <= 0) {
		596	/* we kill the current activation */
		597	level_table[ lev->scheduling_level ]->
1123	pj	598	private_extract(lev->scheduling_level, p);
1085	pj	599
		600	/* we modify the deadline */
		601	CBSGHD_avail_time_check(lev, p);
		602
		603	/* and, finally, we reinsert the task in the master level */
		604	job_task_default_model(job, lev->cbsghd_dline[p]);
		605	job_task_def_yesexc(job);
		606	level_table[ lev->scheduling_level ]->
1123	pj	607	private_insert(lev->scheduling_level, p, (TASK_MODEL *)&job);
1085	pj	608	// kern_printf("epil : dl %d per %d p %d \|\n",
		609	// lev->cbsghd_dline[p].tv_nsec/1000,lev->period[p],p);
		610
		611	}
		612	else
		613	/* the task has been preempted. it returns into the ready queue by
		614	calling the guest_epilogue... */
		615	level_table[ lev->scheduling_level ]->
1123	pj	616	private_epilogue(lev->scheduling_level,p);
1085	pj	617	}
		618
1123	pj	619	static void CBSGHD_public_activate(LEVEL l, PID p)
1085	pj	620	{
		621	CBSGHD_level_des lev = (CBSGHD_level_des )(level_table[l]);
		622
1123	pj	623	kern_gettime(&lev->request_time[p]);
1085	pj	624
		625	/* If idle=1, then we have to discharge the capacities stored in
		626	the capacity queue up to the length of the idle interval */
		627	if (lev->idle == 1) {
		628	TIME interval;
		629	struct timespec delta;
		630	lev->idle = 0;
1123	pj	631	SUBTIMESPEC(&lev->request_time[p], &lev->start_idle, &delta);
1085	pj	632	/* length of the idle interval expressed in usec! */
		633	interval = TIMESPEC2NANOSEC(&delta) / 1000;
		634
		635	/* it discharge the available capacities from the capacity queue */
		636	while (interval > 0 && lev->queue != NULL) {
		637	struct timespec dead;
		638	int cap;
		639	c_readfirst(&dead, &cap, lev->queue);
		640	if (cap > interval) {
		641	c_writefirst(dead, cap - interval, lev->queue);
		642	interval = 0;
		643	}
		644	else {
		645	interval -= cap;
		646	c_extractfirst(&lev->queue);
		647	}
		648	}
		649	}
		650
1123	pj	651	CBSGHD_activation(lev, p, &lev->request_time[p]);
1085	pj	652
		653
		654	/* check the constraint on the maximum period permitted... */
		655	if (lev->act_period[p] > lev->maxperiod[p]) {
		656	kern_printf("Deadline miss(task_activ.! process:%d act_period:%lu maxperiod:%lu\n",
		657	p, lev->act_period[p], lev->maxperiod[p]);
		658	kern_raise(XDEADLINE_MISS,p);
		659	}
		660
		661	/* Set the reactivation timer */
		662	TIMESPEC_ASSIGN(&lev->reactivation_time[p], &lev->cbsghd_dline[p]);
		663	lev->reactivation_timer[p] = kern_event_post(&lev->reactivation_time[p],
		664	CBSGHD_timer_reactivate,
		665	(void *)p);
		666
		667	// kern_printf("act : %d %d \|",lev->cbsghd_dline[p].tv_nsec/1000,p);
		668	}
		669
1123	pj	670	static void CBSGHD_public_unblock(LEVEL l, PID p)
1085	pj	671	{
		672	printk("CBSGHD_task_insert\n");
1100	pj	673	kern_raise(XINVALID_TASK,p);
1085	pj	674	}
		675
1123	pj	676	static void CBSGHD_public_block(LEVEL l, PID p)
1085	pj	677	{
		678	printk("CBSGHD_task_extract\n");
1100	pj	679	kern_raise(XINVALID_TASK,p);
1085	pj	680	}
		681
1123	pj	682	static int CBSGHD_public_message(LEVEL l, PID p, void *m)
1085	pj	683	{
		684	CBSGHD_level_des lev = (CBSGHD_level_des )(level_table[l]);
		685	struct timespec act_time, res;
		686
		687	/* It computes the response time of the current instance... */
1123	pj	688	kern_gettime(&act_time);
		689	SUBTIMESPEC(&act_time, &lev->request_time[p], &res);
1085	pj	690	/* response time expressed in usec! */
		691	lev->last_response_time[p] = TIMESPEC2NANOSEC(&res) / 1000;
		692
		693	level_table[ lev->scheduling_level ]->
1123	pj	694	private_extract(lev->scheduling_level,p);
1085	pj	695
		696
		697	/* A spare capacity is inserted in the capacity queue!! */
		698	if (proc_table[p].avail_time > 0) {
		699	c_insert(lev->cbsghd_dline[p], proc_table[p].avail_time, &lev->queue, p);
		700	proc_table[p].avail_time = 0;
		701	}
		702
		703
		704	proc_table[p].status = CBSGHD_IDLE;
1123	pj	705
		706	jet_update_endcycle(); /* Update the Jet data... */
		707
		708	return 0;
1085	pj	709	}
		710
1123	pj	711	static void CBSGHD_public_end(LEVEL l, PID p)
1085	pj	712	{
		713	CBSGHD_level_des lev = (CBSGHD_level_des )(level_table[l]);
		714
		715	/* check if the capacity became negative... */
		716	/* there is a while because if the wcet is << than the system tick
		717	we need to postpone the deadline many times */
		718	while (proc_table[p].avail_time < 0) {
		719	/* the CBSGHD rule for recharging the capacity */
		720	proc_table[p].avail_time += lev->cnormal[p];
		721	ADDUSEC2TIMESPEC(lev->period[p], &lev->cbsghd_dline[p]);
		722	}
		723
		724	level_table[ lev->scheduling_level ]->
1123	pj	725	private_extract(lev->scheduling_level,p);
1085	pj	726
		727	/* we delete the reactivation timer */
1123	pj	728	kern_event_delete(lev->reactivation_timer[p]);
1085	pj	729	lev->reactivation_timer[p] = -1;
		730
		731
		732	/* Finally, we post the zombie event. when the end period is reached,
		733	the task descriptor and banwidth are freed */
		734	proc_table[p].status = CBSGHD_ZOMBIE;
		735	lev->reactivation_timer[p] = kern_event_post(&lev->cbsghd_dline[p],
		736	CBSGHD_timer_zombie,
		737	(void *)p);
		738	}
		739
		740	/* Registration functions */
		741
		742	/*+ Registration function:
		743	int flags the init flags ... see CBS.h +*/
1123	pj	744	LEVEL CBSGHD_register_level(int flags, LEVEL master)
1085	pj	745	{
		746	LEVEL l; /* the level that we register */
		747	CBSGHD_level_des lev; / for readableness only */
		748	PID i; /* a counter */
		749
		750	printk("CBSGHD_register_level\n");
		751
		752	/* request an entry in the level_table */
1123	pj	753	l = level_alloc_descriptor(sizeof(CBSGHD_level_des));
1085	pj	754
1123	pj	755	lev = (CBSGHD_level_des *)level_table[l];
1085	pj	756
		757	printk(" lev=%d\n",(int)lev);
		758
		759	/* fill the standard descriptor */
1123	pj	760	lev->l.public_scheduler = CBSGHD_public_scheduler;
1085	pj	761
		762	if (flags & CBSGHD_ENABLE_GUARANTEE)
1123	pj	763	lev->l.public_guarantee = CBSGHD_public_guarantee;
1085	pj	764	else
1123	pj	765	lev->l.public_guarantee = NULL;
1085	pj	766
1123	pj	767	lev->l.public_create = CBSGHD_public_create;
		768	lev->l.public_detach = CBSGHD_public_detach;
		769	lev->l.public_end = CBSGHD_public_end;
		770	lev->l.public_dispatch = CBSGHD_public_dispatch;
		771	lev->l.public_epilogue = CBSGHD_public_epilogue;
		772	lev->l.public_activate = CBSGHD_public_activate;
		773	lev->l.public_unblock = CBSGHD_public_unblock;
		774	lev->l.public_block = CBSGHD_public_block;
		775	lev->l.public_message = CBSGHD_public_message;
1085	pj	776
		777	/* fill the CBSGHD descriptor part */
		778	for (i=0; i<MAX_PROC; i++) {
		779	NULL_TIMESPEC(&lev->cbsghd_dline[i]);
		780	lev->period[i] = 0;
1123	pj	781	NULL_TIMESPEC(&lev->request_time[i]);
1085	pj	782	lev->last_response_time[i] = 0;
		783	NULL_TIMESPEC(&lev->reactivation_time[i]);
		784	lev->reactivation_timer[i] = -1;
		785	}
		786
		787
		788	lev->U = 0;
		789	lev->idle = 0;
		790	lev->queue = NULL;
		791
		792	lev->scheduling_level = master;
		793
		794	lev->flags = flags & 0x07;
1123	pj	795
		796	return l;
1085	pj	797	}
		798
		799
		800	int CBSGHD_get_response_time(LEVEL l, PID p)
		801	{
		802	CBSGHD_level_des lev = (CBSGHD_level_des )(level_table[l]);
1123	pj	803
1085	pj	804	return lev->last_response_time[p];
		805	}
		806
		807
		808	bandwidth_t CBSGHD_usedbandwidth(LEVEL l)
		809	{
		810	CBSGHD_level_des lev = (CBSGHD_level_des )(level_table[l]);
1123	pj	811
		812	return lev->U;
1085	pj	813	}
		814

Subversion Repositories shark

(root)/demos/trunk/cash/cash.c @ 1312 - Rev 1287