Subversion Repositories shark

Rev

Rev 1201 | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
1199 giacomo 1 
#include <kernel/kern.h>
2 
#include "parser.h"
1200 giacomo 3 
#include "dosread.h"
1199 giacomo 4 
 
1200 giacomo 5 
extern void *start;
6 
extern void *end;
7 
 
1202 giacomo 8 
struct timespec zero_time;
9 
 
1201 giacomo 10 
TASK nrt_test_task(void *arg)
11 
{
1202 giacomo 12 
  int i;
1201 giacomo 13 
 
1202 giacomo 14 
  cprintf("(Act %d)",exec_shadow);
15 
 
1201 giacomo 16 
  while(1) {
17 
 
1202 giacomo 18 
    for (i=0;i<100000;i++);
19 
 
1201 giacomo 20 
  }
21 
 
22 
  return NULL;
23 
 
24 
}
25 
 
26 
TASK test_task(void *arg)
27 
{
1202 giacomo 28 
  int i;  
1201 giacomo 29 
 
1202 giacomo 30 
  cprintf("(Act %d)",exec_shadow);
31 
 
1201 giacomo 32 
  while(1) {
33 
 
1202 giacomo 34 
    for (i=0;i<100000;i++);
35 
 
1201 giacomo 36 
    task_endcycle();
37 
 
38 
  }
39 
 
40 
  return NULL;
41 
 
42 
}
43 
 
44 
void loader_task_create(struct loader_task *start_loader_task)
45 
{
46 
 
47 
  struct loader_task *current = start_loader_task;
48 
  int i, total_task;
1202 giacomo 49 
  int total_group = 0;
1201 giacomo 50 
  PID p;
51 
 
52 
  total_task = 0;
53 
 
54 
  while (current != NULL) {
55 
 
1202 giacomo 56 
    total_group++;
57 
    current->group = total_group;
58 
 
1201 giacomo 59 
    for (i=0; i < current->number; i++) {
60 
 
61 
      if (current->task_type == PAR_TASK_NRT) {
62 
        NRT_TASK_MODEL nrt;
63 
 
64 
        nrt_task_default_model(nrt);
65 
        nrt_task_def_save_arrivals(nrt);
66 
        nrt_task_def_arg(nrt,(void *)(current));
67 
        nrt_task_def_ctrl_jet(nrt);
68 
        nrt_task_def_level(nrt,current->task_level);
1202 giacomo 69 
        nrt_task_def_group(nrt,total_group);
1201 giacomo 70 
 
71 
        p = task_create("NRT",nrt_test_task,&nrt,NULL);
72 
        if (p == NIL) {
73 
          cprintf("Error nrt task creating\n");
74 
          sys_end();
75 
        }
76 
 
77 
        total_task++;
78 
 
79 
      }
80 
 
81 
      if (current->task_type == PAR_TASK_HARD) {
82 
        HARD_TASK_MODEL ht;
83 
 
84 
        hard_task_default_model(ht);
85 
        hard_task_def_arg(ht,(void *)(current));
86 
        hard_task_def_wcet(ht,TIMESPEC2USEC(&current->wcet));
87 
        hard_task_def_ctrl_jet(ht);
88 
        hard_task_def_level(ht,current->task_level);
1202 giacomo 89 
        hard_task_def_group(ht,total_group);
1201 giacomo 90 
 
91 
        if (current->act_type == PAR_ACT_PERIODIC) {
92 
          hard_task_def_mit(ht,TIMESPEC2USEC(&current->act_par_2));
93 
        } else if (current->act_type != PAR_ACT_SINGLE) {
94 
          hard_task_def_mit(ht,TIMESPEC2USEC(&current->act_par_2));
95 
          hard_task_def_aperiodic(ht);
96 
        } else {
97 
          hard_task_def_mit(ht,TIMESPEC2USEC(&current->wcet)*100);
98 
          hard_task_def_aperiodic(ht);
99 
        }
100 
 
101 
        p = task_create("HARD",test_task,&ht,NULL);
102 
        if (p == NIL) {
103 
          cprintf("Error hard task creating\n");
104 
          sys_end();
105 
        }
106 
 
107 
        total_task++;
108 
 
109 
      }
110 
 
111 
      if (current->task_type == PAR_TASK_SOFT) {
112 
        SOFT_TASK_MODEL st;
113 
 
114 
        soft_task_default_model(st);
115 
        soft_task_def_save_arrivals(st);
116 
        soft_task_def_arg(st,(void *)(current));
117 
        soft_task_def_met(st,TIMESPEC2USEC(&current->wcet));
118 
        soft_task_def_ctrl_jet(st);
119 
        soft_task_def_level(st,current->task_level);
1202 giacomo 120 
        soft_task_def_group(st,total_group);
121 
 
1201 giacomo 122 
        if (current->act_type == PAR_ACT_PERIODIC) {
123 
          soft_task_def_period(st,TIMESPEC2USEC(&current->act_par_2));
124 
        } else if (current->act_type != PAR_ACT_SINGLE) {
125 
          soft_task_def_period(st,TIMESPEC2USEC(&current->act_par_2));
126 
          soft_task_def_aperiodic(st);
127 
        } else {
128 
          soft_task_def_period(st,TIMESPEC2USEC(&current->wcet)*100);
129 
          soft_task_def_aperiodic(st);
130 
        }
131 
 
132 
        p = task_create("SOFT",test_task,&st,NULL);
133 
        if (p == NIL) {
134 
          cprintf("Error soft task creating\n");
135 
          sys_end();
136 
        }
137 
 
138 
        total_task++;
139 
 
140 
      }
141 
 
142 
    }
143 
 
144 
    current = current->next;
145 
 
146 
  }
147 
 
148 
  cprintf("Created %d tasks\n",total_task);
149 
 
150 
}
151 
 
1202 giacomo 152 
void loader_first_execution(struct loader_task *start_loader_task)
153 
{
154 
 
155 
  struct loader_task *current = start_loader_task;
156 
  struct timespec start_time;  
157 
 
158 
  while (current != NULL) {
159 
 
160 
    ADDTIMESPEC(&zero_time,&current->act_par_1,&start_time);
161 
 
162 
    kern_event_post(&start_time, (void *)((void *)group_activate), (void *)(current->group));
163 
 
164 
    current = current->next;
165 
 
166 
  }  
167 
 
168 
}
169 
 
1199 giacomo 170 
int main()
171 
{
172 
 
1200 giacomo 173 
  struct loader_task *start_loader_task = NULL;
174 
  struct timespec total;
1201 giacomo 175 
  struct timespec end_time;
1199 giacomo 176 
 
1201 giacomo 177 
  line_reader(start, end, &total, &start_loader_task);
1200 giacomo 178 
 
1201 giacomo 179 
  loader_task_create(start_loader_task);
180 
 
181 
  kern_gettime(&zero_time);
1202 giacomo 182 
 
183 
  loader_first_execution(start_loader_task);
184 
 
1201 giacomo 185 
  ADDTIMESPEC(&zero_time,&total,&end_time);
186 
  kern_event_post(&end_time,(void *)((void *)(sys_end)),NULL);
187 
 
1199 giacomo 188 
  return 0;
189 
 
190 
}