/shark/trunk/ports/first/first-sync.c |
---|
11,21 → 11,60 |
// S.Ha.R.K. Implementation |
//===================================================================== |
#include "fsf_contract.h" |
#include "fsf_configuration_parameters.h" |
#include "fsf_core.h" |
#include "fsf_server.h" |
#include "posixstar.h" |
#include "edfstar.h" |
#include "nonestar.h" |
#include "rmstar.h" |
extern int fsf_server_level; |
struct hash_entry { |
IQUEUE threads; |
int events; |
FSF_SYNCH_OBJ_HANDLE_T_OPAQUE id; |
}; |
#define MAX_HASH_ENTRY FSF_MAX_N_SYNCH_OBJECTS |
struct hash_entry htable[MAX_HASH_ENTRY]; |
void FSF_init_synch_obj_layer() { |
int i; |
for (i=0; i<MAX_HASH_ENTRY; i++) |
htable[i].id=-1; |
} |
/*----------------------------------------------------------------------*/ |
/* hash_fun() : address hash table */ |
/*----------------------------------------------------------------------*/ |
static int hash_fun(FSF_SYNCH_OBJ_HANDLE_T_OPAQUE id) |
{ |
return (id % MAX_HASH_ENTRY); |
} |
//#define FSF_DEBUG |
int |
fsf_create_synchobject(fsf_synch_object_handle_t *synch_handle) |
fsf_create_synchobject(fsf_synch_obj_handle_t *synch_handle) |
{ |
int index,oldindex; |
if (!synch_handle) return FSF_ERR_INVALID_SYNCH_OBJECT_HANDLE; |
index=hash_fun(*synch_handle); |
if (htable[index].id!=*synch_handle) { |
oldindex=index; |
index = (index + 1) % MAX_HASH_ENTRY; |
// find |
while (htable[index].id != *synch_handle && index!=oldindex) index=(index+1) % MAX_HASH_ENTRY; |
if (index==oldindex) return FSF_ERR_TOO_MANY_SYNCH_OBJS; |
} |
//if (!synch_handle) return FSF_ERR_INVALID_SYNCH_OBJECT_HANDLE; |
iq_init(&synch_handle->threads, NULL, 0); |
synch_handle->events = 0; |
iq_init(&(htable[index].threads), NULL, 0); |
htable[index].events = 0; |
return 0; |
32,17 → 71,28 |
} |
int |
fsf_signal_synchobject(fsf_synch_object_handle_t *synch_handle) |
fsf_signal_synchobject(fsf_synch_obj_handle_t *synch_handle) |
{ |
PID p; |
int index, oldindex; |
if (!synch_handle) return FSF_ERR_INVALID_SYNCH_OBJECT_HANDLE; |
index=hash_fun(*synch_handle); |
if (htable[index].id!=*synch_handle) { |
oldindex=index; |
index = (index + 1) % MAX_HASH_ENTRY; |
// find |
while (htable[index].id != *synch_handle && index!=oldindex) index=(index+1) % MAX_HASH_ENTRY; |
if (index==oldindex) return FSF_ERR_INVALID_SYNCH_OBJ_HANDLE; |
} |
//if (!synch_handle) return FSF_ERR_INVALID_SYNCH_OBJECT_HANDLE; |
if ((p = iq_getfirst(&synch_handle->threads)) != NIL) |
if ((p = iq_getfirst(&(htable[index].threads))) != NIL) |
task_activate(p); |
else |
synch_handle->events++; |
htable[index].events++; |
return 0; |
49,14 → 99,25 |
} |
int |
fsf_destroy_synchobject(fsf_synch_object_handle_t *synch_handle) |
fsf_destroy_synchobject(fsf_synch_obj_handle_t *synch_handle) |
{ |
int index, oldindex; |
if (!synch_handle) return FSF_ERR_INVALID_SYNCH_OBJECT_HANDLE; |
index=hash_fun(*synch_handle); |
while (iq_getfirst(&synch_handle->threads) != NIL); |
synch_handle->events = 0; |
if (htable[index].id!=*synch_handle) { |
oldindex=index; |
index = (index + 1) % MAX_HASH_ENTRY; |
// find |
while (htable[index].id != *synch_handle && index!=oldindex) index=(index+1) % MAX_HASH_ENTRY; |
if (index==oldindex) return FSF_ERR_INVALID_SYNCH_OBJ_HANDLE; |
} |
//if (!synch_handle) return FSF_ERR_INVALID_SYNCH_OBJECT_HANDLE; |
while (iq_getfirst(&(htable[index].threads)) != NIL); |
htable[index].events = 0; |
return 0; |
} |
78,16 → 139,16 |
if (proc_table[exec_shadow].task_level != local_scheduler_level) return 0; |
switch (scheduler_id) { |
case FSF_SCHEDULER_POSIX: |
case FSF_POSIX: |
budget = POSIXSTAR_getbudget(local_scheduler_level, exec_shadow); |
break; |
case FSF_SCHEDULER_EDF: |
case FSF_EDF: |
budget = EDFSTAR_getbudget(local_scheduler_level, exec_shadow); |
break; |
case FSF_SCHEDULER_NONE: |
case FSF_NONE: |
budget = NONESTAR_getbudget(local_scheduler_level, exec_shadow); |
break; |
case FSF_SCHEDULER_RM: |
case FSF_RM: |
budget = RMSTAR_getbudget(local_scheduler_level, exec_shadow); |
break; |
136,7 → 197,7 |
int |
fsf_schedule_next_event_triggered_job |
(fsf_synch_object_handle_t *synch_handle, |
(fsf_synch_obj_handle_t *synch_handle, |
struct timespec *next_budget, |
struct timespec *next_period, |
bool *was_deadline_missed, |
144,6 → 205,7 |
{ |
TIME T,Q,D; |
int index,oldindex; |
int budget, local_scheduler_level, scheduler_id; |
local_scheduler_level = SERVER_get_local_scheduler_level_from_pid(fsf_server_level, exec_shadow); |
152,13 → 214,13 |
if (proc_table[exec_shadow].task_level != local_scheduler_level) return 0; |
switch (scheduler_id) { |
case FSF_SCHEDULER_POSIX: |
case FSF_POSIX: |
budget = POSIXSTAR_getbudget(local_scheduler_level, exec_shadow); |
break; |
case FSF_SCHEDULER_EDF: |
case FSF_EDF: |
budget = EDFSTAR_getbudget(local_scheduler_level, exec_shadow); |
break; |
case FSF_SCHEDULER_RM: |
case FSF_RM: |
default: |
budget = -1; |
break; |
185,12 → 247,22 |
*was_deadline_missed = false; |
if (was_budget_overran != NULL) |
*was_budget_overran = false; |
index=hash_fun(*synch_handle); |
if (htable[index].id!=*synch_handle) { |
oldindex=index; |
index = (index + 1) % MAX_HASH_ENTRY; |
// find |
while (htable[index].id != *synch_handle && index!=oldindex) index=(index+1) % MAX_HASH_ENTRY; |
if (index==oldindex) return FSF_ERR_INVALID_SYNCH_OBJ_HANDLE; |
} |
if (synch_handle->events > 0) { |
if (htable[index].events > 0) { |
task_activate(exec_shadow); |
synch_handle->events--; |
htable[index].events--; |
} else |
iq_insertlast(exec_shadow,&synch_handle->threads); |
iq_insertlast(exec_shadow,&(htable[index].threads)); |
#ifdef FSF_DEBUG |
kern_printf("(Synch_Handle Events %d)",synch_handle->events); |
/shark/trunk/ports/first/first-contract.c |
---|
11,8 → 11,11 |
// S.Ha.R.K. Implementation |
//===================================================================== |
#include "fsf_contract.h" |
#include "fsf_core.h" |
#include "fsf_server.h" |
#include "fsf_shared_objects.h" |
#include "fsf_hierarchical.h" |
#include "fsf_spare_capacity.h" |
#include <kernel/descr.h> |
#include <kernel/func.h> |
#include <pistar.h> |
19,11 → 22,11 |
struct hash_entry { |
mutex_t mx; |
int id; |
FSF_SHARED_OBJ_HANDLE_T_OPAQUE id; |
}; |
#define MAX_HASH_ENTRY FSF_MAX_SHARED_OPERATION |
#define MAX_HASH_ENTRY FSF_MAX_N_SHARED_OBJECTS |
struct hash_entry htable[MAX_HASH_ENTRY]; |
30,7 → 33,7 |
/*----------------------------------------------------------------------*/ |
/* hash_fun() : address hash table */ |
/*----------------------------------------------------------------------*/ |
static int hash_fun(fsf_shared_obj_id_t *id) |
static int hash_fun(fsf_shared_obj_id_t id) |
{ |
return (*id % MAX_HASH_ENTRY); |
} |
53,7 → 56,7 |
struct timespec default_deadline = FSF_DEFAULT_DEADLINE; |
/* Check */ |
if (!contract) return FSF_ERR_NOT_INITIALIZED; |
if (!contract) return FSF_ERR_BAD_ARGUMENT; |
/* Set to default value */ |
NULL_TIMESPEC(&contract->budget_min); |
63,7 → 66,7 |
contract->workload = FSF_DEFAULT_WORKLOAD; |
contract->local_scheduler_id = FSF_DEFAULT_SCHEDULER; |
contract->policy = FSF_DEFAULT_SCHED_POLICY; |
contract->d_equals_t = FSF_DEFAULT_D_EQUALS_T; |
90,19 → 93,21 |
int fsf_set_contract_basic_parameters |
(fsf_contract_parameters_t *contract, |
const struct timespec *budget_min, |
const struct timespec *period_max, |
const struct timespec *budget_max, |
const struct timespec *period_min, |
const struct timespec *period_max, |
fsf_workload_t workload) |
{ |
if (!contract) return FSF_ERR_NOT_INITIALIZED; |
if (!contract) return FSF_ERR_BAD_ARGUMENT; |
if (budget_min) TIMESPEC_ASSIGN(&contract->budget_min,budget_min); |
if (period_max) TIMESPEC_ASSIGN(&contract->period_max,period_max); |
if (budget_max) TIMESPEC_ASSIGN(&contract->budget_max,budget_max); |
if (period_min) TIMESPEC_ASSIGN(&contract->period_min,period_min); |
if (budget_min) { |
TIMESPEC_ASSIGN(&contract->budget_min,budget_min); |
TIMESPEC_ASSIGN(&contract->budget_max,budget_min); |
} |
if (period_max) { |
TIMESPEC_ASSIGN(&contract->period_max,period_max); |
TIMESPEC_ASSIGN(&contract->period_min,period_max); |
} |
contract->workload = workload; |
return 0; |
113,17 → 118,13 |
(const fsf_contract_parameters_t *contract, |
struct timespec *budget_min, |
struct timespec *period_max, |
struct timespec *budget_max, |
struct timespec *period_min, |
fsf_workload_t *workload) |
{ |
if (!contract) return FSF_ERR_NOT_INITIALIZED; |
if (!contract) return FSF_ERR_BAD_ARGUMENT; |
TIMESPEC_ASSIGN(budget_min,&contract->budget_min); |
TIMESPEC_ASSIGN(period_max,&contract->period_max); |
TIMESPEC_ASSIGN(budget_max,&contract->budget_max); |
TIMESPEC_ASSIGN(period_min,&contract->period_min); |
TIMESPEC_ASSIGN(period_max,&contract->period_max); |
*workload = contract->workload; |
141,7 → 142,7 |
union sigval deadline_miss_sig_value) |
{ |
if (!contract) return FSF_ERR_NOT_INITIALIZED; |
if (!contract) return FSF_ERR_BAD_ARGUMENT; |
contract->d_equals_t = d_equals_t; |
166,7 → 167,7 |
union sigval *deadline_miss_sig_value) |
{ |
if (!contract) return FSF_ERR_NOT_INITIALIZED; |
if (!contract) return FSF_ERR_BAD_ARGUMENT; |
*d_equals_t = contract->d_equals_t; |
181,20 → 182,26 |
} |
int fsf_set_contract_reclamation_parameters |
(fsf_contract_parameters_t *contract, |
int |
fsf_set_contract_reclamation_parameters |
(fsf_contract_parameters_t *contract, |
const struct timespec *budget_max, |
const struct timespec *period_min, |
fsf_granularity_t granularity, |
const fsf_utilization_set_t *utilization_set, |
const fsf_utilization_set_t *utilization_set, |
int quality, |
int importance) |
{ |
if (!contract) return FSF_ERR_NOT_INITIALIZED; |
if (!contract) return FSF_ERR_BAD_ARGUMENT; |
contract->granularity = granularity; |
if (utilization_set) memcpy(&contract->utilization_set,utilization_set,sizeof(fsf_utilization_set_t)); |
if (budget_max) TIMESPEC_ASSIGN(&contract->budget_max,budget_max); |
if (period_min) TIMESPEC_ASSIGN(&contract->period_min,period_min); |
contract->quality = quality; |
contract->importance = importance; |
204,6 → 211,8 |
int fsf_get_contract_reclamation_parameters |
(const fsf_contract_parameters_t *contract, |
struct timespec *budget_max, |
struct timespec *period_min, |
fsf_granularity_t *granularity, |
fsf_utilization_set_t *utilization_set, |
int *quality, |
210,11 → 219,14 |
int *importance) |
{ |
if (!contract) return FSF_ERR_NOT_INITIALIZED; |
if (!contract) return FSF_ERR_BAD_ARGUMENT; |
*granularity = contract->granularity; |
memcpy(utilization_set,&contract->utilization_set,sizeof(fsf_utilization_set_t)); |
TIMESPEC_ASSIGN(budget_max,&contract->budget_max); |
TIMESPEC_ASSIGN(period_min,&contract->period_min); |
*quality = contract->quality; |
*importance = contract->importance; |
223,35 → 235,27 |
} |
/* OLD VERSION |
int fsf_set_contract_synchronization_parameters |
(fsf_contract_parameters_t *contract, |
fsf_preemption_level_t preemption_level, |
const fsf_critical_sections_t *critical_sections) |
{ |
if (!contract) return FSF_ERR_NOT_INITIALIZED; |
if (!contract) return FSF_ERR_BAD_ARGUMENT; |
contract->preemption_level = preemption_level; |
if (critical_sections) memcpy(&contract->critical_sections,critical_sections,sizeof(fsf_critical_sections_t)); |
return 0; |
} |
*/ |
int |
fsf_get_contract_synchronization_parameters |
(const fsf_contract_parameters_t *contract, |
fsf_preemption_level_t *preemption_level, |
fsf_critical_sections_t *critical_sections) |
{ |
if (!contract) return FSF_ERR_NOT_INITIALIZED; |
*preemption_level = contract->preemption_level; |
if (!contract) return FSF_ERR_BAD_ARGUMENT; |
memcpy(critical_sections,&contract->critical_sections,sizeof(fsf_critical_sections_t)); |
return 0; |
258,15 → 262,15 |
} |
int |
fsf_set_local_scheduler_parameter |
int |
fsf_set_contract_scheduling_policy |
(fsf_contract_parameters_t *contract, |
fsf_scheduler_id_t local_scheduler_id) |
fsf_sched_policy_t sched_policy) |
{ |
if (!contract) return FSF_ERR_NOT_INITIALIZED; |
if (!contract) return FSF_ERR_BAD_ARGUMENT; |
contract->local_scheduler_id = local_scheduler_id; |
contract->policy = sched_policy; |
return 0; |
273,19 → 277,20 |
} |
int |
fsf_get_local_scheduler_parameter |
fsf_get_contract_scheduling_policy |
(const fsf_contract_parameters_t *contract, |
fsf_scheduler_id_t *local_scheduler_id) |
fsf_sched_policy_t *sched_policy) |
{ |
if (!contract) return FSF_ERR_NOT_INITIALIZED; |
if (!contract) return FSF_ERR_BAD_ARGUMENT; |
*local_scheduler_id = contract->local_scheduler_id; |
*sched_policy = contract->policy; |
return 0; |
} |
/* OLD VERSION |
// mutex lock function |
int fsf_lock_object(fsf_shared_operation_t *op) { |
328,8 → 333,12 |
} |
int fsf_init_shared_object(fsf_shared_object_t *obj, |
fsf_shared_obj_id_t id) { |
*/ |
int fsf_init_shared_object |
(fsf_shared_obj_id_t id, |
fsf_shared_obj_handle_t *obj, |
pthread_mutex_t *mutex) { |
int index; |
int oldindex; |
PISTAR_mutexattr_t a; |
339,10 → 348,10 |
//kern_printf("(SI SO)\n"); |
f=kern_fsave(); |
index=hash_fun(&id); |
index=hash_fun(id); |
//kern_printf("Index %d Hash %d", index, htable[index].id); |
if (htable[index].id == id) { |
if (htable[index].id == index) { |
kern_frestore(f); |
return -1; |
} |
359,11 → 368,12 |
} |
} |
obj->size=0; |
//obj->size=0; |
mutex_init(&(htable[index]).mx, &a); |
htable[index].id=id; |
obj->obj_id=id; |
mutex=&(htable[index]).mx; |
htable[index].id=index; |
*obj=*id; |
kern_frestore(f); |
return 0; |
371,7 → 381,7 |
//kern_printf("(EI SO)\n"); |
} |
/* OLD VERSION |
// Declare an operation |
// This function is used to declare that a shared object has |
// a synchronized operation on it. |
417,7 → 427,9 |
} |
*/ |
/* OLD VERSION |
int fsf_set_contract_synchronization_parameters( |
fsf_contract_parameters_t *contract, |
const fsf_shared_operation_t *shared_ops, |
429,3 → 441,4 |
return 0; |
} |
*/ |
/shark/trunk/ports/first/server-task.c |
---|
34,53 → 34,86 |
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
* |
* |
* CVS : $Id: server-task.c,v 1.5 2004-09-10 13:05:33 trimarchi Exp $ |
* CVS : $Id: server-task.c,v 1.6 2004-10-25 14:40:58 trimarchi Exp $ |
*/ |
#include "ll/i386/64bit.h" |
#include "fsf_configuration_parameters.h" |
#include "fsf_core.h" |
#include "fsf_server.h" |
#include "fsf_service_task.h" |
#include "message.h" |
#include <kernel/kern.h> |
#include <modules/sem.h> |
#include <modules/hartport.h> |
#include <modules/cabs.h> |
#include <string.h> |
#include "fsf_contract.h" |
#include "fsf_server.h" |
#include "fsf_service_task.h" |
#include "message.h" |
TASK service_task() { |
//#define FSF_DEBUG |
TASK service_task(void) { |
struct mess message; |
struct mess msg; |
fsf_renegotiation_status_t status; |
int wait_renegotiation=0; |
PORT rec,tra; |
rec = port_connect("CHANW",sizeof(struct mess),STREAM,READ); |
tra = port_connect("CHANR",sizeof(struct mess),STREAM,WRITE); |
while(1) { |
// wait for renegotiation |
port_receive(rec,&message,BLOCK); |
switch (message.type) { |
// wait for operation |
if (wait_renegotiation) { |
if (!fsf_get_renegotiation_status(msg.server,&status)) { |
if (status==FSF_ADMITTED) { |
// send response server is -1 if the operation fail |
#ifdef FSF_DEBUG |
kern_printf("ADM"); |
#endif |
wait_renegotiation=0; |
port_send(tra,&msg,BLOCK); |
//task_endcycle(); |
continue; |
} else |
#ifdef FSF_DEBUG |
kern_printf("WAIT") |
#endif |
; |
} |
} else { |
port_receive(rec,&msg,BLOCK); |
kern_printf("Message "); |
switch (msg.type) { |
case NEGOTIATE_CONTRACT: |
if (negotiate_contract(&msg.contract, &msg.server)==FSF_ERR_CONTRACT_REJECTED) |
msg.server=-1; |
break; |
case REQUEST_RENEGOTIATE_CONTRACT: |
if (renegotiate_contract(&msg.contract, msg.server)==FSF_ERR_CONTRACT_REJECTED) |
msg.server=-1; |
break; |
case RENEGOTIATE_CONTRACT: |
if (renegotiate_contract(&msg.contract, msg.server)==FSF_ERR_CONTRACT_REJECTED) |
msg.server=-1; |
else { |
wait_renegotiation=1; |
//task_endcycle(); |
continue; |
} |
break; |
default : |
break; |
} |
// send response server is -1 if the operation fail |
port_send(tra,&msg,BLOCK); |
//task_endcycle(); |
case NEGOTIATE_CONTRACT: |
if (negotiate_contract(&message.contract, &message.server)==FSF_ERR_CONTRACT_REJECTED) |
message.server=-1; |
break; |
case RENEGOTIATE_CONTRACT: |
if (renegotiate_contract(&message.contract, message.server)==FSF_ERR_CONTRACT_REJECTED) |
message.server=-1; |
break; |
default : |
break; |
} |
// send response server is -1 if the operation fail |
port_send(tra,&message,BLOCK); |
task_endcycle(); |
} |
} |
89,8 → 122,8 |
int i=0; |
TIME T,Q; |
for (i=0; i<current_server; i++) { |
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; |
133,7 → 166,7 |
#endif |
if (!new_contract) |
return FSF_ERR_NOT_INITIALIZED; |
return FSF_ERR_BAD_ARGUMENT; |
if (server < 0) |
return FSF_ERR_INVALID_SERVER; |
154,7 → 187,7 |
fsf_server_id_t *server) |
{ |
/* Check if contract is initialized */ |
if (!contract) return FSF_ERR_NOT_INITIALIZED; |
if (!contract) return FSF_ERR_BAD_ARGUMENT; |
/* Admission Test */ |
if (FSF_ADMISSION_TEST_IS_ENABLED) |
171,6 → 204,7 |
if (*server >= 0) { |
link_contract_to_server(contract,*server); |
if (recalculate_contract(fsf_max_bw)==-1) { |
remove_contract(server); |
return FSF_ERR_CREATE_SERVER; |
} |
set_contract_parameter(); |
/shark/trunk/ports/first/first-server.c |
---|
17,16 → 17,24 |
#include <modules/hartport.h> |
#include <modules/cabs.h> |
#include "fsf_contract.h" |
#include "fsf_basic_types.h" |
#include "fsf_configuration_parameters.h" |
#include "fsf_core.h" |
#include "fsf_server.h" |
#include "fsf_service_task.h" |
#include "fsf_hierarchical.h" |
#include "message.h" |
#include "posixstar.h" |
#include "edfstar.h" |
#include "nonestar.h" |
#include "rmstar.h" |
#include <pthread.h> |
#include <stdlib.h> |
#include "pistar.h" |
#include <modules/comm_message.h> |
//#define FSF_DEBUG |
int current_server=0; |
34,12 → 42,17 |
bandwidth_t fsf_max_bw = 0; |
int fsf_server_level; |
int fsf_posix_level = -1; |
int shared_object_level; |
PID server_task; |
fsf_contract_parameters_t contract; |
PORT channel[2]; |
fsf_server_id_t service_server = -1; |
fsf_contract_parameters_t service_contract; |
int FSF_register_shared_object_module(void) { |
fsf_register_shared_object(); |
return PISTAR_register_module(); |
50,11 → 63,12 |
return shared_object_level; |
} |
int FSF_register_module(int server_level, bandwidth_t max_bw) |
int FSF_register_module(int posix_level, int server_level, bandwidth_t max_bw) |
{ |
printk("FSF Module\n"); |
current_server=0; |
fsf_server_level = server_level; |
fsf_posix_level = posix_level; |
fsf_max_bw = max_bw; |
shared_object_level = FSF_register_shared_object_module(); |
62,8 → 76,15 |
} |
void FSF_start_service_task(SOFT_TASK_MODEL *model) { |
void FSF_start_service_task(void) { |
int err; |
struct timespec default_period = {0,50000000}; |
struct timespec default_budget = {0,1000000}; |
DUMMY_TASK_MODEL m; |
dummy_task_default_model(m); |
// create the service task |
// create the communication channel for negotiation and renegotiation |
71,8 → 92,14 |
channel[0] = port_create("CHANR",sizeof(struct mess),1,STREAM,READ); |
server_task = task_create("stask",service_task,model,NULL); |
if (server_task == -1) { |
fsf_initialize_contract(&service_contract); |
fsf_set_contract_basic_parameters(&service_contract,&default_budget,&default_period,FSF_DEFAULT_WORKLOAD); |
negotiate_contract(&service_contract,&service_server); |
//server_task = task_create("stask",service_task,model,NULL); |
err = fsf_create_thread(service_server,&server_task,NULL,service_task,NULL,&m); |
if (err) { |
cprintf("error creating service task\n"); |
sys_shutdown_message("Could not create service_task"); |
sys_end(); |
94,17 → 121,17 |
int local_scheduler_level = 0; |
switch (contract->local_scheduler_id) { |
case FSF_SCHEDULER_POSIX: |
switch (contract->policy) { |
case FSF_POSIX: |
local_scheduler_level = POSIXSTAR_register_level(fsf_server_level,5000,32); |
break; |
case FSF_SCHEDULER_EDF: |
case FSF_EDF: |
local_scheduler_level = EDFSTAR_register_level(fsf_server_level); |
break; |
case FSF_SCHEDULER_RM: |
case FSF_RM: |
local_scheduler_level = RMSTAR_register_level(fsf_server_level); |
break; |
case FSF_SCHEDULER_NONE: |
case FSF_NONE: |
local_scheduler_level = NONESTAR_register_level(fsf_server_level); |
break; |
} |
114,13 → 141,13 |
TIMESPEC2USEC(&(contract->budget_min)), |
TIMESPEC2USEC(&(contract->period_max)), |
TIMESPEC2USEC(&(contract->period_max)), |
local_scheduler_level,contract->local_scheduler_id); |
local_scheduler_level,contract->policy); |
} else { |
*budget = SERVER_setbudget(fsf_server_level, |
TIMESPEC2USEC(&(contract->budget_min)), |
TIMESPEC2USEC(&(contract->period_max)), |
TIMESPEC2USEC(&(contract->deadline)), |
local_scheduler_level,contract->local_scheduler_id); |
local_scheduler_level,contract->policy); |
} |
return 0; |
264,7 → 291,23 |
} |
int |
fsf_get_renegotiation_status |
(fsf_server_id_t server, |
fsf_renegotiation_status_t *renegotiation_status) |
{ |
if (SERVER_get_renegotiation_status(fsf_server_level,server)) |
*renegotiation_status=FSF_IN_PROGRESS; |
else |
*renegotiation_status=FSF_ADMITTED; |
return 0; |
} |
int fsf_negotiate_contract |
(const fsf_contract_parameters_t *contract, |
fsf_server_id_t *server) |
278,7 → 321,7 |
port_send(channel[1],&message,BLOCK); |
port_receive(channel[0], &message, BLOCK); |
if (message.server==-1) |
return FSF_ERR_CONTRACT_REJECTED; |
288,6 → 331,106 |
} |
int fsf_unbind_thread_from_server |
(pthread_t thread) |
{ |
int local_scheduler_level, scheduler_id; |
/* Move thread from the local scheduler module to posix level */ |
#ifdef FSF_DEBUG |
kern_printf("(UnBind thread = %d)",thread); |
#endif |
/* Check if thread exsists */ |
if (thread == -1) |
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) |
return FSF_ERR_BAD_ARGUMENT; |
else { |
STD_command_message *msg; |
NRT_TASK_MODEL nrt; |
nrt_task_default_model(nrt); |
nrt_task_def_save_arrivals(nrt); |
/* Send change level command to local scheduler */ |
msg = (STD_command_message *)malloc(sizeof(STD_command_message)); |
msg->command = STD_SET_NEW_MODEL; |
msg->param = (void *)(&nrt); |
level_table[fsf_posix_level]->public_message(fsf_posix_level,thread,msg); |
msg->command = STD_SET_NEW_LEVEL; |
msg->param = (void *)(fsf_posix_level); |
task_message(msg,thread,0); |
free(msg); |
} |
} |
return 0; |
} |
int fsf_bind_thread_to_server |
(fsf_server_id_t server, |
pthread_t thread) |
{ |
STD_command_message *msg; |
int local_scheduler_level,scheduler_id; |
/* Move thread from the posix module to local scheduler */ |
#ifdef FSF_DEBUG |
kern_printf("(Bind thread = %d to Server = %d)",thread,server); |
#endif |
/* Check if server and thread exsist */ |
if (server == -1 || thread == -1) |
return FSF_ERR_BAD_ARGUMENT; |
local_scheduler_level = SERVER_get_local_scheduler_level_from_budget(fsf_server_level,server); |
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) |
return FSF_ERR_BAD_ARGUMENT; |
/* Set server on local scheduler */ |
NONESTAR_setbudget(local_scheduler_level,thread,(int)(server)); |
/* Send change level command to posix level */ |
msg = (STD_command_message *)malloc(sizeof(STD_command_message)); |
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); |
free(msg); |
} else return FSF_ERR_BAD_ARGUMENT; |
return 0; |
} |
int fsf_create_thread |
(fsf_server_id_t server, |
pthread_t *thread, |
305,10 → 448,12 |
local_scheduler_level = SERVER_get_local_scheduler_level_from_budget(fsf_server_level,server); |
scheduler_id = SERVER_get_local_scheduler_id_from_budget(fsf_server_level,server); |
#ifdef FSF_DEBUG |
kern_printf("sched policy %d", scheduler_id); |
#endif |
/* Check if thread is already bind */ |
switch (scheduler_id) { |
case FSF_SCHEDULER_POSIX: |
case FSF_POSIX: |
nrt_task_def_arg(*(NRT_TASK_MODEL *)(local_scheduler_arg),arg); |
nrt_task_def_level(*(NRT_TASK_MODEL *)(local_scheduler_arg),local_scheduler_level); |
324,7 → 469,7 |
POSIXSTAR_setbudget(local_scheduler_level, *thread, (int)(server)); |
break; |
case FSF_SCHEDULER_EDF: |
case FSF_EDF: |
hard_task_def_arg(*(HARD_TASK_MODEL *)(local_scheduler_arg),arg); |
hard_task_def_level(*(HARD_TASK_MODEL *)(local_scheduler_arg),local_scheduler_level); |
337,7 → 482,7 |
break; |
case FSF_SCHEDULER_RM: |
case FSF_RM: |
hard_task_def_arg(*(HARD_TASK_MODEL *)(local_scheduler_arg),arg); |
hard_task_def_level(*(HARD_TASK_MODEL *)(local_scheduler_arg),local_scheduler_level); |
349,10 → 494,10 |
RMSTAR_setbudget(local_scheduler_level, *thread, (int)(server)); |
break; |
case FSF_SCHEDULER_NONE: |
case FSF_NONE: |
hard_task_def_arg(*(HARD_TASK_MODEL *)(local_scheduler_arg),arg); |
hard_task_def_level(*(HARD_TASK_MODEL *)(local_scheduler_arg),local_scheduler_level); |
//dummy_task_def_arg(*( DUMMY_TASK_MODEL *)(local_scheduler_arg),arg); |
dummy_task_def_level(*( DUMMY_TASK_MODEL *)(local_scheduler_arg),local_scheduler_level); |
*thread = task_create("NONESTAR", thread_code, local_scheduler_arg, NULL); |
if (*thread == NIL) |
385,19 → 530,19 |
scheduler_id = SERVER_get_local_scheduler_id_from_pid(fsf_server_level, thread); |
switch (scheduler_id) { |
case FSF_SCHEDULER_POSIX: |
case FSF_POSIX: |
POSIXSTAR_set_nopreemtive_current(local_scheduler_level); |
return 1; |
break; |
case FSF_SCHEDULER_EDF: |
case FSF_EDF: |
EDFSTAR_set_nopreemtive_current(local_scheduler_level); |
return 1; |
break; |
case FSF_SCHEDULER_RM: |
case FSF_RM: |
RMSTAR_set_nopreemtive_current(local_scheduler_level); |
return 1; |
break; |
case FSF_SCHEDULER_NONE: |
case FSF_NONE: |
break; |
default: |
return -1; |
416,19 → 561,19 |
scheduler_id = SERVER_get_local_scheduler_id_from_pid(fsf_server_level, thread); |
switch (scheduler_id) { |
case FSF_SCHEDULER_POSIX: |
case FSF_POSIX: |
POSIXSTAR_unset_nopreemtive_current(local_scheduler_level); |
return 1; |
break; |
case FSF_SCHEDULER_EDF: |
case FSF_EDF: |
EDFSTAR_unset_nopreemtive_current(local_scheduler_level); |
return 1; |
break; |
case FSF_SCHEDULER_RM: |
case FSF_RM: |
RMSTAR_unset_nopreemtive_current(local_scheduler_level); |
return 1; |
break; |
case FSF_SCHEDULER_NONE: |
case FSF_NONE: |
break; |
default: |
return -1; |
440,8 → 585,8 |
int fsf_get_server |
(fsf_server_id_t *server, |
pthread_t thread) |
(pthread_t thread, |
fsf_server_id_t *server) |
{ |
int local_scheduler_level, scheduler_id; |
449,16 → 594,16 |
scheduler_id = SERVER_get_local_scheduler_id_from_pid(fsf_server_level, thread); |
switch (scheduler_id) { |
case FSF_SCHEDULER_POSIX: |
case FSF_POSIX: |
*server = POSIXSTAR_getbudget(local_scheduler_level,thread); |
return 0; |
case FSF_SCHEDULER_EDF: |
case FSF_EDF: |
*server = EDFSTAR_getbudget(local_scheduler_level,thread); |
return 0; |
case FSF_SCHEDULER_RM: |
case FSF_RM: |
*server = RMSTAR_getbudget(local_scheduler_level,thread); |
return 0; |
case FSF_SCHEDULER_NONE: |
case FSF_NONE: |
*server = NONESTAR_getbudget(local_scheduler_level,thread); |
return 0; |
default: |
477,7 → 622,7 |
} |
int fsf_cancel_contract |
(fsf_server_id_t *server) |
(fsf_server_id_t server) |
{ |
int local_scheduler_level, scheduler_id; |
486,40 → 631,40 |
int i=0; |
#ifdef FSF_DEBUG |
kern_printf("(Remove server %d)",*server); |
kern_printf("(Remove server %d)",server); |
#endif |
/* Check server id */ |
if (*server < 0) |
if (server < 0) |
return FSF_ERR_INVALID_SERVER; |
local_scheduler_level = SERVER_get_local_scheduler_level_from_budget(fsf_server_level,*server); |
scheduler_id = SERVER_get_local_scheduler_id_from_budget(fsf_server_level,*server); |
local_scheduler_level = SERVER_get_local_scheduler_level_from_budget(fsf_server_level,server); |
scheduler_id = SERVER_get_local_scheduler_id_from_budget(fsf_server_level,server); |
switch (scheduler_id) { |
case FSF_SCHEDULER_POSIX: |
case FSF_POSIX: |
/* Check if some thread use the server */ |
if(POSIXSTAR_budget_has_thread(local_scheduler_level,*server)) |
if(POSIXSTAR_budget_has_thread(local_scheduler_level,server)) |
return FSF_ERR_SERVER_USED; |
break; |
case FSF_SCHEDULER_EDF: |
case FSF_EDF: |
/* Check if some thread use the server */ |
if(EDFSTAR_budget_has_thread(local_scheduler_level,*server)) |
if(EDFSTAR_budget_has_thread(local_scheduler_level,server)) |
return FSF_ERR_SERVER_USED; |
break; |
case FSF_SCHEDULER_RM: |
case FSF_RM: |
/* Check if some thread use the server */ |
if(RMSTAR_budget_has_thread(local_scheduler_level,*server)) |
if(RMSTAR_budget_has_thread(local_scheduler_level,server)) |
return FSF_ERR_SERVER_USED; |
break; |
case FSF_SCHEDULER_NONE: |
case FSF_NONE: |
/* Check if some thread use the server */ |
if(NONESTAR_budget_has_thread(local_scheduler_level,*server)) |
if(NONESTAR_budget_has_thread(local_scheduler_level,server)) |
return FSF_ERR_SERVER_USED; |
break; |
526,11 → 671,11 |
} |
SERVER_removebudget(fsf_server_level,*server); |
SERVER_removebudget(fsf_server_level,server); |
level_free_descriptor(local_scheduler_level); |
remove_contract(*server); |
remove_contract(server); |
f=kern_fsave(); |
if (recalculate_contract(fsf_max_bw)==-1) { |
573,7 → 718,6 |
} |
*server = -1; |
kern_frestore(f); |
return 0; |
586,7 → 730,9 |
int Qt; |
int isok=0; |
int i=0; |
int target_importance=1; |
int target_importance=FSF_DEFAULT_IMPORTANCE; |
#define MAX_IMPORTANCE 5 |
#ifdef FSF_DEBUG |
int temp; |
608,14 → 754,14 |
&& server_list[i].U<server_list[i].Umax && server_list[i].Qs>0) |
Qt+=server_list[i].Qs; |
current_bandwidth+=server_list[i].U; |
#ifdef FSF_DEBUG |
#ifdef FSF_DEBUG |
kern_printf("(Qs %d, Qt %d, Is %d)", server_list[i].Qs, Qt,server_list[i].Is); |
#endif |
#endif |
} |
#ifdef FSF_DEBUG |
#ifdef FSF_DEBUG |
kern_printf("(Total Quality %d)", Qt); |
#endif |
#endif |
isok=1; |
for (i=0; i<current_server; i++) { |
if (server_list[i].Is==target_importance && server_list[i].U<server_list[i].Umax && server_list[i].Qs>0) { |
638,7 → 784,7 |
} |
} |
target_importance++; |
} while (!isok && target_importance<6); |
} while (!isok && target_importance<=MAX_IMPORTANCE); |
return 0; |
} |
664,6 → 810,29 |
return 0; |
} |
int fsf_request_contract_renegotiation |
(const fsf_contract_parameters_t *new_contract, |
fsf_server_id_t server, |
int sig_notify, |
union sigval sig_value) |
{ |
struct mess message; |
// send response server is -1 if the operation fail |
message.type=REQUEST_RENEGOTIATE_CONTRACT; |
memmove(&message.contract,new_contract, sizeof(fsf_contract_parameters_t)); |
message.server = server; |
port_send(channel[1],&message,BLOCK); |
port_receive(channel[0], &message, BLOCK); |
if (message.server==-1) return FSF_ERR_CONTRACT_REJECTED; |
return 0; |
} |
void print_server_list() |
{ |
684,3 → 853,49 |
return SERVER_get_remain_capacity(fsf_server_level, server); |
} |
int fsf_get_budget_and_period |
(fsf_server_id_t server, |
struct timespec *budget, |
struct timespec *period) { |
TIME bg; |
TIME pd; |
if (!SERVER_getbudgetinfo(fsf_server_level, &bg, &pd, NULL, server)) { |
if (budget) { |
NULL_TIMESPEC(budget); |
ADDUSEC2TIMESPEC(bg, budget); |
} |
if (period) { |
NULL_TIMESPEC(period); |
ADDUSEC2TIMESPEC(pd, period); |
} |
return 0; |
} |
return FSF_ERR_BAD_ARGUMENT; |
} |
int |
fsf_set_service_thread_data |
(const struct timespec *budget, |
const struct timespec *period, |
bool *accepted) { |
if (budget==NULL && period==NULL) return FSF_ERR_BAD_ARGUMENT; |
fsf_set_contract_basic_parameters(&service_contract,budget,period,FSF_DEFAULT_WORKLOAD); |
*accepted = !fsf_renegotiate_contract(&service_contract,service_server)?true:false; |
return 0; |
} |
int fsf_get_service_thread_data |
(struct timespec *budget, |
struct timespec *period) { |
return fsf_get_budget_and_period(service_server, budget, period); |
} |