|
48
|
1 #include <stdio.h>
|
|
50
|
2 #include <stdlib.h>
|
|
42
|
3 #include "Scheduler.h"
|
|
|
4 #include "SchedNop.h"
|
|
|
5 #include "error.h"
|
|
|
6
|
|
109
|
7 Scheduler::TaskObject task_list[MAX_TASK_OBJECT];
|
|
|
8
|
|
|
9 Scheduler::~Scheduler(void)
|
|
|
10 {
|
|
|
11 delete connector;
|
|
|
12 }
|
|
|
13
|
|
42
|
14 void
|
|
|
15 Scheduler::init(void)
|
|
|
16 {
|
|
|
17 init_impl();
|
|
109
|
18
|
|
|
19 for (int i = 0; i < 2; i++) {
|
|
|
20 buff_taskList[i] = (TaskListPtr)allocate(sizeof(TaskList));
|
|
|
21 buff_inListData[i] = (ListDataPtr)allocate(sizeof(ListData));
|
|
|
22 buff_outListData[i] = (ListDataPtr)allocate(sizeof(ListData));
|
|
|
23 }
|
|
42
|
24
|
|
109
|
25 buffFlag_taskList = 0;
|
|
|
26 buffFlag_inListData = 0;
|
|
|
27 buffFlag_outListData = 0;
|
|
|
28 flag_renewTaskList = 0;
|
|
|
29
|
|
298
|
30 // bzero でもいいけど
|
|
109
|
31 for (int i = 0; i < MAX_GLOBAL_AREA; i++) {
|
|
|
32 globalList[i] = NULL;
|
|
|
33 }
|
|
|
34
|
|
|
35 for (int i = 0; i < MAX_MAINMEM_AREA; i++) {
|
|
|
36 mainMemList[i] = NULL;
|
|
|
37 }
|
|
|
38
|
|
|
39
|
|
|
40 taskGroup = new TaskGroup;
|
|
|
41 renewTop_taskList = NULL;
|
|
|
42 renewCur_taskList = NULL;
|
|
42
|
43 }
|
|
|
44
|
|
|
45 void
|
|
|
46 Scheduler::run(void)
|
|
|
47 {
|
|
|
48 SchedTaskBase* taskTmp;
|
|
109
|
49
|
|
42
|
50 task1 = new SchedNop();
|
|
|
51 task2 = new SchedNop();
|
|
|
52 task3 = new SchedNop();
|
|
|
53
|
|
|
54 // main loop
|
|
|
55 do {
|
|
|
56 __debug("----------\n");
|
|
|
57 task3->write();
|
|
|
58 task2->exec();
|
|
|
59 task1->read();
|
|
|
60
|
|
|
61 taskTmp = task3;
|
|
|
62 task3 = task2;
|
|
|
63 task2 = task1;
|
|
|
64 task1 = task1->next(this, taskTmp);
|
|
|
65 } while (task1);
|
|
|
66
|
|
|
67 delete task3;
|
|
|
68 delete task2;
|
|
50
|
69 }
|
|
48
|
70
|
|
50
|
71
|
|
|
72 void
|
|
|
73 Scheduler::finish(void)
|
|
|
74 {
|
|
109
|
75 free(buff_taskList[0]);
|
|
|
76 free(buff_taskList[1]);
|
|
|
77 free(buff_inListData[0]);
|
|
|
78 free(buff_inListData[1]);
|
|
|
79 free(buff_outListData[0]);
|
|
|
80 free(buff_outListData[1]);
|
|
42
|
81 }
|
|
|
82
|
|
109
|
83 /**
|
|
298
|
84 * あらかじめ memory allocte してある TaskList の領域を
|
|
|
85 * パイプラインの各処理が交代して使う。
|
|
109
|
86 */
|
|
42
|
87 TaskListPtr
|
|
|
88 Scheduler::get_curListBuf(void)
|
|
|
89 {
|
|
109
|
90 buffFlag_taskList ^= 1;
|
|
|
91
|
|
|
92 return buff_taskList[buffFlag_taskList];
|
|
|
93 }
|
|
|
94
|
|
|
95
|
|
|
96 /**
|
|
298
|
97 * あらかじめ memory allocte してある ListData の領域を
|
|
|
98 * パイプラインの各処理が交代して使う。
|
|
109
|
99 */
|
|
|
100 ListDataPtr
|
|
|
101 Scheduler::get_curWriteBuf(void)
|
|
|
102 {
|
|
|
103 buffFlag_outListData ^= 1;
|
|
|
104 return buff_outListData[buffFlag_outListData];
|
|
|
105 }
|
|
|
106
|
|
|
107
|
|
|
108 ListDataPtr
|
|
|
109 Scheduler::get_curReadBuf(void)
|
|
|
110 {
|
|
|
111 buffFlag_inListData ^= 1;
|
|
|
112 return buff_inListData[buffFlag_inListData];
|
|
|
113 }
|
|
|
114
|
|
|
115 /**
|
|
298
|
116 * タスク内で生成されたタスクを格納する TaskList を取得する
|
|
|
117 * 現在格納に使っている TaskList (renewCur_taskList) が使えるならそれを返す
|
|
|
118 * もしそうでないなら、新しく TaskList を allocate してそれを返す
|
|
|
119 * コード中で renewCur_taskList が NULL になるのは
|
|
|
120 * - プログラム開始時
|
|
|
121 * - タスク内生成タスクがある TaskList の実行を新しく始める (Nop2Ready 参照)
|
|
|
122 * 以上の場合です
|
|
109
|
123 */
|
|
|
124 TaskListPtr
|
|
|
125 Scheduler::get_renewListBuf(void)
|
|
|
126 {
|
|
|
127 if (renewCur_taskList && renewCur_taskList->length < TASK_MAX_SIZE) {
|
|
|
128 return renewCur_taskList;
|
|
|
129 } else {
|
|
|
130 TaskListPtr newList = (TaskListPtr)allocate(sizeof(TaskList));
|
|
|
131 newList->length = 0;
|
|
|
132 newList->next = NULL;
|
|
|
133 renewTop_taskList = TaskList::append(renewTop_taskList, newList);
|
|
|
134 renewCur_taskList = newList;
|
|
|
135 return newList;
|
|
|
136 }
|
|
|
137 }
|
|
|
138
|
|
184
|
139 /**
|
|
298
|
140 * 次に実行する Renew Task List を返す
|
|
184
|
141 *
|
|
298
|
142 * @param[in] curList 現在実行中の TaskList
|
|
|
143 * 中断して RenewTaskList を行うため
|
|
|
144 * バックアップを取っておく
|
|
184
|
145 * @return next RenewTaskList
|
|
|
146 */
|
|
|
147 SchedTaskList*
|
|
187
|
148 Scheduler::get_nextRenewTaskList(void)
|
|
184
|
149 {
|
|
|
150 if (renewTop_taskList) {
|
|
|
151 TaskListPtr list = renewTop_taskList;
|
|
|
152 renewTop_taskList = renewTop_taskList->next;
|
|
|
153 renewCur_taskList = NULL;
|
|
233
|
154
|
|
187
|
155 list->next = NULL;
|
|
184
|
156 SchedTaskList *sched
|
|
|
157 = createSchedTaskList((uint32)list, this, SCHED_TASKLIST_RENEW);
|
|
|
158 return sched;
|
|
|
159 } else {
|
|
|
160 return NULL;
|
|
|
161 }
|
|
|
162 }
|
|
|
163
|
|
187
|
164 void
|
|
|
165 Scheduler::set_backupTaskList(TaskListPtr cur_taskList)
|
|
|
166 {
|
|
|
167 bak_curTaskList = cur_taskList;
|
|
|
168 }
|
|
|
169
|
|
|
170 void
|
|
|
171 Scheduler::set_backupTaskListIndex(int cur_index)
|
|
|
172 {
|
|
|
173 bakIndex_taskList = cur_index;
|
|
|
174 }
|
|
|
175
|
|
184
|
176 /**
|
|
298
|
177 * RenewTaskList 実行前に中断した TaskList を返す
|
|
|
178 * NULL の場合、中断した TaskList は無い。
|
|
184
|
179 *
|
|
|
180 * @return TaskList
|
|
|
181 */
|
|
|
182 TaskListPtr
|
|
|
183 Scheduler::get_backupTaskList(void)
|
|
|
184 {
|
|
187
|
185 TaskListPtr ret = bak_curTaskList;
|
|
|
186
|
|
|
187 bak_curTaskList = NULL;
|
|
|
188 return ret;
|
|
|
189 }
|
|
|
190
|
|
|
191 int
|
|
|
192 Scheduler::get_backupTaskListIndex(void)
|
|
|
193 {
|
|
|
194 int ret = bakIndex_taskList;
|
|
|
195
|
|
|
196 bakIndex_taskList = 0;
|
|
|
197 return ret;
|
|
184
|
198 }
|
|
|
199
|
|
109
|
200 void
|
|
|
201 Scheduler::dma_load(void *buf, uint32 addr, uint32 size, uint32 mask)
|
|
|
202 {
|
|
|
203 connector->dma_load(buf, addr, size, mask);
|
|
|
204 }
|
|
|
205
|
|
|
206 void
|
|
|
207 Scheduler::dma_store(void *buf, uint32 addr, uint32 size, uint32 mask)
|
|
|
208 {
|
|
|
209 connector->dma_store(buf, addr, size, mask);
|
|
|
210 }
|
|
|
211
|
|
|
212 void
|
|
|
213 Scheduler::dma_wait(uint32 mask)
|
|
|
214 {
|
|
|
215 connector->dma_wait(mask);
|
|
|
216 }
|
|
|
217
|
|
|
218 void
|
|
|
219 Scheduler::dma_loadList(ListDataPtr list, void *buff, uint32 mask)
|
|
|
220 {
|
|
|
221 connector->dma_loadList(list, buff, mask);
|
|
42
|
222 }
|
|
|
223
|
|
|
224
|
|
109
|
225 void
|
|
|
226 Scheduler::dma_storeList(ListDataPtr list, void *buff, uint32 mask)
|
|
|
227 {
|
|
|
228 return connector->dma_storeList(list, buff, mask);
|
|
|
229 }
|
|
|
230
|
|
|
231 void
|
|
|
232 Scheduler::mail_write(uint32 data)
|
|
|
233 {
|
|
|
234 connector->mail_write(data);
|
|
|
235 }
|
|
|
236
|
|
|
237 uint32
|
|
|
238 Scheduler::mail_read(void)
|
|
|
239 {
|
|
|
240 return connector->mail_read();
|
|
|
241 }
|
|
|
242
|
|
|
243 TaskGroupPtr
|
|
|
244 Scheduler::set_groupTask(uint32 command)
|
|
|
245 {
|
|
|
246 TaskGroupPtr ret = taskGroup;
|
|
|
247
|
|
|
248 reload_groupTask();
|
|
|
249
|
|
|
250 ret->command = command;
|
|
|
251 return ret;
|
|
|
252 }
|
|
|
253
|
|
|
254 void
|
|
|
255 Scheduler::add_groupTask(TaskGroupPtr group, TaskPtr task)
|
|
|
256 {
|
|
|
257 group->add(task);
|
|
|
258 }
|
|
|
259
|
|
|
260 void
|
|
|
261 Scheduler::remove_groupTask(TaskGroupPtr group, TaskPtr task)
|
|
42
|
262 {
|
|
109
|
263 group->remove(task);
|
|
|
264 }
|
|
|
265
|
|
|
266 void
|
|
|
267 Scheduler::reload_groupTask(void)
|
|
|
268 {
|
|
|
269 taskGroup = new TaskGroup;
|
|
|
270 }
|
|
|
271
|
|
|
272 uint32
|
|
|
273 Scheduler::status_groupTask(TaskGroupPtr group)
|
|
|
274 {
|
|
|
275 return group->status();
|
|
|
276 }
|
|
|
277
|
|
|
278 void*
|
|
|
279 Scheduler::global_alloc(int id, int size)
|
|
|
280 {
|
|
|
281 globalList[id] = allocate(size);
|
|
|
282 return globalList[id];
|
|
|
283 }
|
|
|
284
|
|
|
285 void*
|
|
|
286 Scheduler::global_get(int id)
|
|
|
287 {
|
|
|
288 return globalList[id];
|
|
|
289 }
|
|
|
290
|
|
|
291 void
|
|
|
292 Scheduler::global_free(int id)
|
|
|
293 {
|
|
|
294 free(globalList[id]);
|
|
|
295 globalList[id] = NULL;
|
|
|
296 }
|
|
|
297
|
|
|
298 /**
|
|
298
|
299 * mainMem_alloc で確保したメインメモリの領域アドレスを返す。
|
|
|
300 * これは Fifo, Cell で共通
|
|
109
|
301 */
|
|
|
302 void*
|
|
|
303 Scheduler::mainMem_get(int id)
|
|
|
304 {
|
|
|
305 return mainMemList[id];
|
|
42
|
306 }
|
|
|
307
|
|
|
308
|
|
109
|
309 /**
|
|
298
|
310 * 本当は Scheduler クラスに入れるべきなんだろうか。。。
|
|
|
311 * なんか手抜きの感がある
|
|
109
|
312 */
|
|
|
313 void
|
|
|
314 register_task(int cmd, Scheduler::TaskObject task)
|
|
42
|
315 {
|
|
109
|
316 task_list[cmd] = task;
|
|
42
|
317 }
|
