Subversion Repositories shark

Compare Revisions

Ignore whitespace Rev 1231 → Rev 1232

/demos/trunk/loader/newloader.c
0,0 → 1,159
#include <kernel/kern.h>
 
#include "fsf_contract.h"
#include "fsf_server.h"
#include "event_header.h"
#include "func.h"
 
/* Calibration Loops */
#define CALIBRATION_DELTA 10000
 
/* Activate task output */
#define TASK_OUTPUT
 
int cal_cycles = 0;
struct timespec zero_time;
 
/* Soft and hard Task */
TASK test_task(void *arg)
{
long long i,exec_cycles = 0;
int crit_start,crit_len;
long long crit_start_cycles = 0, crit_len_cycles = 0;
struct timespec next_time;
int act = 0;
struct loader_task *l = loader_task_list[get_current_exec_task()];
char tmp[20];
 
 
while((l->act_num)>act) {
 
//task_testcancel();
 
act++;
 
#ifdef TASK_OUTPUT
sprintf(tmp,"X[%06d]",act);
printf_xy((get_current_exec_task() % 5) * 9 + 34,get_current_exec_task() / 5 + 5, GREEN, tmp);
#endif
 
generic_set_next_activationn(&l->act[act]);
 
exec_cycles = (long long)(TIMESPEC2USEC(l->exec[act])) * CALIBRATION_DELTA / cal_cycles;
#ifdef TASK_OUTPUT
sprintf(tmp,"X[%06d]",act);
printf_xy((get_current_exec_task() % 5) * 9 + 34, get_current_exec_task() / 5 + 5, GREEN, tmp);
#endif
for (i=0;i<exec_cycles;i++) calibration_func();
generic_task_endcycle();
}
return NULL;
}
 
 
/* Mutex create */
/*
void loader_mutex_create(struct loader_task *start_loader_task)
{
 
struct loader_task *current = start_loader_task;
int i,res = 0;
PI_mutexattr_t a;
int init_array[MAX_MUTEX];
 
PI_mutexattr_default(a);
 
for (i = 0;i < MAX_MUTEX;i++) init_array[i] = 0;
 
while (current != NULL) {
if (current->crit_type == PAR_CRIT) {
if (init_array[current->resource] == 0) {
mutex_init(&mux_table[current->resource],&a);
init_array[current->resource] = 1;
res++;
}
}
 
current = current->next;
 
}
 
cprintf("Created %d mutex\n",res);
 
}
*/
 
/* Task create */
void loader_task_create(struct loader_task *start_loader_task)
{
 
struct loader_task *current = &loader_task_list[0];
char tmp[30];
int i=0,k=0, total_task;
int total_group = 0;
PID p;
 
total_task = sizeof(loader_task_list)/sizeof(loader_task);
 
while (k<total_task) {
k++;
total_group++;
current->group = total_group;
 
for (i=0; i < current->number; i++) {
pthread_t j;
int err;
err = generic_create_thread(current->server,&j,NULL,test_task,(void *)current,generic_get_task_model(current));
if (err) {
cprintf("Error fsf task creating\n");
sys_end();
}
}
current = &loader_task_list[i];
 
}
 
 
}
 
cprintf("Created %d tasks\n",total_task);
}
 
 
void generic_fsfinit(void);
 
int main()
{
 
struct loader_task *start_loader_task = &loader_task_list[0];
struct timespec total;
 
generic_calibrate_cycle();
 
generic_fsfinit();
 
//loader_mutex_create(start_loader_task);
loader_task_create(start_loader_task);
 
generic_set_simulation_time(total);
 
 
return 0;
 
}
/demos/trunk/loader/func.h
0,0 → 1,11
#define SHARK
#if defined SHARK
#define get_current_exec_task() exec_shadow
#define generic_calibration_func calibration_func
#define generic_create_thread fsf_create_thread
#define generic_calibrate_cycle calibrate_cycle
#define generic_set_next_activation set_next_activation
#define generic_set_simulation_time set_simulation_time
#define generic_get_task_model get_task_model
#endif
 
/demos/trunk/loader/shark.c
0,0 → 1,76
#include <func.h>
 
/* Delay Calibration */
int calibrate_cycle()
{
long long i;
struct timespec start,end,diff;
 
kern_cli();
kern_gettime(&start);
for (i=0;i<CALIBRATION_DELTA;i++) kern_gettime(NULL);
kern_gettime(&end);
kern_sti();
 
SUBTIMESPEC(&end,&start,&diff);
cal_cycles = TIMESPEC2USEC(&diff);
cprintf("Calibration usec/[%d cycles] = %d\n",CALIBRATION_DELTA,cal_cycles);
 
return 0;
 
}
 
void *get_task_model(task_loader *current) {
if (current->local_scheduler == LOADER_POSIX_SCHEDULER) {
static NRT_TASK_MODEL nrt;
nrt_task_default_model(nrt);
nrt_task_def_save_arrivals(nrt);
nrt_task_def_ctrl_jet(nrt);
nrt_task_def_usemath(nrt);
return &nrt;
 
}
 
if (current->local_scheduler == LOADER_EDF_SCHEDULER) {
static HARD_TASK_MODEL ht;
 
hard_task_default_model(ht);
hard_task_def_ctrl_jet(ht);
hard_task_def_mit(ht,TIMESPEC2USEC(&current->deadline));
hard_task_def_wcet(ht,TIMESPEC2USEC(&current->wcet));
hard_task_def_usemath(ht);
return &ht;
}
 
 
if (current->local_scheduler == LOADER_RM_SCHEDULER) {
static HARD_TASK_MODEL ht;
hard_task_default_model(ht);
hard_task_def_mit(ht,TIMESPEC2USEC(&current->deadline));
hard_task_def_wcet(ht,TIMESPEC2USEC(&current->wcet));
hard_task_def_ctrl_jet(ht);
hard_task_def_usemath(ht);
return &ht;
}
}
 
void set_simulation_time (struct timespec *total) {
struct timespec end_time;
kern_gettime(&zero_time);
 
loader_first_execution(start_loader_task);
ADDTIMESPEC(&zero_time,total,&end_time);
kern_event_post(&end_time,(void *)((void *)(sys_end)),NULL);
 
}
 
void set_next_activation(struct timespec *next) {
struct timespec end_time;
ADDTIMESPEC(&zero_time,next,&end_time);
kern_event_post(&end_time,(void *)((void *)(task_activate(exec_shadow))),NULL);
}
/demos/trunk/loader/event_gen.c
293,7 → 293,7
tot_time_usec = first_time_usec;
for (i=0;i<act_number-1;i++) {
tot_time_usec += mean_time_usec + random() % delta_time_usec - delta_time_usec/2;
fprintf(file_act_header," {%d,%d},\n",
fprintf(file_act_header," {%d,%d},\n",
(int)tot_time_usec/1000000,(int)tot_time_usec%1000000*1000);
}