Subversion Repositories shark

Compare Revisions

Ignore whitespace Rev 1207 → Rev 1208

/demos/trunk/loader/dosread.c
2,7 → 2,7
#include <stdlib.h>
#include "parser.h"
 
int dos_preload(char *file_name, long max_size, void **start, void **end)
int dos_preload(char *file_name, long max_size, void **start_file, void **end_file)
{
DOS_FILE* file;
void *buf;
13,14 → 13,14
if (file == NULL) return -1;
buf = malloc(max_size);
*start = buf;
*start_file = buf;
while(((rd = DOS_fread(buf, sizeof(BYTE), 2048, file)) == 2048) &&
((buf - *start + rd) < (max_size-2048))) {
((buf - *start_file + rd) < (max_size-2048))) {
buf += rd;
}
*end = buf + rd;
*end_file = buf + rd;
DOS_fclose(file);
return(0);
27,10 → 27,10
}
 
int line_reader(void *start, void *end, struct timespec *total, struct loader_task **start_loader_task)
int line_reader(void *start_file, void *end_file, struct timespec *total, struct loader_task **start_loader_task)
{
char *pbuf = start;
char *pbuf = start_file;
int res,line_num,total_loader_task;
struct loader_task *current = NULL;
 
38,7 → 38,7
 
line_num = 0;
total_loader_task = 0;
while ((void *)(pbuf) < end) {
while ((void *)(pbuf) < end_file) {
line_num++;
 
/demos/trunk/loader/initfile.c
55,8 → 55,8
/*+ RR tick in us +*/
#define RRTICK 10000
 
void *start;
void *end;
void *start_file = NULL;
void *end_file = NULL;
 
TIME __kernel_register_levels__(void *arg)
{
71,11 → 71,11
 
CABS_register_module();
 
dos_preload("loadfile.txt",100000,&start,&end);
dos_preload("loadfile.txt",100000,&start_file,&end_file);
 
cprintf("Start file ptr = %08lx\n",(long)(start));
cprintf("End file ptr = %08lx\n",(long)(end));
cprintf("Size = %8ld\n",(long)(end - start));
cprintf("Start file ptr = %08lx\n",(long)(start_file));
cprintf("End file ptr = %08lx\n",(long)(end_file));
cprintf("Size = %8ld\n",(long)(end_file - start_file));
 
return TICK;
}
/demos/trunk/loader/loader.c
3,8 → 3,8
#include "dosread.h"
 
/* Memory pointers on loaded file */
extern void *start;
extern void *end;
extern void *start_file;
extern void *end_file;
 
/* Calibration Loops */
#define CALIBRATION_DELTA 100000
237,6 → 237,114
}
 
/* Background Task */
TASK back_task(void *arg)
{
long long i,exec_cycles = 0;
int exec_1,exec_2,exec_3;
int act_1,act_2,act_3,next_act;
int crit_1 = 0,crit_2 = 0,crit_3 = 0,crit_4 = 0;
int crit_start,crit_len;
long long crit_start_cycles = 0, crit_len_cycles = 0;
struct timespec next_time;
static int act=0;
int extra_rit, k;
struct loader_task *l = (struct loader_task *)(arg);
act++;
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;
 
if (l->crit_type == PAR_CRIT) {
crit_1 = TIMESPEC2USEC(&l->crit_par_1);
crit_2 = TIMESPEC2USEC(&l->crit_par_2);
crit_3 = TIMESPEC2USEC(&l->crit_par_3);
crit_4 = TIMESPEC2USEC(&l->crit_par_4);
}
 
k = 0;
while(1) {
 
task_testcancel();
 
#ifdef TASK_OUTPUT
k++;
if (k > 15) k = 1;
printf_xy(exec_shadow % 20 + 59, exec_shadow / 20, k,"X");
#endif
 
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;
if (l->crit_type == PAR_CRIT) {
crit_start = crit_1 + rand() % crit_2 - crit_2/2;
crit_len = crit_3 + rand() % crit_4 - crit_4/2;
crit_start_cycles = (long long)(crit_start) * CALIBRATION_DELTA / cal_cycles;
crit_len_cycles = (long long)(crit_len) * CALIBRATION_DELTA / cal_cycles;
exec_cycles -= crit_start_cycles + crit_len_cycles;
if (exec_cycles < 0) {
cprintf("Error: exec_cycles < 0\n");
sys_end();
}
}
extra_rit = 0;
 
if (l->crit_type == PAR_NO_CRIT)
for (i=0;i<exec_cycles;i++) kern_gettime(NULL);
else {
for (i=0;i<crit_start_cycles;i++) kern_gettime(NULL);
#ifdef TASK_OUTPUT
printf_xy(exec_shadow % 20 + 59, exec_shadow / 20, k,"B");
#endif
mutex_lock(&mux_table[l->resource]);
for (i=0;i<crit_len_cycles;i++) kern_gettime(NULL);
mutex_unlock(&mux_table[l->resource]);
#ifdef TASK_OUTPUT
printf_xy(exec_shadow % 20 + 59, exec_shadow / 20, k,"X");
#endif
for (i=0;i<exec_cycles;i++) kern_gettime(NULL);
}
}
return NULL;
}
 
/* Delay Calibration */
int calibrate_cycle()
{
357,6 → 465,27
 
}
 
if (current->task_type == PAR_TASK_BACK) {
NRT_TASK_MODEL nrt;
nrt_task_default_model(nrt);
nrt_task_def_save_arrivals(nrt);
nrt_task_def_arg(nrt,(void *)(current));
nrt_task_def_ctrl_jet(nrt);
nrt_task_def_level(nrt,current->task_level);
nrt_task_def_group(nrt,total_group);
 
sprintf(tmp,"BACK %d:%d",current->group,i);
p = task_create(tmp,back_task,&nrt,NULL);
if (p == NIL) {
cprintf("Error back task creating\n");
sys_end();
}
 
total_task++;
 
}
 
if (current->task_type == PAR_TASK_HARD) {
HARD_TASK_MODEL ht;
466,7 → 595,7
struct timespec total;
struct timespec end_time;
 
line_reader(start, end, &total, &start_loader_task);
line_reader(start_file, end_file, &total, &start_loader_task);
 
srand(kern_gettime(NULL));
 
/demos/trunk/loader/loadfile.txt
1,5 → 1,5
# TASK TYPE:TASK LEVEL:NUMBER OF:TASK ACT TYPE (PAR0,PAR1,...)
# :DEADLINE:WCET:TASK EXEC TYPE:CRIT_START (PAR0,PAR1,PAR2):CRIT_LEN (PAR0,PAR1,PAR2);
# TASK TYPE:TASK LEVEL:NUMBER OF:TASK ACT TYPE (PAR1,PAR2,...):DEADLINE:WCET
# :TASK EXEC TYPE (PAR1,PAR2,...):CRITICAL SESSION (PAR1,PAR2,PAR3,PAR4);
#
# TASK TYPE
# NRT - NON REAL TIME
29,11 → 29,13
# NO_CRIT
#
 
TOTAL_EXEC_TIME:[200][0];
TOTAL_EXEC_TIME:[20][0];
HARD:[0]:[10]:ACT_MEAN([3][0],[1][0],[0][100000]):[0][900000]:[0][10000]
:EXEC_MEAN([0][5000],[0][1000]):NO_CRIT;
HARD:[0]:[10]:ACT_PERIODIC([1][0],[0][300000]):[0][100000]:[0][5000]
:EXEC_CONST([0][1000]):NO_CRIT;
SOFT:[1]:[10]:ACT_PERIODIC([2][0],[0][200000]):[0][200000]:[0][5000]
:EXEC_CONST([0][2000]):NO_CRIT;
 
:EXEC_CONST([0][4000]):CRIT([0],[0][0],[0][1000],[0][2000],[0][1]);
BACK:[2]:[1]:ACT_SINGLE([3][0]):[0][0]:[0][0]
:EXEC_CONST([0][1000]):NO_CRIT;
END
/demos/trunk/loader/parser.c
88,6 → 88,11
*buf += 5;
return PAR_FOUND;
}
if (!strncmp(*buf, "BACK:",5)) {
*val = PAR_TASK_BACK;
*buf += 5;
return PAR_FOUND;
}
break;
 
case PAR_TASK_NUMBER: