Subversion Repositories shark

Compare Revisions

Ignore whitespace Rev 867 → Rev 868

/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);
 
}