Subversion Repositories shark

Compare Revisions

Ignore whitespace Rev 1538 → Rev 1537

/demos/trunk/loader/shark/fsfinit.c
1,10 → 1,6
#include "kernel/kern.h"
#include "fsf_basic_types.h"
#include "fsf_core.h"
#include "fsf_hierarchical.h"
#include "fsf_spare_capacity.h"
#include "fsf_contract.h"
#include "fsf_server.h"
 
#include "func.h"
 
extern struct loader_contract loader_contract_list[];
18,9 → 14,14
fsf_server_id_t server;
union sigval no_sigval = {0};
int i;
SOFT_TASK_MODEL m;
 
FSF_start_service_task();
soft_task_default_model(m);
soft_task_def_period(m,50000);
soft_task_def_met(m,1000);
 
FSF_start_service_task(&m);
 
for (i=0;i<total_loader_contract;i++) {
 
c = &loader_contract_list[i];
27,25 → 28,24
 
fsf_initialize_contract(&contract);
 
fsf_set_contract_basic_parameters(&contract,&c->cmin,&c->tmax,c->workload);
fsf_set_contract_reclamation_parameters(&contract,&c->cmax,&c->tmin,FSF_DEFAULT_GRANULARITY, NULL, 1,1);
fsf_set_contract_basic_parameters(&contract,&c->cmin,&c->tmax,&c->cmax,&c->tmin,c->workload);
fsf_set_contract_reclamation_parameters(&contract,FSF_DEFAULT_GRANULARITY, NULL, 1,1);
 
if (TIMESPEC2USEC(&c->deadline) != 0)
fsf_set_contract_timing_requirements(&contract,FALSE,&c->deadline,0,no_sigval,0,no_sigval);
 
switch (c->local_scheduler) {
case PAR_EDF:
fsf_set_contract_scheduling_policy(&contract,FSF_EDF);
break;
case PAR_RM:
fsf_set_contract_scheduling_policy(&contract,FSF_RM);
break;
case PAR_POSIX:
fsf_set_contract_scheduling_policy(&contract,FSF_POSIX);
break;
if (c->local_scheduler != PAR_POSIX) {
switch (c->local_scheduler) {
case PAR_EDF:
fsf_set_local_scheduler_parameter(&contract,FSF_SCHEDULER_EDF);
break;
case PAR_RM:
fsf_set_local_scheduler_parameter(&contract,FSF_SCHEDULER_RM);
break;
}
 
}
 
fsf_negotiate_contract(&contract,&server);
c->server = server;
/demos/trunk/loader/shark/shark.c
12,7 → 12,7
extern int total_loader_task;
extern int total_loader_contract;
 
mutex_t mutex_table[MAX_MUTEX];
mutex_object mutex_table[MAX_MUTEX];
int main_chunk;
 
/* Runtime Calibration */
166,17 → 166,18
 
}
 
extern unsigned int clk_per_msec;
 
/* Set the zero_time and post the first activation event */
void start_simulation() {
int i;
int i, object;
struct loader_task *l = loader_task_list;
struct timespec end_time;
PI_mutexattr_t a;
int res;
 
PI_mutexattr_default(a);
 
i = 0;
object = 0;
 
#ifdef __NEW_TRACER__
 
188,14 → 189,26
 
#endif
 
TRACER_LOGEVENT(FTrace_EVT_trace_start,0,0);
TRACER_LOGEVENT(FTrace_EVT_trace_start,proc_table[exec_shadow].context,clk_per_msec);
for (i=0;i<10;i++)
if (proc_table[i].context != 0) TRACER_LOGEVENT(FTrace_EVT_id,
(unsigned short int)proc_table[i].context,i);
 
kern_gettime(&zero_time);
i = 0;
while (i < total_loader_task) {
if (l->muxstatus == 1) {
mutex_init(&mutex_table[l->resource],&a);
res = fsf_init_shared_object(&(mutex_table[l->resource]).object,l->resource);
if (res != -1) {
mutex_table[l->resource].operation.op_id=1;
mutex_table[l->resource].operation.wcet.tv_sec=l->block[0].tv_sec;
mutex_table[l->resource].operation.wcet.tv_nsec=l->block[0].tv_nsec;
fsf_declare_shared_object_operation(&mutex_table[l->resource].object,
&mutex_table[l->resource].operation);
}
l->muxstatus = 2;
}
 
/demos/trunk/loader/shark/func.h
2,14 → 2,18
#define __FUNC_H__
 
#include "kernel/kern.h"
#include "fsf_basic_types.h"
#include "fsf_core.h"
#include "fsf_contract.h"
#include "fsf_server.h"
#include "shark.h"
 
#define OS_SHARK
 
typedef struct {
fsf_shared_object_t object;
fsf_shared_operation_t operation;
} mutex_object;
 
 
#define get_current_exec_task() exec_shadow
/* Return the PID/pthread_t of calling task */
 
88,15 → 92,15
 
/* Mutex */
extern __inline__ void generic_lock_mutex(int res) {
extern mutex_t mutex_table[MAX_MUTEX];
extern mutex_object mutex_table[MAX_MUTEX];
 
mutex_lock(&mutex_table[res]);
fsf_lock_object(&mutex_table[res].operation);
}
 
extern __inline__ void generic_unlock_mutex(int res) {
extern mutex_t mutex_table[MAX_MUTEX];
extern mutex_object mutex_table[MAX_MUTEX];
mutex_unlock(&mutex_table[res]);
fsf_unlock_object(&mutex_table[res].operation);
}
 
/* TASK RUNTIME FUNCTIONS */
/demos/trunk/loader/shark/initfile.c
40,8 → 40,7
 
#include "modules/posix.h"
#include "grubstar.h"
#include "fsf_basic_types.h"
#include "fsf_core.h"
#include "fsf_contract.h"
 
#include "modules/pi.h"
#include "modules/pc.h"
78,14 → 77,13
{
struct multiboot_info *mb = (struct multiboot_info *)arg;
int grubstar_level;
int posix_level;
 
INTDRIVE_register_level(INTDRIVE_Q, INTDRIVE_T, INTDRIVE_FLAG);
EDF_register_level(EDF_ENABLE_ALL);
posix_level=POSIX_register_level(RRTICK, 1, mb, 32);
POSIX_register_level(RRTICK, 1, mb, 32);
grubstar_level = GRUBSTAR_register_level(FSF_MAX_N_SERVERS, 1);
 
FSF_register_module(posix_level,grubstar_level, (int)(MAX_BANDWIDTH * 0.8));
FSF_register_module(grubstar_level, (int)(MAX_BANDWIDTH * 0.8));
dummy_register_level();
CBS_register_level(CBS_ENABLE_ALL,1);
/demos/trunk/loader/common/nload.c
9,9 → 9,7
*
*/
 
#include "fsf_basic_types.h"
#include "fsf_core.h" //Framework main header
 
#include "fsf_contract.h" //Framework main header
#include "calibrate.h"
#include "func.h" //Generic function definitions
#include "lconst.h"