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