Subversion Repositories shark

Compare Revisions

Ignore whitespace Rev 962 → Rev 963

/shark/trunk/ports/first/first-error.c
15,34 → 15,44
#include <string.h>
static char *fsf_msg[]={
"Too Many Task",
"Bad argument",
"Invalid synch object handle",
"No renegotiation request",
"Contract rejected",
"Not scheduled calling thread",
"Unbound error",
"Unknown application scheduled thread",
"No contracted server",
"Not scheduled thread",
"Too many service jobs",
"Too many synch object",
"Too many servers in synch object",
"Too many events in synch object",
"FSF internal error",
"Too many servers",
"Invalid scheduler reply",
"Too many many pending replenishments",
"System already initialized",
"Shared object already initialized",
"Shared object not initizialized",
"Scheduling policy not compatible",
"TOO_MANY_TASKS ",
"BAD_ARGUMENT ",
"INVALID_SYNCH_OBJ_HANDLE ",
"NO_RENEGOTIATION_REQUESTED ",
"CONTRACT_REJECTED ",
"NOT_SCHEDULED_CALLING_THREAD ",
"NOT_BOUND_THREAD ",
"UNKNOWN_SCHEDULED_THREAD ",
"NOT_CONTRACTED_SERVER ",
"NOT_SCHEDULED_THREAD ",
"TOO_MANY_SERVICE_JOBS ",
"TOO_MANY_SYNCH_OBJS ",
"TOO_MANY_SERVERS_IN_SYNCH_OBJ ",
"TOO_MANY_EVENTS_IN_SYNCH_OBJ ",
"INTERNAL_ERROR ",
"TOO_MANY_SERVERS ",
"INVALID_SCHEDULER_REPLY ",
"TOO_MANY_PENDING_REPLENISHMENTS",
"SYSTEM_ALREADY_INITIALIZED ",
"SHARED_OBJ_ALREADY_INITIALIZED ",
"SHARED_OBJ_NOT_INITIALIZED ",
"SCHED_POLICY_NOT_COMPATIBLE ",
"SERVER_WORKLOAD_NOT_COMPATIBLE ",
"ALREADY_BOUND ",
"WRONG_NETWORK ",
"TOO_LARGE ",
"BUFFER_FULL ",
"NO_SPACE ",
"NO_MESSAGES ",
"MODULE_NOT_SUPPORTED ",
"SYSTEM_NOT_INITIALIZED ",
"TOO_MANY_SHARED_OBJS ",
};
 
int fsf_strerror (int error, char *message, size_t size)
{
if (error>FSF_ERR_CODES_BASE && error<FSF_ERR_CODES_BASE+FSF_ERR_CODES_MAX) {
strncpy(message, fsf_msg[error-FSF_ERR_CODES_BASE-1], size);
} else return -1;
if (message && size>0 && error>FSF_ERR_BASE_VALUE && error<=FSF_ERR_LAST_VALUE) {
strncpy(message, fsf_msg[error-FSF_ERR_BASE_VALUE-1], size);
} else return FSF_ERR_BAD_ARGUMENT;
return 0;
}
/shark/trunk/ports/first/first-server.c
384,13 → 384,12
// send response server is -1 if the operation fail
m.type=NEGOTIATE_CONTRACT;
memmove(&m.contract,contract, sizeof(fsf_contract_parameters_t));
//kern_printf("(SN:%d)",*server);
port_send(channel[1],&m,BLOCK);
//kern_printf("BR:%d)", *server);
port_receive(channel[0], &m, BLOCK);
//kern_printf("(EN:%d)", *server);
if (m.server==-1)
return FSF_ERR_CONTRACT_REJECTED;
if (m.server==-1) {
*server=0;
return 0;
}
 
