Subversion Repositories shark

Compare Revisions

Ignore whitespace Rev 1202 → Rev 1203

/demos/trunk/loader/dosread.c
48,11 → 48,18
}
pbuf += i+1;
line_buf[i] = 0;
res = line_parser(line_buf, line_num, total, &current);
 
if (*start_loader_task == NULL)
res = line_parser(line_buf, line_num, total, &current);
else
res = line_parser(line_buf, line_num, total, &current->next);
 
if (res == 2) {
total_loader_task++;
if (*start_loader_task == NULL) *start_loader_task = current;
current = current->next;
if (*start_loader_task == NULL)
*start_loader_task = current;
else
current = current->next;
}
}
 
/demos/trunk/loader/parser.h
10,19 → 10,20
#define PAR_EXEC_TYPE 5
#define PAR_TASK_TYPE 6
#define PAR_NOTHING 8
#define PAR_DEADLINE 9
#define PAR_ERROR 10
#define PAR_FOUND 11
 
#define PAR_EXEC_CONST 12
#define PAR_EXEC_MEAN 13
#define PAR_EXEC_EXP 14
#define PAR_EXEC_EXP_MAX 15
#define PAR_EXEC_GAUSS 14
#define PAR_EXEC_GAUSS_MAX 15
 
#define PAR_ACT_SINGLE 16
#define PAR_ACT_PERIODIC 17
#define PAR_ACT_MEAN 18
#define PAR_ACT_EXP 19
#define PAR_ACT_EXP_MAX 20
#define PAR_ACT_GAUSS 19
#define PAR_ACT_GAUSS_MAX 20
 
