WebSVN - shark - Blame - Rev 888 - /shark/trunk/ports/first/first-server.c

Rev	Author	Line No.	Line
221	giacomo	1	//=====================================================================
		2	// FFFFFFIII RRRRR SSTTTTTTT
		3	// FF IIR RR SS
		4	// FF IR SS
		5	// FFFFFF RRRR SSSSST
		6	// FF FI RRR SS
		7	// FF II RRR SS
		8	// FF IIIIIR RS
		9	//
		10	// Basic FSF(FIRST Scheduling Framework) contract management
		11	// S.Ha.R.K. Implementation
		12	//=====================================================================
		13
405	trimarchi	14	#include "ll/i386/64bit.h"
679	trimarchi	15	#include <kernel/kern.h>
		16	#include <modules/sem.h>
		17	#include <modules/hartport.h>
		18	#include <modules/cabs.h>
405	trimarchi	19
881	trimarchi	20	#include "fsf.h"
679	trimarchi	21	#include "fsf_service_task.h"
		22	#include "message.h"
221	giacomo	23
868	trimarchi	24	#include "posixstar.h"
		25	#include "edfstar.h"
		26	#include "nonestar.h"
		27	#include "rmstar.h"
		28
221	giacomo	29	#include <pthread.h>
		30	#include <stdlib.h>
808	trimarchi	31	#include "pistar.h"
868	trimarchi	32	#include <modules/comm_message.h>
221	giacomo	33
417	giacomo	34	//#define FSF_DEBUG
221	giacomo	35
410	trimarchi	36	int current_server=0;
407	giacomo	37	server_elem server_list[FSF_MAX_N_SERVERS];
406	giacomo	38	bandwidth_t fsf_max_bw = 0;
405	trimarchi	39
241	giacomo	40	int fsf_server_level;
868	trimarchi	41	int fsf_posix_level = -1;
808	trimarchi	42	int shared_object_level;
679	trimarchi	43	PID server_task;
868	trimarchi	44	fsf_contract_parameters_t contract;
221	giacomo	45
868	trimarchi	46
679	trimarchi	47	PORT channel[2];
		48
868	trimarchi	49	fsf_server_id_t service_server = -1;
		50	fsf_contract_parameters_t service_contract;
		51
808	trimarchi	52	int FSF_register_shared_object_module(void) {
811	trimarchi	53	fsf_register_shared_object();
808	trimarchi	54	return PISTAR_register_module();
		55	}
		56
		57
810	trimarchi	58	int FSF_get_shared_object_level() {
		59	return shared_object_level;
		60	}
		61
868	trimarchi	62	int FSF_register_module(int posix_level, int server_level, bandwidth_t max_bw)
224	giacomo	63	{
		64	printk("FSF Module\n");
410	trimarchi	65	current_server=0;
241	giacomo	66	fsf_server_level = server_level;
868	trimarchi	67	fsf_posix_level = posix_level;
406	giacomo	68	fsf_max_bw = max_bw;
811	trimarchi	69	shared_object_level = FSF_register_shared_object_module();
679	trimarchi	70
224	giacomo	71	return 0;
		72
		73	}
		74
868	trimarchi	75	void FSF_start_service_task(void) {
679	trimarchi	76
868	trimarchi	77	int err;
881	trimarchi	78	struct timespec default_period = FSF_SERVICE_THREAD_PERIOD;
		79	struct timespec default_budget = FSF_SERVICE_THREAD_BUDGET;
868	trimarchi	80	DUMMY_TASK_MODEL m;
881	trimarchi	81	fsf_sched_params_t pr;
868	trimarchi	82
881	trimarchi	83	pr.policy=FSF_NONE;
		84	pr.params=&m;
		85
868	trimarchi	86	dummy_task_default_model(m);
		87
679	trimarchi	88	// create the service task
		89	// create the communication channel for negotiation and renegotiation
		90
		91	channel[1] = port_create("CHANW",sizeof(struct mess),1,STREAM,WRITE);
		92
		93	channel[0] = port_create("CHANR",sizeof(struct mess),1,STREAM,READ);
		94
868	trimarchi	95	fsf_initialize_contract(&service_contract);
		96
		97	fsf_set_contract_basic_parameters(&service_contract,&default_budget,&default_period,FSF_DEFAULT_WORKLOAD);
		98	negotiate_contract(&service_contract,&service_server);
		99
		100	//server_task = task_create("stask",service_task,model,NULL);
881	trimarchi	101	err = fsf_create_local_thread(service_server,&pr, &server_task,NULL,(fsf_thread_code_t)service_task,NULL);
868	trimarchi	102	if (err) {
679	trimarchi	103	cprintf("error creating service task\n");
		104	sys_shutdown_message("Could not create service_task");
		105	sys_end();
		106	return;
		107	}
		108
		109	task_activate(server_task);
		110
		111	}
		112
		113
221	giacomo	114	/* Convert the contract specification to
		115	* budget parameters
		116	*/
