Subversion Repositories shark

Compare Revisions

Ignore whitespace Rev 1207 → Rev 1208

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