WebSVN - shark - Path Comparison - /demos/ Rev 1203 and /demos/ Rev 1202

Ignore whitespace Rev 1203 → Rev 1202

 /demos/trunk/loader/parser.h
 ,20 → 10,19
 #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_GAUSS 14
-#define PAR_EXEC_GAUSS_MAX 15
+#define PAR_EXEC_EXP 14
+#define PAR_EXEC_EXP_MAX 15
 #define PAR_ACT_SINGLE 16
 #define PAR_ACT_PERIODIC 17
 #define PAR_ACT_MEAN 18
-#define PAR_ACT_GAUSS 19
-#define PAR_ACT_GAUSS_MAX 20
+#define PAR_ACT_EXP 19
+#define PAR_ACT_EXP_MAX 20
 #define PAR_TASK_NRT 21
 #define PAR_TASK_HARD 22
 ,10 → 31,8
 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
 ,216 → 2,49
 #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)
 {
-  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
+  int i;
-  act_1 = TIMESPEC2USEC(&l->act_par_2);
-  act_2 = TIMESPEC2USEC(&l->act_par_3);
-  act_3 = TIMESPEC2USEC(&l->act_par_4);
+  cprintf("(Act %d)",exec_shadow);
-  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);
-  }
+  while(1) {
-  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);
-  }
+    for (i=0;i<100000;i++);
-  if (l->act_type == PAR_ACT_GAUSS) {
   }
+  return NULL;
-  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)
 {
-  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
+  int i;
-  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);
+  cprintf("(Act %d)",exec_shadow);
-  extra_rit = cal_rit_start;
   while(1) {
-    task_testcancel();
+    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);
-    }
+    task_endcycle();
-    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;
 ,7 → 55,6
     total_group++;
     current->group = total_group;
-    current->bandwidth = 0;
     for (i=0; i < current->number; i++) {
 ,8 → 68,7
         nrt_task_def_level(nrt,current->task_level);
         nrt_task_def_group(nrt,total_group);
-        sprintf(tmp,"NRT %d:%d",current->group,i);
-        p = task_create(tmp,nrt_test_task,&nrt,NULL);
+        p = task_create("NRT",nrt_test_task,&nrt,NULL);
         if (p == NIL) {
           cprintf("Error nrt task creating\n");
           sys_end();
 ,19 → 88,17
         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->deadline));
-          current->bandwidth += MAX_BANDWIDTH / TIMESPEC2USEC(&current->deadline)
-                                 * TIMESPEC2USEC(&current->wcet);
+        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));
           hard_task_def_aperiodic(ht);
         } else {
-          hard_task_def_mit(ht,TIMESPEC2USEC(&current->act_par_2));
-          current->bandwidth += MAX_BANDWIDTH / TIMESPEC2USEC(&current->act_par_2)
-                                 * TIMESPEC2USEC(&current->wcet);
+          hard_task_def_mit(ht,TIMESPEC2USEC(&current->wcet)*100);
+          hard_task_def_aperiodic(ht);
         }
-        sprintf(tmp,"HARD %d:%d",current->group,i);
-        p = task_create(tmp,test_task,&ht,NULL);
+        p = task_create("HARD",test_task,&ht,NULL);
         if (p == NIL) {
           cprintf("Error hard task creating\n");
           sys_end();
 ,21 → 121,15
         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)*1000);
-          current->bandwidth += MAX_BANDWIDTH / 1000;
+          soft_task_def_period(st,TIMESPEC2USEC(&current->wcet)*100);
           soft_task_def_aperiodic(st);
         }
-        sprintf(tmp,"SOFT %d:%d",current->group,i);
-        p = task_create(tmp,test_task,&st,NULL);
+        p = task_create("SOFT",test_task,&st,NULL);
         if (p == NIL) {
           cprintf("Error soft task creating\n");
           sys_end();
 ,10 → 141,6
     }
-    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;
   }
 ,7 → 149,6
 }
-/* Set the first extivation events */
 void loader_first_execution(struct loader_task *start_loader_task)
 {
 ,10 → 176,6
   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/dosread.c
 ,18 → 48,11
     }
     pbuf += i+1;
     line_buf[i] = 0;