241	giacomo	117	int set_SERVER_budget_from_contract
221	giacomo	118	(const fsf_contract_parameters_t *contract,
		119	int *budget)
		120	{
		121
		122	int local_scheduler_level = 0;
		123
868	trimarchi	124	switch (contract->policy) {
		125	case FSF_POSIX:
241	giacomo	126	local_scheduler_level = POSIXSTAR_register_level(fsf_server_level,5000,32);
221	giacomo	127	break;
868	trimarchi	128	case FSF_EDF:
241	giacomo	129	local_scheduler_level = EDFSTAR_register_level(fsf_server_level);
221	giacomo	130	break;
868	trimarchi	131	case FSF_RM:
241	giacomo	132	local_scheduler_level = RMSTAR_register_level(fsf_server_level);
221	giacomo	133	break;
868	trimarchi	134	case FSF_NONE:
855	trimarchi	135	local_scheduler_level = NONESTAR_register_level(fsf_server_level);
334	giacomo	136	break;
221	giacomo	137	}
405	trimarchi	138
661	giacomo	139	if (contract->d_equals_t == TRUE) {
241	giacomo	140	*budget = SERVER_setbudget(fsf_server_level,
221	giacomo	141	TIMESPEC2USEC(&(contract->budget_min)),
		142	TIMESPEC2USEC(&(contract->period_max)),
661	giacomo	143	TIMESPEC2USEC(&(contract->period_max)),
868	trimarchi	144	local_scheduler_level,contract->policy);
661	giacomo	145	} else {
		146	*budget = SERVER_setbudget(fsf_server_level,
		147	TIMESPEC2USEC(&(contract->budget_min)),
		148	TIMESPEC2USEC(&(contract->period_max)),
		149	TIMESPEC2USEC(&(contract->deadline)),
868	trimarchi	150	local_scheduler_level,contract->policy);
661	giacomo	151	}
221	giacomo	152
		153	return 0;
		154
		155	}
		156
405	trimarchi	157	int adjust_SERVER_budget
		158	(int budget, const TIME budget_actual,
661	giacomo	159	const TIME period_actual, const TIME dline_actual)
221	giacomo	160	{
		161
241	giacomo	162	SERVER_adjust_budget(fsf_server_level,
405	trimarchi	163	budget_actual,
		164	period_actual,
661	giacomo	165	dline_actual,
241	giacomo	166	budget);
221	giacomo	167
		168	return 0;
		169
		170	}
		171
		172	/* Admission Test function */
		173	int add_contract(const fsf_contract_parameters_t *contract)
		174	{
		175	return 0;
		176
		177	}
		178
687	trimarchi	179	void contract_to_server(const fsf_contract_parameters_t *contract, int i) {
		180
410	trimarchi	181	TIME T,Q;
		182	#ifdef FSF_DEBUG
		183	int temp;
		184	#endif
		185
		186	T=TIMESPEC2USEC(&contract->period_min);
		187	Q=TIMESPEC2USEC(&contract->budget_max);
		188	mul32div32to32(MAX_BANDWIDTH,Q,T,server_list[current_server].Umax);
		189
417	giacomo	190	T=TIMESPEC2USEC(&contract->period_min);
		191	server_list[i].Tmin=T;
		192
410	trimarchi	193	T=TIMESPEC2USEC(&contract->period_max);
		194	server_list[i].Tmax=T;
417	giacomo	195
410	trimarchi	196	Q=TIMESPEC2USEC(&contract->budget_min);
		197	server_list[i].Cmin=Q;
		198
		199	mul32div32to32(MAX_BANDWIDTH,Q,T,server_list[i].Umin);
416	trimarchi	200	server_list[i].U=server_list[i].Umin;
661	giacomo	201
		202	if (contract->d_equals_t == TRUE) {
		203	server_list[i].deadline = 0;
		204	server_list[i].d_equals_t = TRUE;
		205	} else {
		206	server_list[i].deadline = TIMESPEC2USEC(&contract->deadline);;
		207	server_list[i].d_equals_t = FALSE;
		208	}
		209
843	trimarchi	210	server_list[i].Qs = contract->quality;
		211	server_list[i].Is = contract->importance;
		212
410	trimarchi	213	#ifdef FSF_DEBUG
		214	mul32div32to32(server_list[i].Umax,100, MAX_BANDWIDTH, temp);
		215	kern_printf("(Umax %d)",temp);
		216	mul32div32to32(server_list[i].Umin,100, MAX_BANDWIDTH, temp);
		217	kern_printf("(Umin %d)",temp);
		218	#endif
		219
687	trimarchi	220	}
		221
		222	int relink_contract_to_server(const fsf_contract_parameters_t *contract,
		223	fsf_server_id_t server)
		224	{
		225	int i=0;
		226	#ifdef FSF_DEBUG
		227	kern_printf("(Relink Server %d)",server);
		228	#endif
		229	// find contract
		230	while(i<current_server) {
		231	if (server_list[i].server==server) break;
		232	i++;
		233	}
		234
		235	server_list[i].server=server;
843	trimarchi	236	// server_list[i].Qs=1;
687	trimarchi	237
		238	contract_to_server(contract, i);
		239
		240
410	trimarchi	241	return 0;
		242
		243	}
		244
221	giacomo	245	int link_contract_to_server(const fsf_contract_parameters_t *contract,
		246	fsf_server_id_t server)
		247	{
407	giacomo	248	#ifdef FSF_DEBUG
405	trimarchi	249	kern_printf("(Link Server %d)",server);
		250	#endif
		251
410	trimarchi	252	server_list[current_server].server=server;
843	trimarchi	253	//server_list[current_server].Qs=1;
405	trimarchi	254
687	trimarchi	255	contract_to_server(contract,current_server);
405	trimarchi	256
410	trimarchi	257	current_server++;
221	giacomo	258	return 0;
		259
		260	}
		261
		262	int remove_contract(fsf_server_id_t server)
		263	{
405	trimarchi	264	int i=0;
		265	// find the contract
410	trimarchi	266	while(i<current_server) {
405	trimarchi	267	if (server_list[i].server==server) break;
		268	i++;
		269	}
221	giacomo	270
405	trimarchi	271	// compress the array;
410	trimarchi	272	while (i<(current_server-1)) {
405	trimarchi	273	server_list[i].server=server_list[i+1].server;
		274	server_list[i].Umin=server_list[i+1].Umin;
416	trimarchi	275	server_list[i].U=server_list[i+1].Umin;
405	trimarchi	276	server_list[i].Umax=server_list[i+1].Umax;
		277	server_list[i].Cmin=server_list[i+1].Cmin;
417	giacomo	278	server_list[i].Tmin=server_list[i+1].Tmin;
405	trimarchi	279	server_list[i].Tmax=server_list[i+1].Tmax;
		280	server_list[i].Qs=server_list[i+1].Qs;
661	giacomo	281	server_list[i].deadline = server_list[i+1].deadline;
		282	server_list[i].d_equals_t = server_list[i+1].d_equals_t;
843	trimarchi	283	server_list[i].Is = server_list[i+1].Is;
417	giacomo	284
405	trimarchi	285	i++;
		286	}
410	trimarchi	287	current_server--;
405	trimarchi	288
		289
221	giacomo	290	return 0;
		291
		292	}
		293
