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

Subversion Repositories shark

(root)/shark/trunk/ports/first/first-server.c @ 1063 - Rev 896