#define PAR_TASK_NRT 21
#define PAR_TASK_HARD 22
31,8 → 32,10
struct loader_task {
int number;
int group;
bandwidth_t bandwidth;
int task_level;
int task_type;
struct timespec deadline;
struct timespec wcet;
int exec_type;
struct timespec exec_par_1;
/demos/trunk/loader/loader.c
2,49 → 2,216
#include "parser.h"
#include "dosread.h"
 
/* Memory pointers on loaded file */
extern void *start;
extern void *end;
 
/* Calibration Loops */
#define CALIBRATION_DELTA 1000000
 
/* Activate task output */
#define TASK_OUTPUT
 
struct timespec zero_time;
int cal_cycles = 0;
int cal_rit_start = 0;
int cal_rit_calc_const = 0;
int cal_rit_calc_mean = 0;
int cal_rit_calc_gauss = 0;
 
/* Not Real-Time Task */
TASK nrt_test_task(void *arg)
{
int i;
long long i,exec_cycles = 0;
int exec_1,exec_2,exec_3;
int act_1,act_2,act_3,next_act;
struct timespec next_time;
static int act= 0;
struct loader_task *l = (struct loader_task *)(arg);
act++;
#ifdef TASK_OUTPUT
cprintf("(Act %d Pid %d Grp %d Lev %d)",act,exec_shadow,l->group,l->task_level);
#endif
 
cprintf("(Act %d)",exec_shadow);
act_1 = TIMESPEC2USEC(&l->act_par_2);
act_2 = TIMESPEC2USEC(&l->act_par_3);
act_3 = TIMESPEC2USEC(&l->act_par_4);
 
while(1) {
if (l->act_type == PAR_ACT_PERIODIC) {
kern_gettime(&next_time);
ADDUSEC2TIMESPEC(act_1,&next_time);
kern_event_post(&next_time,(void *)((void *)task_activate),(void *)exec_shadow);
}
 
for (i=0;i<100000;i++);
if (l->act_type == PAR_ACT_MEAN) {
next_act = act_1 + rand() % act_2 - act_2/2;
kern_gettime(&next_time);
ADDUSEC2TIMESPEC(next_act,&next_time);
kern_event_post(&next_time,(void *)((void *)task_activate),(void *)exec_shadow);
}
 
if (l->act_type == PAR_ACT_GAUSS) {
}
 
if (l->act_type == PAR_ACT_GAUSS_MAX) {
}
exec_1 = TIMESPEC2USEC(&l->exec_par_1);
exec_2 = TIMESPEC2USEC(&l->exec_par_2);
exec_3 = TIMESPEC2USEC(&l->exec_par_3);
if (l->exec_type == PAR_EXEC_CONST)
exec_cycles = (long long)(exec_1 - cal_rit_start - cal_rit_calc_const)
* CALIBRATION_DELTA / cal_cycles;
if (l->exec_type == PAR_EXEC_MEAN)
exec_cycles = (long long)(exec_1 - cal_rit_start - cal_rit_calc_mean
+ rand() % exec_2 - exec_2/2) * CALIBRATION_DELTA / cal_cycles;
if (l->exec_type == PAR_EXEC_GAUSS)
exec_cycles = 0;
 
if (l->exec_type == PAR_EXEC_GAUSS_MAX)
exec_cycles = 0;
 
for (i=0;i<exec_cycles;i++);
return NULL;
 
}
 
/* Soft and hard Task */
TASK test_task(void *arg)
{
int i;
long long i,exec_cycles = 0;
int exec_1,exec_2,exec_3;
int act_1,act_2,act_3,next_act;
struct timespec next_time;
static int act=0;
int extra_rit;
struct loader_task *l = (struct loader_task *)(arg);
act++;
#ifdef TASK_OUTPUT
cprintf("(Act %d Pid %d Grp %d Lev %d)",act,exec_shadow,l->group,l->task_level);
#endif
 
cprintf("(Act %d)",exec_shadow);
act_1 = TIMESPEC2USEC(&l->act_par_2);
act_2 = TIMESPEC2USEC(&l->act_par_3);
act_3 = TIMESPEC2USEC(&l->act_par_4);
exec_1 = TIMESPEC2USEC(&l->exec_par_1);
exec_2 = TIMESPEC2USEC(&l->exec_par_2);
exec_3 = TIMESPEC2USEC(&l->exec_par_3);
 
extra_rit = cal_rit_start;
while(1) {
 
for (i=0;i<100000;i++);
task_testcancel();
 
if (l->act_type == PAR_ACT_MEAN) {
next_act = act_1 + rand() % act_2 - act_2/2;
kern_gettime(&next_time);
ADDUSEC2TIMESPEC(next_act,&next_time);
kern_event_post(&next_time,(void *)((void *)task_activate),(void *)exec_shadow);
}
 
if (l->act_type == PAR_ACT_GAUSS) {
}
 
if (l->act_type == PAR_ACT_GAUSS_MAX) {
}
 
if (l->exec_type == PAR_EXEC_CONST)
exec_cycles = (long long)(exec_1 - extra_rit - cal_rit_calc_const)
* CALIBRATION_DELTA / cal_cycles;
if (l->exec_type == PAR_EXEC_MEAN)
exec_cycles = (long long)(exec_1 - extra_rit - cal_rit_calc_mean
+ rand() % exec_2 - exec_2/2) * CALIBRATION_DELTA / cal_cycles;
if (l->exec_type == PAR_EXEC_GAUSS)
exec_cycles = 0;
 
if (l->exec_type == PAR_EXEC_GAUSS_MAX)
exec_cycles = 0;
extra_rit = 0;
 
for (i=0;i<exec_cycles;i++);
task_endcycle();
 
}
 
return NULL;
}
 
/* Delay Calibration */
int calibrate_cycle()
{
long long i;
struct timespec start,end,diff;
int temp = 1234567;
int temp_1 = 1234567;
int temp_2 = 1234567;
 
kern_cli();
kern_gettime(&start);
for (i=0;i<CALIBRATION_DELTA;i++);
kern_gettime(&end);
kern_sti();
 
SUBTIMESPEC(&end,&start,&diff);
cal_cycles = TIMESPEC2USEC(&diff);
 
cprintf("Calibration usec/[%d cycles] = %d\n",CALIBRATION_DELTA,cal_cycles);
 
kern_cli();
kern_gettime(&start);
temp = (long long)(temp_1) * CALIBRATION_DELTA / cal_cycles;
kern_gettime(&end);
kern_sti();
SUBTIMESPEC(&end,&start,&diff);
cal_rit_calc_const = TIMESPEC2USEC(&diff);
 
kern_cli();
kern_gettime(&start);
temp = (long long)(temp_1 + rand() % temp_2 - temp_2/2) * CALIBRATION_DELTA / cal_cycles;
kern_gettime(&end);
kern_sti();
SUBTIMESPEC(&end,&start,&diff);
cal_rit_calc_mean = TIMESPEC2USEC(&diff);
 
kern_cli();
kern_gettime(&start);
temp = TIMESPEC2USEC(&start);
kern_gettime(&end);
kern_sti();
SUBTIMESPEC(&end,&start,&diff);
cal_rit_start = TIMESPEC2USEC(&diff) * 6 + cal_rit_calc_const;
cprintf("Calibration delay start = %d const = %d mean = %d gauss = %d\n",
cal_rit_start,cal_rit_calc_const,cal_rit_calc_mean,cal_rit_calc_gauss);
 
return 0;
 
}
 
/* Task create */
void loader_task_create(struct loader_task *start_loader_task)
{
 
struct loader_task *current = start_loader_task;
char tmp[30];
int i, total_task;
int total_group = 0;
PID p;
55,6 → 222,7
 
total_group++;
current->group = total_group;
current->bandwidth = 0;
 
for (i=0; i < current->number; i++) {
 
68,7 → 236,8
nrt_task_def_level(nrt,current->task_level);
nrt_task_def_group(nrt,total_group);
 
p = task_create("NRT",nrt_test_task,&nrt,NULL);
sprintf(tmp,"NRT %d:%d",current->group,i);
p = task_create(tmp,nrt_test_task,&nrt,NULL);
if (p == NIL) {
cprintf("Error nrt task creating\n");
sys_end();
88,17 → 257,19
hard_task_def_level(ht,current->task_level);
hard_task_def_group(ht,total_group);
 
if (current->act_type == PAR_ACT_PERIODIC) {
hard_task_def_mit(ht,TIMESPEC2USEC(&current->act_par_2));
} else if (current->act_type != PAR_ACT_SINGLE) {
hard_task_def_mit(ht,TIMESPEC2USEC(&current->act_par_2));
if (current->act_type != PAR_ACT_PERIODIC) {
hard_task_def_mit(ht,TIMESPEC2USEC(&current->deadline));
current->bandwidth += MAX_BANDWIDTH / TIMESPEC2USEC(&current->deadline)
* TIMESPEC2USEC(&current->wcet);
hard_task_def_aperiodic(ht);
} else {
hard_task_def_mit(ht,TIMESPEC2USEC(&current->wcet)*100);
hard_task_def_aperiodic(ht);
hard_task_def_mit(ht,TIMESPEC2USEC(&current->act_par_2));
current->bandwidth += MAX_BANDWIDTH / TIMESPEC2USEC(&current->act_par_2)
* TIMESPEC2USEC(&current->wcet);
}
p = task_create("HARD",test_task,&ht,NULL);
sprintf(tmp,"HARD %d:%d",current->group,i);
p = task_create(tmp,test_task,&ht,NULL);
if (p == NIL) {
cprintf("Error hard task creating\n");
sys_end();
121,15 → 292,21
 
if (current->act_type == PAR_ACT_PERIODIC) {
soft_task_def_period(st,TIMESPEC2USEC(&current->act_par_2));
current->bandwidth += MAX_BANDWIDTH / TIMESPEC2USEC(&current->act_par_2)
* TIMESPEC2USEC(&current->wcet);
} else if (current->act_type != PAR_ACT_SINGLE) {
soft_task_def_period(st,TIMESPEC2USEC(&current->act_par_2));
current->bandwidth += MAX_BANDWIDTH / TIMESPEC2USEC(&current->act_par_2)
* TIMESPEC2USEC(&current->wcet);
soft_task_def_aperiodic(st);
} else {
soft_task_def_period(st,TIMESPEC2USEC(&current->wcet)*100);
soft_task_def_period(st,TIMESPEC2USEC(&current->wcet)*1000);
current->bandwidth += MAX_BANDWIDTH / 1000;
soft_task_def_aperiodic(st);
}
p = task_create("SOFT",test_task,&st,NULL);
sprintf(tmp,"SOFT %d:%d",current->group,i);
p = task_create(tmp,test_task,&st,NULL);
if (p == NIL) {
cprintf("Error soft task creating\n");
sys_end();
141,6 → 318,10
 
}
 
cprintf("Task group %d created. Worst case BW = %d.%d \n",
current->group,(int)( (long long)current->bandwidth * 100 / MAX_BANDWIDTH),
(int)( (long long)current->bandwidth* 100000 / MAX_BANDWIDTH % 1000));
 
current = current->next;
 
}
149,6 → 330,7
}
 
/* Set the first extivation events */
void loader_first_execution(struct loader_task *start_loader_task)
{
 
176,6 → 358,10
 
line_reader(start, end, &total, &start_loader_task);
 
srand(kern_gettime(NULL));
 
calibrate_cycle();
 
loader_task_create(start_loader_task);
kern_gettime(&zero_time);
/demos/trunk/loader/loadfile.txt
1,4 → 1,4
# TASK TYPE:TASK LEVEL:NUMBER OF:TASK ACTIVATION TYPE (PAR0,PAR1,...):WCET:TASK EXEC TYPE;
# TASK TYPE:TASK LEVEL:NUMBER OF:TASK ACT TYPE (PAR0,PAR1,...):DEADLINE:WCET:TASK EXEC TYPE;
#
# TASK TYPE
# NRT - NON REAL TIME
6,18 → 6,24
# SOFT - SOFT REAL TIME
#
# TASK EXEC TYPE
# EXEC_CONST(TIME) - CONSTANT EXEC TIME
# EXEC_MEAN(MEAN, DELTA) - VARIABLE EXEC TIME WITH CONSTANT DISTRIBUTION
# EXEC_EXP(MEAN, SIGMA) - VARIABLE EXEC TIME WITH EXP DISTRIBUTION
# EXEC_EXP_MAX(MEAN, SIGMA, MAX) - VARIABLE EXEC TIME WITH EXP DISTRIBUTION MAXIMIZED
# EXEC_CONST(TIME)
# - CONSTANT EXEC TIME
# EXEC_MEAN(MEAN, DELTA)
# - VARIABLE EXEC TIME WITH CONSTANT DISTRIBUTION
# EXEC_GAUSS(MEAN, SIGMA)
# - VARIABLE EXEC TIME WITH GAUSSIAN DISTRIBUTION
# EXEC_GAUSS_MAX(MEAN, SIGMA, MAX)
# - VARIABLE EXEC TIME WITH GAUSSIAN DISTRIBUTION MAXIMIZED
#
# TASK ACTIVATION TIME
# ACT_SINGLE(START_TIME)
# ACT_PERIODIC(START_TIME, PERIOD)
# ACT_MEAN(START_TIME, MEAN, DELTA)
# ACT_EXP(START_TIME, MEAN, SIGMA)
# ACT_EXP_MAX(START_TIME, MEAN, SIGMA, MAX)
# ACT_GAUSS(START_TIME, MEAN, SIGMA)
# ACT_GAUSS_MAX(START_TIME, MEAN, SIGMA, MAX)
 
TOTAL_EXEC_TIME:[10][0];
HARD:[0]:[1]:ACT_PERIODIC([0][0],[1][0]):[0][10000]:EXEC_CONST([0][1000]);
TOTAL_EXEC_TIME:[200][0];
HARD:[0]:[1]:ACT_MEAN([3][0],[1][0],[0][100000]):[0][900000]:[0][10000]:EXEC_MEAN([0][5000],[0][1000]);
HARD:[0]:[10]:ACT_PERIODIC([1][0],[0][300000]):[0][100000]:[0][5000]:EXEC_CONST([0][1000]);
SOFT:[1]:[10]:ACT_PERIODIC([2][0],[0][200000]):[0][200000]:[0][5000]:EXEC_CONST([0][2000]);
 
/demos/trunk/loader/parser.c
4,7 → 4,7
#include <stdio.h>
#include "parser.h"
 
#define PARSER_DEBUG
//#define PARSER_DEBUG
 
static int find_break(char **buf, int find_type, struct timespec *time, int *val)
{
109,14 → 109,14
*val = PAR_ACT_MEAN;
return PAR_FOUND;
}
if (!strncmp(*buf,"ACT_EXP(",8)) {
*buf += 8;
*val = PAR_ACT_EXP;
if (!strncmp(*buf,"ACT_GAUSS(",10)) {
*buf += 10;
*val = PAR_ACT_GAUSS;
return PAR_FOUND;;
}
if (!strncmp(*buf,"ACT_EXP_MAX(",12)) {
*buf += 12;
*val = PAR_ACT_EXP_MAX;
if (!strncmp(*buf,"ACT_GAUSS_MAX(",14)) {
*buf += 14;
*val = PAR_ACT_GAUSS_MAX;
return PAR_FOUND;
}
return PAR_ERROR;
133,14 → 133,14
*val = PAR_EXEC_MEAN;
return PAR_FOUND;
}
if (!strncmp(*buf,"EXEC_EXP(",9)) {
*buf += 9;
*val = PAR_EXEC_EXP;
if (!strncmp(*buf,"EXEC_GAUSS(",11)) {
*buf += 11;
*val = PAR_EXEC_GAUSS;
return PAR_FOUND;
}
if (!strncmp(*buf,"EXEC_EXP_MAX(",13)) {
*buf += 13;
*val = PAR_EXEC_EXP_MAX;
if (!strncmp(*buf,"EXEC_GAUSS_MAX(",15)) {
*buf += 15;
*val = PAR_EXEC_GAUSS_MAX;
return PAR_FOUND;
}
return PAR_ERROR;
261,7 → 261,7
}
 
if (ld->act_type != PAR_ACT_SINGLE && ld->act_type != PAR_ACT_PERIODIC &&
ld->act_type != PAR_ACT_MEAN && ld->act_type != PAR_ACT_EXP) {
ld->act_type != PAR_ACT_MEAN && ld->act_type != PAR_ACT_GAUSS) {
res = find_break(&pbuf,PAR_TIME, &time, &val);
if (res == PAR_FOUND) {
#ifdef PARSER_DEBUG
280,6 → 280,14
res = find_break(&pbuf,PAR_TIME, &time, &val);
if (res == PAR_FOUND) {
#ifdef PARSER_DEBUG
cprintf("DEADLINE: [%ld][%ld]\n",time.tv_sec,time.tv_nsec/1000);
#endif
TIMESPEC_ASSIGN(&ld->deadline,&time);
} else par_error(line_num);
 
res = find_break(&pbuf,PAR_TIME, &time, &val);
if (res == PAR_FOUND) {
#ifdef PARSER_DEBUG
cprintf("WCET: [%ld][%ld]\n",time.tv_sec,time.tv_nsec/1000);
#endif
TIMESPEC_ASSIGN(&ld->wcet,&time);
310,7 → 318,7
}
if (ld->exec_type != PAR_EXEC_CONST && ld->exec_type != PAR_EXEC_MEAN &&
ld->exec_type != PAR_EXEC_EXP) {
ld->exec_type != PAR_EXEC_GAUSS) {
res = find_break(&pbuf,PAR_TIME, &time, &val);
if (res == PAR_FOUND) {
#ifdef PARSER_DEBUG