868	trimarchi	294	int
		295	fsf_get_renegotiation_status
		296	(fsf_server_id_t server,
		297	fsf_renegotiation_status_t *renegotiation_status)
		298	{
221	giacomo	299
868	trimarchi	300	if (SERVER_get_renegotiation_status(fsf_server_level,server))
		301	*renegotiation_status=FSF_IN_PROGRESS;
		302	else
		303	*renegotiation_status=FSF_ADMITTED;
		304
		305	return 0;
		306
		307
		308	}
		309
		310
221	giacomo	311	int fsf_negotiate_contract
		312	(const fsf_contract_parameters_t *contract,
		313	fsf_server_id_t *server)
		314	{
880	trimarchi	315	struct mess m;
221	giacomo	316
679	trimarchi	317	// send response server is -1 if the operation fail
880	trimarchi	318	m.type=NEGOTIATE_CONTRACT;
		319	memmove(&m.contract,contract, sizeof(fsf_contract_parameters_t));
		320	//kern_printf("(SN:%d)",*server);
		321	port_send(channel[1],&m,BLOCK);
		322	//kern_printf("BR:%d)", *server);
		323	port_receive(channel[0], &m, BLOCK);
		324	//kern_printf("(EN:%d)", *server);
		325	if (m.server==-1)
679	trimarchi	326	return FSF_ERR_CONTRACT_REJECTED;
221	giacomo	327
880	trimarchi	328	*server=m.server;
679	trimarchi	329
221	giacomo	330	return 0;
		331
		332	}
		333
872	trimarchi	334	int
		335	fsf_negotiate_contract_for_new_thread
		336	(const fsf_contract_parameters_t *contract,
		337	fsf_server_id_t *server,
		338	pthread_t *thread,
		339	pthread_attr_t *attr,
		340	fsf_thread_code_t thread_code,
		341	void *arg) {
		342
		343	int err=0;
		344
		345	err = fsf_negotiate_contract(contract,server);
		346	if (!err) {
		347	err = pthread_create(thread, attr, thread_code, arg);
		348	if (!err)
		349	err = fsf_bind_thread_to_server(server,thread);
		350	} else return err;
		351
		352	return err;
		353	}
		354
		355	int
		356	fsf_negotiate_contract_for_myself
		357	(const fsf_contract_parameters_t *contract,
		358	fsf_server_id_t *server) {
		359
		360	int err=0;
		361
		362	err = fsf_negotiate_contract(contract,server);
880	trimarchi	363	//kern_printf("ENMyS:%d", *server);
872	trimarchi	364	if (!err) {
		365	err = fsf_bind_thread_to_server(*server,exec_shadow);
880	trimarchi	366	//kern_printf("EMMyE:%d:%d",*server,err);
872	trimarchi	367	} else return err;
		368
		369	return err;
		370	}
		371
868	trimarchi	372	int fsf_unbind_thread_from_server
		373	(pthread_t thread)
		374	{
		375
		376	int local_scheduler_level, scheduler_id;
		377
		378	/* Move thread from the local scheduler module to posix level */
		379
		380	#ifdef FSF_DEBUG
		381	kern_printf("(UnBind thread = %d)",thread);
		382	#endif
		383
		384	/* Check if thread exsists */
		385	if (thread == -1)
		386	return FSF_ERR_BAD_ARGUMENT;
		387
		388	local_scheduler_level = SERVER_get_local_scheduler_level_from_pid(fsf_server_level,thread);
		389	scheduler_id = SERVER_get_local_scheduler_id_from_pid(fsf_server_level,thread);
		390
		391	/* Check if thread is already bind */
		392	if (scheduler_id == FSF_NONE) {
		393	/* Check if it is bind to a server */
		394	if (NONESTAR_getbudget(local_scheduler_level,thread) == -1)
		395	return FSF_ERR_BAD_ARGUMENT;
		396	else {
		397
		398	STD_command_message *msg;
		399	NRT_TASK_MODEL nrt;
		400
		401	nrt_task_default_model(nrt);
		402	nrt_task_def_save_arrivals(nrt);
		403
		404	/* Send change level command to local scheduler */
		405	msg = (STD_command_message *)malloc(sizeof(STD_command_message));
		406
		407	msg->command = STD_SET_NEW_MODEL;
		408	msg->param = (void *)(&nrt);
		409	level_table[fsf_posix_level]->public_message(fsf_posix_level,thread,msg);
		410
		411	msg->command = STD_SET_NEW_LEVEL;
		412	msg->param = (void *)(fsf_posix_level);
		413	task_message(msg,thread,0);
		414
		415	free(msg);
		416	}
		417	}
		418
		419	return 0;
		420
		421	}
		422