*server=m.server;
443,25 → 442,29
{
 
int local_scheduler_level, scheduler_id;
 
SYS_FLAGS f;
/* Move thread from the local scheduler module to posix level */
 
#ifdef FSF_DEBUG
kern_printf("(UnBind thread = %d)",thread);
#endif
 
f=kern_fsave();
/* Check if thread exsists */
if (thread == -1)
if (thread == -1) {
kern_frestore(f);
return FSF_ERR_BAD_ARGUMENT;
}
 
local_scheduler_level = SERVER_get_local_scheduler_level_from_pid(fsf_server_level,thread);
scheduler_id = SERVER_get_local_scheduler_id_from_pid(fsf_server_level,thread);
 
/* Check if thread is already bind */
if (scheduler_id == FSF_NONE) {
/* Check if it is bind to a server */
if (NONESTAR_getbudget(local_scheduler_level,thread) == -1)
if (NONESTAR_getbudget(local_scheduler_level,thread) == -1) {
kern_frestore(f);
return FSF_ERR_BAD_ARGUMENT;
}
else {
STD_command_message *msg;
469,6 → 472,9
 
nrt_task_default_model(nrt);
nrt_task_def_save_arrivals(nrt);
nrt_task_def_weight(nrt,0);
nrt_task_def_policy(nrt,NRT_RR_POLICY);
nrt_task_def_inherit(nrt,NRT_EXPLICIT_SCHED);
 
/* Send change level command to local scheduler */
msg = (STD_command_message *)malloc(sizeof(STD_command_message));
480,9 → 486,19
msg->command = STD_SET_NEW_LEVEL;
msg->param = (void *)(fsf_posix_level);
task_message(msg,thread,0);
//if (exec_shadow!=thread)
level_table[proc_table[thread].task_level]->public_epilogue(proc_table[thread].task_level, thread);
//else {
//scheduler();
//kern_context_load(proc_table[exec_shadow].context);
//}
kern_frestore(f);
 
free(msg);
}
} else {
kern_frestore(f);
return FSF_ERR_BAD_ARGUMENT;
}
 
return 0;
613,11 → 629,12
pthread_t thread)
{
 
STD_command_message *msg;
STD_command_message *msg=0;
int local_scheduler_level,scheduler_id;
SYS_FLAGS f;
/* Move thread from the posix module to local scheduler */
 
f=kern_fsave();
#ifdef FSF_DEBUG
kern_printf("(Bthr=%d to Sr=%d)",thread,server);
#endif
631,36 → 648,46
return FSF_ERR_UNKNOWN_SCHEDULED_THREAD;
 
scheduler_id = SERVER_get_local_scheduler_id_from_budget(fsf_server_level,server);
 
/* Check if thread is already bind */
if (scheduler_id == FSF_NONE) {
DUMMY_TASK_MODEL rt_arg;
if (NONESTAR_getbudget(local_scheduler_level,thread) != -1)
if (NONESTAR_getbudget(local_scheduler_level,thread) != -1) {
kern_frestore(f);
return FSF_ERR_BAD_ARGUMENT;
 
}
/* Set server on local scheduler */
NONESTAR_setbudget(local_scheduler_level,thread,(int)(server));
f=kern_fsave();
/* Send change level command to posix level */
msg = (STD_command_message *)malloc(sizeof(STD_command_message));
 
if (!msg) exit(-1);
msg->command = STD_SET_NEW_MODEL;
msg->param = (void *)(&rt_arg);
level_table[local_scheduler_level]->public_message(local_scheduler_level,thread,msg);
msg->command = STD_SET_NEW_LEVEL;
msg->param = (void *)(local_scheduler_level);
task_message(msg,thread,0);
task_message(msg,thread,0);
//if (thread!=exec_shadow) {
level_table[proc_table[thread].task_level]->public_dispatch(proc_table[thread].task_level, thread, 0);
level_table[proc_table[thread].task_level]->public_epilogue(proc_table[thread].task_level, thread);
//} else {
if (cap_timer != NIL) {
event_delete(cap_timer);
cap_timer = NIL;
}
scheduler();
kern_context_load(proc_table[exec_shadow].context);
//}
kern_frestore(f);
 
free(msg);
if (msg) free(msg);
} else return FSF_ERR_BAD_ARGUMENT;
 
} else {
kern_frestore(f);
return FSF_ERR_BAD_ARGUMENT;
}
return 0;
}
 
884,8 → 911,9
int local_scheduler_level, scheduler_id;
SYS_FLAGS f;
TIME T,Q;
int i=0;
int i=0,err=0;
 
 
#ifdef FSF_DEBUG
kern_printf("(Remove server %d)",server);
#endif
920,13 → 948,15
 
case FSF_NONE:
/* Check if some thread use the server */
if(NONESTAR_budget_has_thread(local_scheduler_level,server))
return FSF_ERR_NOT_CONTRACTED_SERVER;
if(NONESTAR_budget_has_thread(local_scheduler_level,server)) {
err=fsf_unbind_thread_from_server(NONESTAR_get_current(local_scheduler_level));
if (err) return err;
}
break;
 
}
 
SERVER_removebudget(fsf_server_level,server);
 