-    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);
+    res = line_parser(line_buf, line_num, total, &current);
     if (res == 2) {
       total_loader_task++;
-      if (*start_loader_task == NULL)
-        *start_loader_task = current;
-      else
-        current = current->next;
+      if (*start_loader_task == NULL) *start_loader_task = current;
+      current = current->next;
     }
   }

 /demos/trunk/loader/loadfile.txt
 ,4 → 1,4
-# TASK TYPE:TASK LEVEL:NUMBER OF:TASK ACT TYPE (PAR0,PAR1,...):DEADLINE:WCET:TASK EXEC TYPE;
+# TASK TYPE:TASK LEVEL:NUMBER OF:TASK ACTIVATION TYPE (PAR0,PAR1,...):WCET:TASK EXEC TYPE;
 #
 # TASK TYPE
 # NRT - NON REAL TIME
 ,24 → 6,18
 # SOFT - SOFT REAL TIME
 #
 # TASK EXEC TYPE
-# 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
+# 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
 #
 # TASK ACTIVATION TIME
 # ACT_SINGLE(START_TIME)
 # ACT_PERIODIC(START_TIME, PERIOD)
 # ACT_MEAN(START_TIME, MEAN, DELTA)
-# ACT_GAUSS(START_TIME, MEAN, SIGMA)
-# ACT_GAUSS_MAX(START_TIME, MEAN, SIGMA, MAX)
+# ACT_EXP(START_TIME, MEAN, SIGMA)
+# ACT_EXP_MAX(START_TIME, MEAN, SIGMA, MAX)
-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]);
+TOTAL_EXEC_TIME:[10][0];
+HARD:[0]:[1]:ACT_PERIODIC([0][0],[1][0]):[0][10000]:EXEC_CONST([0][1000]);

 /demos/trunk/loader/parser.c
 ,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)
 {
 ,14 → 109,14
         *val = PAR_ACT_MEAN;
         return PAR_FOUND;
       }
-      if (!strncmp(*buf,"ACT_GAUSS(",10)) {
-        *buf += 10;
-        *val = PAR_ACT_GAUSS;
+      if (!strncmp(*buf,"ACT_EXP(",8)) {
+        *buf += 8;
+        *val = PAR_ACT_EXP;
         return PAR_FOUND;;
       }
-      if (!strncmp(*buf,"ACT_GAUSS_MAX(",14)) {
-        *buf += 14;
-        *val = PAR_ACT_GAUSS_MAX;
+      if (!strncmp(*buf,"ACT_EXP_MAX(",12)) {
+        *buf += 12;
+        *val = PAR_ACT_EXP_MAX;
         return PAR_FOUND;
       }
       return PAR_ERROR;
 ,14 → 133,14
        *val = PAR_EXEC_MEAN;
        return PAR_FOUND;
      }
-     if (!strncmp(*buf,"EXEC_GAUSS(",11)) {
-       *buf += 11;
-       *val = PAR_EXEC_GAUSS;
+     if (!strncmp(*buf,"EXEC_EXP(",9)) {
+       *buf += 9;
+       *val = PAR_EXEC_EXP;
        return PAR_FOUND;
      }
-     if (!strncmp(*buf,"EXEC_GAUSS_MAX(",15)) {
-       *buf += 15;
-       *val = PAR_EXEC_GAUSS_MAX;
+     if (!strncmp(*buf,"EXEC_EXP_MAX(",13)) {
+       *buf += 13;
+       *val = PAR_EXEC_EXP_MAX;
        return PAR_FOUND;
      }
      return PAR_ERROR;
 ,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_GAUSS) {
+        ld->act_type != PAR_ACT_MEAN && ld->act_type != PAR_ACT_EXP) {
       res = find_break(&pbuf,PAR_TIME, &time, &val);
       if (res == PAR_FOUND) {
         #ifdef PARSER_DEBUG
 ,14 → 280,6
   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);
 ,7 → 310,7
     }
     if (ld->exec_type != PAR_EXEC_CONST && ld->exec_type != PAR_EXEC_MEAN &&
-        ld->exec_type != PAR_EXEC_GAUSS) {
+        ld->exec_type != PAR_EXEC_EXP) {
       res = find_break(&pbuf,PAR_TIME, &time, &val);
       if (res == PAR_FOUND) {
         #ifdef PARSER_DEBUG

Subversion Repositories shark

Compare Revisions

Ignore whitespace Rev 1203 → Rev 1202