873	trimarchi	423	int
		424	fsf_bind_local_thread_to_server
		425	(fsf_server_id_t server,
		426	pthread_t thread,
		427	fsf_sched_params_t *sched_params)
		428	{
868	trimarchi	429
873	trimarchi	430	STD_command_message *msg;
		431	int local_scheduler_level,scheduler_id;
		432
		433	/* Move thread from the posix module to local scheduler */
		434
		435	#ifdef FSF_DEBUG
		436	kern_printf("(Bind thread = %d to Server = %d)",thread,server);
		437	#endif
		438
		439	/* Check if server and thread exsist */
		440	if (server == -1 \|\| thread == -1)
		441	return FSF_ERR_BAD_ARGUMENT;
		442
		443	local_scheduler_level = SERVER_get_local_scheduler_level_from_budget(fsf_server_level,server);
		444	if (local_scheduler_level==-1)
		445	return FSF_ERR_UNKNOWN_APPSCHEDULED_THREAD;
		446
		447	scheduler_id = SERVER_get_local_scheduler_id_from_budget(fsf_server_level,server);
881	trimarchi	448
		449	if (scheduler_id!=sched_params->policy)
		450	return FSF_ERR_SCHED_POLICY_NOT_COMPATIBLE;
873	trimarchi	451
		452	/* Check if thread is already bind */
		453	switch(scheduler_id) {
		454
		455	case FSF_RM:
		456	{
881	trimarchi	457	TASK_MODEL m=(TASK_MODEL)(sched_params->params);
		458	HARD_TASK_MODEL h=(HARD_TASK_MODEL )(sched_params->params);
873	trimarchi	459
		460	if (m->pclass != HARD_PCLASS)
		461	return FSF_ERR_SCHED_POLICY_NOT_COMPATIBLE;
		462
		463	h = (HARD_TASK_MODEL *)m;
		464
		465	if (!h->wcet \|\| !h->mit) return FSF_ERR_SCHED_POLICY_NOT_COMPATIBLE;
		466
		467	/* now we know that m is a valid model */
		468	if (RMSTAR_getbudget(local_scheduler_level,thread) != -1)
		469	return FSF_ERR_BAD_ARGUMENT;
		470
		471	/* Set server on local scheduler */
		472	RMSTAR_setbudget(local_scheduler_level,thread,(int)(server));
		473
		474	/* Send change level command to posix level */
		475	}
877	trimarchi	476	break;
		477
873	trimarchi	478	case FSF_EDF:
		479	{
881	trimarchi	480	TASK_MODEL m=(TASK_MODEL)(sched_params->params);
		481	HARD_TASK_MODEL h=(HARD_TASK_MODEL )(sched_params->params);
873	trimarchi	482
		483	if (m->pclass != HARD_PCLASS)
		484	return FSF_ERR_SCHED_POLICY_NOT_COMPATIBLE;
		485
		486	h = (HARD_TASK_MODEL *)m;
		487
		488	if (!h->wcet \|\| !h->mit) return FSF_ERR_SCHED_POLICY_NOT_COMPATIBLE;
		489
		490	if (EDFSTAR_getbudget(local_scheduler_level,thread) != -1)
		491	return FSF_ERR_BAD_ARGUMENT;
		492
		493	/* Set server on local scheduler */
		494	EDFSTAR_setbudget(local_scheduler_level,thread,(int)(server));
		495
		496	}
		497	break;
		498
		499	case FSF_POSIX:
		500	{
881	trimarchi	501	TASK_MODEL m=(TASK_MODEL)(sched_params->params);
873	trimarchi	502
		503	if (m->pclass != NRT_PCLASS)
		504	return FSF_ERR_SCHED_POLICY_NOT_COMPATIBLE;
		505
		506	if (POSIXSTAR_getbudget(local_scheduler_level,thread) != -1)
		507	return FSF_ERR_BAD_ARGUMENT;
		508
		509	/* Set server on local scheduler */
		510	POSIXSTAR_setbudget(local_scheduler_level,thread,(int)(server));
		511	}
877	trimarchi	512	break;
873	trimarchi	513
877	trimarchi	514	default:
		515
873	trimarchi	516	return FSF_ERR_BAD_ARGUMENT;
877	trimarchi	517
873	trimarchi	518	}
		519
		520	msg = (STD_command_message *)malloc(sizeof(STD_command_message));
877	trimarchi	521	if (msg) {
		522	SYS_FLAGS f;
		523	f=kern_fsave();
873	trimarchi	524	msg->command = STD_SET_NEW_MODEL;
881	trimarchi	525	msg->param = (void *)(sched_params->params);
873	trimarchi	526	level_table[local_scheduler_level]->public_message(local_scheduler_level,thread,msg);
		527
		528	msg->command = STD_SET_NEW_LEVEL;
		529	msg->param = (void *)(local_scheduler_level);
		530	task_message(msg,thread,0);
877	trimarchi	531	kern_frestore(f);
873	trimarchi	532	free(msg);
		533	} else return FSF_ERR_INTERNAL_ERROR;
		534
		535	return 0;
		536
		537	}
		538
		539
