Subversion Repositories shark

Rev

Rev 1200 | Rev 1202 | Go to most recent revision | 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 
 
1201 giacomo 8 
TASK nrt_test_task(void *arg)
9 
{
10 
 
11 
  while(1) {
12 
 
13 
  }
14 
 
15 
  return NULL;
16 
 
17 
}
18 
 
19 
TASK test_task(void *arg)
20 
{
21 
 
22 
  while(1) {
23 
 
24 
    task_endcycle();
25 
 
26 
  }
27 
 
28 
  return NULL;
29 
 
30 
}
31 
 
32 
void loader_task_create(struct loader_task *start_loader_task)
33 
{
34 
 
35 
  struct loader_task *current = start_loader_task;
36 
  int i, total_task;
37 
  PID p;
38 
 
39 
  total_task = 0;
40 
 
41 
  while (current != NULL) {
42 
 
43 
    for (i=0; i < current->number; i++) {
44 
 
45 
      if (current->task_type == PAR_TASK_NRT) {
46 
        NRT_TASK_MODEL nrt;
47 
 
48 
        nrt_task_default_model(nrt);
49 
        nrt_task_def_save_arrivals(nrt);
50 
        nrt_task_def_arg(nrt,(void *)(current));
51 
        nrt_task_def_ctrl_jet(nrt);
52 
        nrt_task_def_level(nrt,current->task_level);
53 
        nrt_task_def_group(nrt,1);
54 
 
55 
        p = task_create("NRT",nrt_test_task,&nrt,NULL);
56 
        if (p == NIL) {
57 
          cprintf("Error nrt task creating\n");
58 
          sys_end();
59 
        }
60 
 
61 
        total_task++;
62 
 
63 
      }
64 
 
65 
      if (current->task_type == PAR_TASK_HARD) {
66 
        HARD_TASK_MODEL ht;
67 
 
68 
        hard_task_default_model(ht);
69 
        hard_task_def_arg(ht,(void *)(current));
70 
        hard_task_def_wcet(ht,TIMESPEC2USEC(&current->wcet));
71 
        hard_task_def_ctrl_jet(ht);
72 
        hard_task_def_level(ht,current->task_level);
73 
        hard_task_def_group(ht,1);
74 
 
75 
        if (current->act_type == PAR_ACT_PERIODIC) {
76 
          hard_task_def_mit(ht,TIMESPEC2USEC(&current->act_par_2));
77 
        } else if (current->act_type != PAR_ACT_SINGLE) {
78 
          hard_task_def_mit(ht,TIMESPEC2USEC(&current->act_par_2));
79 
          hard_task_def_aperiodic(ht);
80 
        } else {
81 
          hard_task_def_mit(ht,TIMESPEC2USEC(&current->wcet)*100);
82 
          hard_task_def_aperiodic(ht);
83 
        }
84 
 
85 
        p = task_create("HARD",test_task,&ht,NULL);
86 
        if (p == NIL) {
87 
          cprintf("Error hard task creating\n");
88 
          sys_end();
89 
        }
90 
 
91 
        total_task++;
92 
 
93 
      }
94 
 
95 
      if (current->task_type == PAR_TASK_SOFT) {
96 
        SOFT_TASK_MODEL st;
97 
 
98 
        soft_task_default_model(st);
99 
        soft_task_def_save_arrivals(st);
100 
        soft_task_def_arg(st,(void *)(current));
101 
        soft_task_def_met(st,TIMESPEC2USEC(&current->wcet));
102 
        soft_task_def_ctrl_jet(st);
103 
        soft_task_def_level(st,current->task_level);
104 
        soft_task_def_group(st,1);                                  
105 
 
106 
        if (current->act_type == PAR_ACT_PERIODIC) {
107 
          soft_task_def_period(st,TIMESPEC2USEC(&current->act_par_2));
108 
        } else if (current->act_type != PAR_ACT_SINGLE) {
109 
          soft_task_def_period(st,TIMESPEC2USEC(&current->act_par_2));
110 
          soft_task_def_aperiodic(st);
111 
        } else {
112 
          soft_task_def_period(st,TIMESPEC2USEC(&current->wcet)*100);
113 
          soft_task_def_aperiodic(st);
114 
        }
115 
 
116 
        p = task_create("SOFT",test_task,&st,NULL);
117 
        if (p == NIL) {
118 
          cprintf("Error soft task creating\n");
119 
          sys_end();
120 
        }
121 
 
122 
        total_task++;
123 
 
124 
      }
125 
 
126 
    }
127 
 
128 
    current = current->next;
129 
 
130 
  }
131 
 
132 
  cprintf("Created %d tasks\n",total_task);
133 
 
134 
}
135 
 
1199 giacomo 136 
int main()
137 
{
138 
 
1200 giacomo 139 
  struct loader_task *start_loader_task = NULL;
140 
  struct timespec total;
1201 giacomo 141 
  struct timespec zero_time;
142 
  struct timespec end_time;
1199 giacomo 143 
 
1201 giacomo 144 
  line_reader(start, end, &total, &start_loader_task);
1200 giacomo 145 
 
1201 giacomo 146 
  loader_task_create(start_loader_task);
147 
 
148 
  kern_gettime(&zero_time);
149 
  ADDTIMESPEC(&zero_time,&total,&end_time);
150 
 
151 
  kern_event_post(&end_time,(void *)((void *)(sys_end)),NULL);
152 
 
1199 giacomo 153 
  return 0;
154 
 
155 
}