level_free_descriptor(local_scheduler_level);
942,21 → 972,35
kern_printf("(Adjust budget)");
#endif
for (i=0; i<current_server; i++) {
mul32div32to32(MAX_BANDWIDTH,server_list[i].Cmin,server_list[i].U,T);
if (T > server_list[i].Tmin ) {
server_list[i].actual_budget = server_list[i].Cmin;
 
if (T > server_list[i].Tmax)
T=server_list[i].Tmax;
 
server_list[i].actual_period = T;
server_list[i].actual_budget = server_list[i].Cmin;
#ifdef FSF_DEBUG
kern_printf("(1 - Q %ld T %ld)", server_list[i].actual_budget, server_list[i].actual_period);
#endif
 
if (server_list[i].d_equals_t == true)
adjust_SERVER_budget(server_list[i].server,server_list[i].Cmin, T, T);
adjust_SERVER_budget(server_list[i].server,server_list[i].Cmin, T, T);
else
adjust_SERVER_budget(server_list[i].server,server_list[i].Cmin, T, server_list[i].deadline);
 
adjust_SERVER_budget(server_list[i].server,server_list[i].Cmin, T, T); // server_list[i].deadline);
} else {
mul32div32to32(server_list[i].Tmin,server_list[i].U,MAX_BANDWIDTH,Q);
 
if (Q>server_list[i].Cmax)
Q=server_list[i].Cmax;
 
server_list[i].actual_budget = Q;
server_list[i].actual_period = server_list[i].Tmin;
#ifdef FSF_DEBUG
964,10 → 1008,11
#endif
if (server_list[i].d_equals_t == true)
adjust_SERVER_budget(server_list[i].server,Q, server_list[i].Tmin, server_list[i].Tmin);
adjust_SERVER_budget(server_list[i].server,Q, server_list[i].Tmin, server_list[i].Tmin);
else
adjust_SERVER_budget(server_list[i].server,Q, server_list[i].Tmin, server_list[i].deadline);
adjust_SERVER_budget(server_list[i].server,Q, server_list[i].Tmin, server_list[i].Tmin); //server_list[i].deadline);
 
 
}
server_list[i].U=server_list[i].Umin;
1036,7 → 1081,9
if (server_list[i].Is==target_importance && server_list[i].U<server_list[i].Umax && server_list[i].Qs>0) {
temp_U=server_list[i].U;
server_list[i].U=U-current_bandwidth;
//kern_printf("before mull");
mul32div32to32(server_list[i].U, server_list[i].Qs, Qt, server_list[i].U);
//kern_printf("after mull");
temp_U+=server_list[i].U;
if (temp_U<=server_list[i].Umin) {
1054,7 → 1101,7
}
target_importance++;
} while (!isok || target_importance<=MAX_IMPORTANCE);
//kern_printf("(RNDNL)");
 
return 0;
}
1081,10 → 1128,10
msg.server = server;
//kern_printf("(REN %d)", server);
port_send(channel[1],&msg,BLOCK);
 
//kern_printf("After send\n");
port_receive(channel[0], &msg, BLOCK);
 
//kern_printf("(REN %d)", msg.server);
//kern_printf("After receive\n");
//kern_printf("(EREN %d)", msg.server);
if (msg.server==-1) return FSF_ERR_CONTRACT_REJECTED;
return 0;
1131,12 → 1178,24
 
}
 
 
int fsf_get_remain_budget(fsf_server_id_t server) {
 
int
fsf_get_remaining_budget
(fsf_server_id_t server,
struct timespec *budget) {
TIME t;
NULL_TIMESPEC(budget);
t=SERVER_get_remain_capacity(fsf_server_level, server);
ADDUSEC2TIMESPEC(t, budget);
return 0;
}
/*
int fsf_get_remaining_budget(fsf_server_id_t server) {
return SERVER_get_remain_capacity(fsf_server_level, server);
}
 
*/
int fsf_get_budget_and_period
(fsf_server_id_t server,
struct timespec *budget,
1202,3 → 1261,40
return 0;
 
}
 
int
fsf_get_total_quality
(fsf_server_id_t server, int *total_quality) {
 
return 0;
}
 
int
fsf_get_available_capacity (
fsf_server_id_t server, uint32_t *capacity){
 
return 0;
}
 
bool
fsf_is_admission_test_enabled() {
return true;
}
 
 
int
fsf_get_cpu_time
(fsf_server_id_t server,
struct timespec *cpu_time) {
 
return 0;
}
 
 
int
fsf_get_contract
(fsf_server_id_t server,
fsf_contract_parameters_t *contract) {
 
return 0;
}