868	trimarchi	540	int fsf_bind_thread_to_server
		541	(fsf_server_id_t server,
		542	pthread_t thread)
		543	{
		544
		545	STD_command_message *msg;
		546	int local_scheduler_level,scheduler_id;
		547
		548	/* Move thread from the posix module to local scheduler */
		549
		550	#ifdef FSF_DEBUG
880	trimarchi	551	kern_printf("(Bthr=%d to Sr=%d)",thread,server);
868	trimarchi	552	#endif
		553
		554	/* Check if server and thread exsist */
		555	if (server == -1 \|\| thread == -1)
		556	return FSF_ERR_BAD_ARGUMENT;
		557
		558	local_scheduler_level = SERVER_get_local_scheduler_level_from_budget(fsf_server_level,server);
873	trimarchi	559	if (local_scheduler_level==-1)
		560	return FSF_ERR_UNKNOWN_APPSCHEDULED_THREAD;
		561
868	trimarchi	562	scheduler_id = SERVER_get_local_scheduler_id_from_budget(fsf_server_level,server);
		563
		564	/* Check if thread is already bind */
		565	if (scheduler_id == FSF_NONE) {
		566	DUMMY_TASK_MODEL rt_arg;
		567
		568	if (NONESTAR_getbudget(local_scheduler_level,thread) != -1)
		569	return FSF_ERR_BAD_ARGUMENT;
		570
		571	/* Set server on local scheduler */
		572	NONESTAR_setbudget(local_scheduler_level,thread,(int)(server));
		573
		574	/* Send change level command to posix level */
		575	msg = (STD_command_message *)malloc(sizeof(STD_command_message));
		576
		577	msg->command = STD_SET_NEW_MODEL;
		578	msg->param = (void *)(&rt_arg);
		579	level_table[local_scheduler_level]->public_message(local_scheduler_level,thread,msg);
		580
		581	msg->command = STD_SET_NEW_LEVEL;
		582	msg->param = (void *)(local_scheduler_level);
		583	task_message(msg,thread,0);
		584	free(msg);
		585	} else return FSF_ERR_BAD_ARGUMENT;
		586
		587	return 0;
		588	}
		589
881	trimarchi	590	int fsf_create_local_thread
		591	(fsf_server_id_t server,
		592	fsf_sched_params_t *local_scheduler_arg,
		593	pthread_t *thread,
		594	pthread_attr_t *attr,
		595	fsf_thread_code_t thread_code,
		596	void *arg)
221	giacomo	597	{
		598
		599	int local_scheduler_level,scheduler_id;
		600
		601	/* Check if server and thread exsist */
241	giacomo	602	if (server == NIL)
873	trimarchi	603	return FSF_ERR_BAD_ARGUMENT;
221	giacomo	604
241	giacomo	605	local_scheduler_level = SERVER_get_local_scheduler_level_from_budget(fsf_server_level,server);
		606	scheduler_id = SERVER_get_local_scheduler_id_from_budget(fsf_server_level,server);
868	trimarchi	607	#ifdef FSF_DEBUG
		608	kern_printf("sched policy %d", scheduler_id);
		609	#endif
888	trimarchi	610
		611	if (scheduler_id!=local_scheduler_arg->policy)
		612	return FSF_ERR_SCHED_POLICY_NOT_COMPATIBLE;
		613
221	giacomo	614	/* Check if thread is already bind */
		615	switch (scheduler_id) {
873	trimarchi	616	case FSF_POSIX:
221	giacomo	617
888	trimarchi	618	nrt_task_def_arg((NRT_TASK_MODEL )(local_scheduler_arg->params),arg);
		619	nrt_task_def_level((NRT_TASK_MODEL )(local_scheduler_arg->params),local_scheduler_level);
221	giacomo	620
888	trimarchi	621	*thread = task_create("POSIXSTAR", thread_code, local_scheduler_arg->params, NULL);
267	giacomo	622	if (*thread == NIL) {
		623	#ifdef FSF_DEBUG
		624	kern_printf("(FSF:Error creating thread)");
		625	#endif
873	trimarchi	626	return FSF_ERR_INTERNAL_ERROR;
267	giacomo	627	}
221	giacomo	628
241	giacomo	629	POSIXSTAR_setbudget(local_scheduler_level, *thread, (int)(server));
234	giacomo	630
221	giacomo	631	break;
868	trimarchi	632	case FSF_EDF:
221	giacomo	633
888	trimarchi	634	hard_task_def_arg((HARD_TASK_MODEL )(local_scheduler_arg->params),arg);
		635	hard_task_def_level((HARD_TASK_MODEL )(local_scheduler_arg->params),local_scheduler_level);
250	giacomo	636
888	trimarchi	637	*thread = task_create("EDFSTAR", thread_code, local_scheduler_arg->params, NULL);
250	giacomo	638	if (*thread == NIL)
873	trimarchi	639	return FSF_ERR_INTERNAL_ERROR;
250	giacomo	640
		641	EDFSTAR_setbudget(local_scheduler_level, *thread, (int)(server));
		642
221	giacomo	643	break;
235	giacomo	644
868	trimarchi	645	case FSF_RM:
235	giacomo	646
888	trimarchi	647	hard_task_def_arg((HARD_TASK_MODEL )(local_scheduler_arg->params),arg);
		648	hard_task_def_level((HARD_TASK_MODEL )(local_scheduler_arg->params),local_scheduler_level);
273	giacomo	649
888	trimarchi	650	*thread = task_create("RMSTAR", thread_code, local_scheduler_arg->params, NULL);
273	giacomo	651	if (*thread == NIL)
873	trimarchi	652	return FSF_ERR_INTERNAL_ERROR;
273	giacomo	653
		654	RMSTAR_setbudget(local_scheduler_level, *thread, (int)(server));
		655
		656	break;
868	trimarchi	657	case FSF_NONE:
334	giacomo	658
888	trimarchi	659	dummy_task_def_arg(( DUMMY_TASK_MODEL )(local_scheduler_arg->params),arg);
		660	dummy_task_def_level(( DUMMY_TASK_MODEL )(local_scheduler_arg->params),local_scheduler_level);
879	trimarchi	661	#ifdef FSF_DEBUG
		662	kern_printf("(None Server create task)");
		663	#endif
888	trimarchi	664	*thread = task_create("NONESTAR", thread_code, local_scheduler_arg->params, NULL);
334	giacomo	665	if (*thread == NIL)
873	trimarchi	666	return FSF_ERR_INTERNAL_ERROR;
334	giacomo	667
855	trimarchi	668	NONESTAR_setbudget(local_scheduler_level, *thread, (int)(server));
334	giacomo	669
		670	break;
		671
221	giacomo	672	default:
873	trimarchi	673	return FSF_ERR_INTERNAL_ERROR;
221	giacomo	674	break;
		675	}
811	trimarchi	676
		677	#ifdef FSF_DEBUG
		678	kern_printf("(FSF:Insert thread = %d to Server = %d)",*thread,server);
		679	#endif
221	giacomo	680
		681	return 0;
		682
		683	}
		684
808	trimarchi	685	int fsf_settask_nopreemptive
221	giacomo	686	(fsf_server_id_t *server,
		687	pthread_t thread)
		688	{
		689	int local_scheduler_level, scheduler_id;
		690
241	giacomo	691	local_scheduler_level = SERVER_get_local_scheduler_level_from_pid(fsf_server_level,thread);
		692	scheduler_id = SERVER_get_local_scheduler_id_from_pid(fsf_server_level, thread);
221	giacomo	693
		694	switch (scheduler_id) {
868	trimarchi	695	case FSF_POSIX:
816	trimarchi	696	POSIXSTAR_set_nopreemtive_current(local_scheduler_level);
		697	return 1;
808	trimarchi	698	break;
868	trimarchi	699	case FSF_EDF:
808	trimarchi	700	EDFSTAR_set_nopreemtive_current(local_scheduler_level);
		701	return 1;
		702	break;
868	trimarchi	703	case FSF_RM:
812	trimarchi	704	RMSTAR_set_nopreemtive_current(local_scheduler_level);
		705	return 1;
808	trimarchi	706	break;
868	trimarchi	707	case FSF_NONE:
808	trimarchi	708	break;
		709	default:
		710	return -1;
		711	}
		712	return -1;
		713	}
		714
		715
		716	int fsf_settask_preemptive
		717	(fsf_server_id_t *server,
		718	pthread_t thread)
		719	{
		720	int local_scheduler_level, scheduler_id;
		721
		722	local_scheduler_level = SERVER_get_local_scheduler_level_from_pid(fsf_server_level,thread);
		723	scheduler_id = SERVER_get_local_scheduler_id_from_pid(fsf_server_level, thread);
		724
		725	switch (scheduler_id) {
868	trimarchi	726	case FSF_POSIX:
823	trimarchi	727	POSIXSTAR_unset_nopreemtive_current(local_scheduler_level);
816	trimarchi	728	return 1;
808	trimarchi	729	break;
868	trimarchi	730	case FSF_EDF:
808	trimarchi	731	EDFSTAR_unset_nopreemtive_current(local_scheduler_level);
		732	return 1;
		733	break;
868	trimarchi	734	case FSF_RM:
812	trimarchi	735	RMSTAR_unset_nopreemtive_current(local_scheduler_level);
		736	return 1;
808	trimarchi	737	break;
868	trimarchi	738	case FSF_NONE:
808	trimarchi	739	break;
		740	default:
		741	return -1;
		742	}
		743
		744	return -1;
		745
		746	}
		747
		748
		749	int fsf_get_server
868	trimarchi	750	(pthread_t thread,
		751	fsf_server_id_t *server)
808	trimarchi	752	{
		753	int local_scheduler_level, scheduler_id;
		754
		755	local_scheduler_level = SERVER_get_local_scheduler_level_from_pid(fsf_server_level,thread);
		756	scheduler_id = SERVER_get_local_scheduler_id_from_pid(fsf_server_level, thread);
		757
		758	switch (scheduler_id) {
868	trimarchi	759	case FSF_POSIX:
829	giacomo	760	*server = POSIXSTAR_getbudget(local_scheduler_level,thread);
		761	return 0;
868	trimarchi	762	case FSF_EDF:
829	giacomo	763	*server = EDFSTAR_getbudget(local_scheduler_level,thread);
		764	return 0;
868	trimarchi	765	case FSF_RM:
829	giacomo	766	*server = RMSTAR_getbudget(local_scheduler_level,thread);
		767	return 0;
868	trimarchi	768	case FSF_NONE:
855	trimarchi	769	*server = NONESTAR_getbudget(local_scheduler_level,thread);
829	giacomo	770	return 0;
235	giacomo	771	default:
221	giacomo	772	return -1;
		773	}
		774
		775	return -1;
		776
		777	}
		778
339	giacomo	779	int fsf_get_server_level(void)
		780	{
		781
		782	return fsf_server_level;
		783
		784	}
		785
221	giacomo	786	int fsf_cancel_contract
868	trimarchi	787	(fsf_server_id_t server)
221	giacomo	788	{
		789
		790	int local_scheduler_level, scheduler_id;
411	trimarchi	791	SYS_FLAGS f;
		792	TIME T,Q;
		793	int i=0;
221	giacomo	794
		795	#ifdef FSF_DEBUG
868	trimarchi	796	kern_printf("(Remove server %d)",server);
221	giacomo	797	#endif
		798
		799	/* Check server id */
868	trimarchi	800	if (server < 0)
873	trimarchi	801	return FSF_ERR_BAD_ARGUMENT;
221	giacomo	802
868	trimarchi	803	local_scheduler_level = SERVER_get_local_scheduler_level_from_budget(fsf_server_level,server);
		804	scheduler_id = SERVER_get_local_scheduler_id_from_budget(fsf_server_level,server);
221	giacomo	805
		806	switch (scheduler_id) {
868	trimarchi	807	case FSF_POSIX:
221	giacomo	808
		809	/* Check if some thread use the server */
868	trimarchi	810	if(POSIXSTAR_budget_has_thread(local_scheduler_level,server))
873	trimarchi	811	return FSF_ERR_NOT_CONTRACTED_SERVER;
221	giacomo	812
		813	break;
868	trimarchi	814	case FSF_EDF:
235	giacomo	815	/* Check if some thread use the server */
868	trimarchi	816	if(EDFSTAR_budget_has_thread(local_scheduler_level,server))
873	trimarchi	817	return FSF_ERR_NOT_CONTRACTED_SERVER;
235	giacomo	818	break;
		819
868	trimarchi	820	case FSF_RM:
235	giacomo	821	/* Check if some thread use the server */
868	trimarchi	822	if(RMSTAR_budget_has_thread(local_scheduler_level,server))
873	trimarchi	823	return FSF_ERR_NOT_CONTRACTED_SERVER;
235	giacomo	824
221	giacomo	825	break;
334	giacomo	826
868	trimarchi	827	case FSF_NONE:
334	giacomo	828	/* Check if some thread use the server */
868	trimarchi	829	if(NONESTAR_budget_has_thread(local_scheduler_level,server))
873	trimarchi	830	return FSF_ERR_NOT_CONTRACTED_SERVER;
334	giacomo	831
		832	break;
		833
221	giacomo	834	}
		835
868	trimarchi	836	SERVER_removebudget(fsf_server_level,server);
221	giacomo	837
		838	level_free_descriptor(local_scheduler_level);
405	trimarchi	839
868	trimarchi	840	remove_contract(server);
411	trimarchi	841
		842	f=kern_fsave();
		843	if (recalculate_contract(fsf_max_bw)==-1) {
		844	kern_frestore(f);
873	trimarchi	845	return FSF_ERR_INTERNAL_ERROR;
411	trimarchi	846	}
		847	#ifdef FSF_DEBUG
		848	kern_printf("(Adjust budget)");
		849	#endif
		850	for (i=0; i<current_server; i++) {
		851	mul32div32to32(MAX_BANDWIDTH,server_list[i].Cmin,server_list[i].U,T);
417	giacomo	852	if (T > server_list[i].Tmin ) {
411	trimarchi	853	server_list[i].actual_budget = server_list[i].Cmin;
		854	server_list[i].actual_period = T;
417	giacomo	855	#ifdef FSF_DEBUG
		856	kern_printf("(1 - Q %ld T %ld)", server_list[i].actual_budget, server_list[i].actual_period);
		857	#endif
661	giacomo	858
		859	if (server_list[i].d_equals_t == TRUE)
		860	adjust_SERVER_budget(server_list[i].server,server_list[i].Cmin, T, T);
		861	else
		862	adjust_SERVER_budget(server_list[i].server,server_list[i].Cmin, T, server_list[i].deadline);
		863
411	trimarchi	864	} else {
417	giacomo	865	mul32div32to32(server_list[i].Tmin,server_list[i].U,MAX_BANDWIDTH,Q);
411	trimarchi	866	server_list[i].actual_budget = Q;
417	giacomo	867	server_list[i].actual_period = server_list[i].Tmin;
		868	#ifdef FSF_DEBUG
		869	kern_printf("(2 - Q %ld T %ld)", server_list[i].actual_budget, server_list[i].actual_period);
		870	#endif
661	giacomo	871
		872	if (server_list[i].d_equals_t == TRUE)
		873	adjust_SERVER_budget(server_list[i].server,Q, server_list[i].Tmin, server_list[i].Tmin);
		874	else
		875	adjust_SERVER_budget(server_list[i].server,Q, server_list[i].Tmin, server_list[i].deadline);
		876
411	trimarchi	877	}
416	trimarchi	878	server_list[i].U=server_list[i].Umin;
411	trimarchi	879
		880	}
221	giacomo	881
405	trimarchi	882
411	trimarchi	883	kern_frestore(f);
221	giacomo	884
		885	return 0;
411	trimarchi	886
221	giacomo	887	}
		888
881	trimarchi	889	bandwidth_t SERVER_return_bandwidth() {
		890	int i=0;
		891	bandwidth_t U;
		892	U=0;
		893	for(i=0;i<current_server;i++) {
		894
		895	U+=server_list[i].Umin;
		896
		897	}
		898
		899	return U;
		900	}
		901
405	trimarchi	902	int recalculate_contract(bandwidth_t U) {
416	trimarchi	903	bandwidth_t current_bandwidth;
418	giacomo	904	unsigned int temp_U;
416	trimarchi	905	int Qt;
405	trimarchi	906	int isok=0;
		907	int i=0;
868	trimarchi	908	int target_importance=FSF_DEFAULT_IMPORTANCE;
		909
		910	#define MAX_IMPORTANCE 5
405	trimarchi	911
407	giacomo	912	#ifdef FSF_DEBUG
		913	int temp;
		914
		915	kern_printf("(Recalculate contract)");
		916	#endif
405	trimarchi	917
		918	/* The current bandwidth is the min bandwidth */
881	trimarchi	919	current_bandwidth=SERVER_return_bandwidth(fsf_server_level);
405	trimarchi	920	#ifdef FSF_DEBUG
410	trimarchi	921	kern_printf("(nserver %d)", current_server);
405	trimarchi	922	#endif
880	trimarchi	923	//kern_printf("(CS:%d)", current_server);
405	trimarchi	924	do {
		925	current_bandwidth=0;
		926	Qt=0;
410	trimarchi	927	for (i=0; i<current_server; i++) {
843	trimarchi	928	if (server_list[i].Is==target_importance
		929	&& server_list[i].U<server_list[i].Umax && server_list[i].Qs>0)
405	trimarchi	930	Qt+=server_list[i].Qs;
416	trimarchi	931	current_bandwidth+=server_list[i].U;
868	trimarchi	932	#ifdef FSF_DEBUG
843	trimarchi	933	kern_printf("(Qs %d, Qt %d, Is %d)", server_list[i].Qs, Qt,server_list[i].Is);
868	trimarchi	934	#endif
405	trimarchi	935	}
413	trimarchi	936
868	trimarchi	937	#ifdef FSF_DEBUG
405	trimarchi	938	kern_printf("(Total Quality %d)", Qt);
868	trimarchi	939	#endif
405	trimarchi	940	isok=1;
410	trimarchi	941	for (i=0; i<current_server; i++) {
843	trimarchi	942	if (server_list[i].Is==target_importance && server_list[i].U<server_list[i].Umax && server_list[i].Qs>0) {
416	trimarchi	943	temp_U=server_list[i].U;
		944	server_list[i].U=U-current_bandwidth;
		945	mul32div32to32(server_list[i].U, server_list[i].Qs, Qt, server_list[i].U);
		946	temp_U+=server_list[i].U;
		947
		948	if (temp_U<=server_list[i].Umin) {
405	trimarchi	949	server_list[i].U=server_list[i].Umin;
416	trimarchi	950	} else if (temp_U>server_list[i].Umax) {
		951	server_list[i].U=server_list[i].Umax;
405	trimarchi	952	isok=0;
		953	} else server_list[i].U=temp_U;
		954
		955	#ifdef FSF_DEBUG
		956	mul32div32to32(server_list[i].U,100, MAX_BANDWIDTH, temp);
		957	kern_printf("(Server %d bw %d)", server_list[i].server, temp);
		958	#endif
		959	}
		960	}
843	trimarchi	961	target_importance++;
880	trimarchi	962	} while (!isok \|\| target_importance<=MAX_IMPORTANCE);
		963	//kern_printf("(RNDNL)");
405	trimarchi	964	return 0;
		965	}
		966
221	giacomo	967	int fsf_renegotiate_contract
		968	(const fsf_contract_parameters_t *new_contract,
		969	fsf_server_id_t server)
		970	{
679	trimarchi	971
		972	struct mess message;
221	giacomo	973
679	trimarchi	974	// send response server is -1 if the operation fail
		975	message.type=RENEGOTIATE_CONTRACT;
		976	memmove(&message.contract,new_contract, sizeof(fsf_contract_parameters_t));
		977	message.server = server;
221	giacomo	978
859	trimarchi	979	port_send(channel[1],&message,BLOCK);
		980
		981	port_receive(channel[0], &message, BLOCK);
		982
679	trimarchi	983	if (message.server==-1) return FSF_ERR_CONTRACT_REJECTED;
		984
405	trimarchi	985	return 0;
221	giacomo	986	}
241	giacomo	987
868	trimarchi	988	int fsf_request_contract_renegotiation
		989	(const fsf_contract_parameters_t *new_contract,
		990	fsf_server_id_t server,
		991	int sig_notify,
		992	union sigval sig_value)
		993	{
		994
		995	struct mess message;
		996
		997	// send response server is -1 if the operation fail
		998	message.type=REQUEST_RENEGOTIATE_CONTRACT;
		999	memmove(&message.contract,new_contract, sizeof(fsf_contract_parameters_t));
		1000	message.server = server;
		1001
		1002	port_send(channel[1],&message,BLOCK);
		1003
		1004	port_receive(channel[0], &message, BLOCK);
		1005
		1006	if (message.server==-1) return FSF_ERR_CONTRACT_REJECTED;
		1007
		1008	return 0;
		1009	}
		1010
407	giacomo	1011	void print_server_list()
		1012	{
		1013
		1014	int i;
		1015
		1016	kern_printf("Server List\n");
		1017
410	trimarchi	1018	for(i=0;i<current_server;i++) {
407	giacomo	1019
662	giacomo	1020	kern_printf("[%d] Q:%d T:%d D:%d [DeT = %d]\n",server_list[i].server,(int)server_list[i].actual_budget,(int)server_list[i].actual_period,(int)server_list[i].deadline,(int)server_list[i].d_equals_t);
407	giacomo	1021
		1022	}
		1023
		1024	}
808	trimarchi	1025
		1026
		1027	int fsf_get_remain_budget(fsf_server_id_t server) {
		1028
825	trimarchi	1029	return SERVER_get_remain_capacity(fsf_server_level, server);
808	trimarchi	1030	}
868	trimarchi	1031
		1032	int fsf_get_budget_and_period
		1033	(fsf_server_id_t server,
		1034	struct timespec *budget,
		1035	struct timespec *period) {
		1036	TIME bg;
		1037	TIME pd;
		1038
		1039	if (!SERVER_getbudgetinfo(fsf_server_level, &bg, &pd, NULL, server)) {
		1040	if (budget) {
		1041	NULL_TIMESPEC(budget);
		1042	ADDUSEC2TIMESPEC(bg, budget);
		1043	}
		1044	if (period) {
		1045	NULL_TIMESPEC(period);
		1046	ADDUSEC2TIMESPEC(pd, period);
		1047	}
		1048
		1049	return 0;
		1050	}
		1051	return FSF_ERR_BAD_ARGUMENT;
		1052	}
		1053
		1054	int
		1055	fsf_set_service_thread_data
		1056	(const struct timespec *budget,
		1057	const struct timespec *period,
		1058	bool *accepted) {
		1059
		1060	if (budget==NULL && period==NULL) return FSF_ERR_BAD_ARGUMENT;
		1061	fsf_set_contract_basic_parameters(&service_contract,budget,period,FSF_DEFAULT_WORKLOAD);
		1062	*accepted = !fsf_renegotiate_contract(&service_contract,service_server)?true:false;
		1063	return 0;
		1064
		1065	}
		1066
		1067
		1068
		1069	int fsf_get_service_thread_data
		1070	(struct timespec *budget,
		1071	struct timespec *period) {
		1072
		1073	return fsf_get_budget_and_period(service_server, budget, period);
		1074
		1075	}
		1076

Subversion Repositories shark

(root)/shark/trunk/ports/first/first-server.c - Rev 888