Mercurial > hg > Members > kono > Cerium
annotate TaskManager/kernel/schedule/Scheduler.cc @ 523:b273767962b8
half finish for Cell
author | Shinji KONO <kono@ie.u-ryukyu.ac.jp> |
---|---|
date | Tue, 20 Oct 2009 22:29:27 +0900 |
parents | 1d4a8a86f26b |
children | 1733f3cbfa28 |
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" | |
386 | 6 #include <assert.h> |
42 | 7 |
313
c9f8cfcdc5c2
fix ppu mail box waiting (mainMem allocate)
kono@localhost.localdomain
parents:
301
diff
changeset
|
8 /* |
c9f8cfcdc5c2
fix ppu mail box waiting (mainMem allocate)
kono@localhost.localdomain
parents:
301
diff
changeset
|
9 * 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
|
10 * 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
|
11 */ |
c9f8cfcdc5c2
fix ppu mail box waiting (mainMem allocate)
kono@localhost.localdomain
parents:
301
diff
changeset
|
12 |
109 | 13 Scheduler::TaskObject task_list[MAX_TASK_OBJECT]; |
14 | |
501
4a2c9ff53605
Cell inData/outData DMA removal
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
483
diff
changeset
|
15 Scheduler::~Scheduler() |
109 | 16 { |
17 delete connector; | |
18 } | |
19 | |
301
bcb81858aa62
remove deprecated source. not work.
tkaito@localhost.localdomain
parents:
298
diff
changeset
|
20 /*! @brief speTaskの入出力のパイプラインバッファを確保する |
bcb81858aa62
remove deprecated source. not work.
tkaito@localhost.localdomain
parents:
298
diff
changeset
|
21 */ |
bcb81858aa62
remove deprecated source. not work.
tkaito@localhost.localdomain
parents:
298
diff
changeset
|
22 |
42 | 23 void |
501
4a2c9ff53605
Cell inData/outData DMA removal
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
483
diff
changeset
|
24 Scheduler::init() |
42 | 25 { |
388
82cb9368e3ff
MemHash (OS X version)
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
387
diff
changeset
|
26 hash = 0; |
42 | 27 init_impl(); |
109 | 28 |
29 for (int i = 0; i < 2; i++) { | |
373 | 30 buff_taskList[i] = (TaskListPtr)allocate(sizeof(TaskList)); |
501
4a2c9ff53605
Cell inData/outData DMA removal
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
483
diff
changeset
|
31 // buff_inListData[i] = (ListDataPtr)allocate(sizeof(ListData)); |
4a2c9ff53605
Cell inData/outData DMA removal
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
483
diff
changeset
|
32 // buff_outListData[i] = (ListDataPtr)allocate(sizeof(ListData)); |
109 | 33 } |
373 | 34 |
109 | 35 buffFlag_taskList = 0; |
501
4a2c9ff53605
Cell inData/outData DMA removal
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
483
diff
changeset
|
36 // buffFlag_inListData = 0; |
4a2c9ff53605
Cell inData/outData DMA removal
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
483
diff
changeset
|
37 // buffFlag_outListData = 0; |
109 | 38 flag_renewTaskList = 0; |
39 | |
298 | 40 // bzero でもいいけど |
109 | 41 for (int i = 0; i < MAX_GLOBAL_AREA; i++) { |
373 | 42 globalList[i] = NULL; |
109 | 43 } |
44 | |
45 for (int i = 0; i < MAX_MAINMEM_AREA; i++) { | |
373 | 46 mainMemList[i] = NULL; |
109 | 47 } |
373 | 48 |
109 | 49 |
50 taskGroup = new TaskGroup; | |
51 renewTop_taskList = NULL; | |
52 renewCur_taskList = NULL; | |
483
0b933bef0328
renew task worked. but not test_nogl...
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
468
diff
changeset
|
53 bak_curTaskList = NULL; |
42 | 54 } |
55 | |
56 void | |
501
4a2c9ff53605
Cell inData/outData DMA removal
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
483
diff
changeset
|
57 Scheduler::run() |
42 | 58 { |
59 task1 = new SchedNop(); | |
60 task2 = new SchedNop(); | |
61 task3 = new SchedNop(); | |
62 | |
63 // main loop | |
64 do { | |
373 | 65 __debug("----------\n"); |
66 task3->write(); | |
67 task2->exec(); | |
68 task1->read(); | |
468
bd5b93d39597
test_nogl on Mac OS X worked.
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
464
diff
changeset
|
69 delete task3; |
42 | 70 |
373 | 71 task3 = task2; |
72 task2 = task1; | |
468
bd5b93d39597
test_nogl on Mac OS X worked.
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
464
diff
changeset
|
73 task1 = task1->next(this, 0); |
42 | 74 } while (task1); |
75 | |
76 delete task3; | |
77 delete task2; | |
50 | 78 } |
48 | 79 |
50 | 80 |
81 void | |
501
4a2c9ff53605
Cell inData/outData DMA removal
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
483
diff
changeset
|
82 Scheduler::finish() |
50 | 83 { |
109 | 84 free(buff_taskList[0]); |
85 free(buff_taskList[1]); | |
501
4a2c9ff53605
Cell inData/outData DMA removal
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
483
diff
changeset
|
86 // free(buff_inListData[0]); |
4a2c9ff53605
Cell inData/outData DMA removal
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
483
diff
changeset
|
87 // free(buff_inListData[1]); |
4a2c9ff53605
Cell inData/outData DMA removal
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
483
diff
changeset
|
88 // free(buff_outListData[0]); |
4a2c9ff53605
Cell inData/outData DMA removal
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
483
diff
changeset
|
89 // free(buff_outListData[1]); |
42 | 90 } |
91 | |
109 | 92 /** |
298 | 93 * あらかじめ memory allocte してある TaskList の領域を |
94 * パイプラインの各処理が交代して使う。 | |
109 | 95 */ |
42 | 96 TaskListPtr |
501
4a2c9ff53605
Cell inData/outData DMA removal
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
483
diff
changeset
|
97 Scheduler::get_curListBuf() |
42 | 98 { |
109 | 99 buffFlag_taskList ^= 1; |
100 | |
101 return buff_taskList[buffFlag_taskList]; | |
102 } | |
103 | |
104 | |
105 /** | |
501
4a2c9ff53605
Cell inData/outData DMA removal
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
483
diff
changeset
|
106 * Task に inListData, outListData を入れたので、 |
4a2c9ff53605
Cell inData/outData DMA removal
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
483
diff
changeset
|
107 * これは必要ないらしい。 |
4a2c9ff53605
Cell inData/outData DMA removal
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
483
diff
changeset
|
108 * |
298 | 109 * あらかじめ memory allocte してある ListData の領域を |
110 * パイプラインの各処理が交代して使う。 | |
109 | 111 */ |
501
4a2c9ff53605
Cell inData/outData DMA removal
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
483
diff
changeset
|
112 #if 0 |
109 | 113 ListDataPtr |
501
4a2c9ff53605
Cell inData/outData DMA removal
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
483
diff
changeset
|
114 Scheduler::get_curWriteBuf() |
109 | 115 { |
116 buffFlag_outListData ^= 1; | |
117 return buff_outListData[buffFlag_outListData]; | |
118 } | |
119 | |
120 | |
121 ListDataPtr | |
501
4a2c9ff53605
Cell inData/outData DMA removal
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
483
diff
changeset
|
122 Scheduler::get_curReadBuf() |
109 | 123 { |
124 buffFlag_inListData ^= 1; | |
125 return buff_inListData[buffFlag_inListData]; | |
126 } | |
501
4a2c9ff53605
Cell inData/outData DMA removal
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
483
diff
changeset
|
127 #endif |
109 | 128 |
129 /** | |
298 | 130 * タスク内で生成されたタスクを格納する TaskList を取得する |
131 * 現在格納に使っている TaskList (renewCur_taskList) が使えるならそれを返す | |
132 * もしそうでないなら、新しく TaskList を allocate してそれを返す | |
133 * コード中で renewCur_taskList が NULL になるのは | |
134 * - プログラム開始時 | |
135 * - タスク内生成タスクがある TaskList の実行を新しく始める (Nop2Ready 参照) | |
136 * 以上の場合です | |
109 | 137 */ |
138 TaskListPtr | |
501
4a2c9ff53605
Cell inData/outData DMA removal
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
483
diff
changeset
|
139 Scheduler::get_renewListBuf() |
109 | 140 { |
141 if (renewCur_taskList && renewCur_taskList->length < TASK_MAX_SIZE) { | |
373 | 142 return renewCur_taskList; |
109 | 143 } else { |
373 | 144 TaskListPtr newList = (TaskListPtr)allocate(sizeof(TaskList)); |
145 newList->length = 0; | |
146 newList->next = NULL; | |
147 renewTop_taskList = TaskList::append(renewTop_taskList, newList); | |
148 renewCur_taskList = newList; | |
149 return newList; | |
109 | 150 } |
151 } | |
152 | |
184 | 153 /** |
298 | 154 * 次に実行する Renew Task List を返す |
184 | 155 * |
298 | 156 * @param[in] curList 現在実行中の TaskList |
157 * 中断して RenewTaskList を行うため | |
158 * バックアップを取っておく | |
184 | 159 * @return next RenewTaskList |
160 */ | |
161 SchedTaskList* | |
501
4a2c9ff53605
Cell inData/outData DMA removal
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
483
diff
changeset
|
162 Scheduler::get_nextRenewTaskList() |
184 | 163 { |
164 if (renewTop_taskList) { | |
373 | 165 TaskListPtr list = renewTop_taskList; |
166 renewTop_taskList = renewTop_taskList->next; | |
167 renewCur_taskList = NULL; | |
233 | 168 |
373 | 169 list->next = NULL; |
170 SchedTaskList *sched | |
171 = createSchedTaskList((uint32)list, this, SCHED_TASKLIST_RENEW); | |
172 return sched; | |
184 | 173 } else { |
373 | 174 return NULL; |
184 | 175 } |
176 } | |
177 | |
187 | 178 void |
179 Scheduler::set_backupTaskList(TaskListPtr cur_taskList) | |
180 { | |
181 bak_curTaskList = cur_taskList; | |
182 } | |
183 | |
184 void | |
185 Scheduler::set_backupTaskListIndex(int cur_index) | |
186 { | |
187 bakIndex_taskList = cur_index; | |
188 } | |
189 | |
184 | 190 /** |
298 | 191 * RenewTaskList 実行前に中断した TaskList を返す |
192 * NULL の場合、中断した TaskList は無い。 | |
184 | 193 * |
194 * @return TaskList | |
195 */ | |
196 TaskListPtr | |
501
4a2c9ff53605
Cell inData/outData DMA removal
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
483
diff
changeset
|
197 Scheduler::get_backupTaskList() |
184 | 198 { |
187 | 199 TaskListPtr ret = bak_curTaskList; |
373 | 200 |
187 | 201 bak_curTaskList = NULL; |
202 return ret; | |
203 } | |
204 | |
205 int | |
501
4a2c9ff53605
Cell inData/outData DMA removal
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
483
diff
changeset
|
206 Scheduler::get_backupTaskListIndex() |
187 | 207 { |
208 int ret = bakIndex_taskList; | |
209 | |
210 bakIndex_taskList = 0; | |
211 return ret; | |
184 | 212 } |
213 | |
109 | 214 void |
215 Scheduler::dma_load(void *buf, uint32 addr, uint32 size, uint32 mask) | |
216 { | |
217 connector->dma_load(buf, addr, size, mask); | |
218 } | |
219 | |
220 void | |
221 Scheduler::dma_store(void *buf, uint32 addr, uint32 size, uint32 mask) | |
222 { | |
223 connector->dma_store(buf, addr, size, mask); | |
224 } | |
225 | |
226 void | |
227 Scheduler::dma_wait(uint32 mask) | |
228 { | |
229 connector->dma_wait(mask); | |
230 } | |
231 | |
232 void | |
233 Scheduler::dma_loadList(ListDataPtr list, void *buff, uint32 mask) | |
234 { | |
235 connector->dma_loadList(list, buff, mask); | |
42 | 236 } |
237 | |
238 | |
109 | 239 void |
240 Scheduler::dma_storeList(ListDataPtr list, void *buff, uint32 mask) | |
241 { | |
242 return connector->dma_storeList(list, buff, mask); | |
243 } | |
244 | |
245 void | |
246 Scheduler::mail_write(uint32 data) | |
247 { | |
248 connector->mail_write(data); | |
249 } | |
250 | |
251 uint32 | |
501
4a2c9ff53605
Cell inData/outData DMA removal
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
483
diff
changeset
|
252 Scheduler::mail_read() |
109 | 253 { |
254 return connector->mail_read(); | |
255 } | |
256 | |
257 TaskGroupPtr | |
258 Scheduler::set_groupTask(uint32 command) | |
259 { | |
260 TaskGroupPtr ret = taskGroup; | |
261 | |
262 reload_groupTask(); | |
263 | |
264 ret->command = command; | |
265 return ret; | |
266 } | |
267 | |
268 void | |
269 Scheduler::add_groupTask(TaskGroupPtr group, TaskPtr task) | |
270 { | |
271 group->add(task); | |
272 } | |
273 | |
274 void | |
275 Scheduler::remove_groupTask(TaskGroupPtr group, TaskPtr task) | |
42 | 276 { |
109 | 277 group->remove(task); |
278 } | |
279 | |
280 void | |
501
4a2c9ff53605
Cell inData/outData DMA removal
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
483
diff
changeset
|
281 Scheduler::reload_groupTask() |
109 | 282 { |
283 taskGroup = new TaskGroup; | |
284 } | |
285 | |
286 uint32 | |
287 Scheduler::status_groupTask(TaskGroupPtr group) | |
288 { | |
289 return group->status(); | |
290 } | |
291 | |
386 | 292 /* |
293 ここから下は、memory 以下にあるべき | |
294 */ | |
295 | |
109 | 296 void* |
297 Scheduler::global_alloc(int id, int size) | |
298 { | |
299 globalList[id] = allocate(size); | |
300 return globalList[id]; | |
301 } | |
302 | |
303 void* | |
304 Scheduler::global_get(int id) | |
305 { | |
306 return globalList[id]; | |
307 } | |
308 | |
309 void | |
373 | 310 Scheduler::global_set(int id, void *addr) |
311 { | |
312 globalList[id] = addr; | |
313 } | |
314 | |
315 void | |
109 | 316 Scheduler::global_free(int id) |
317 { | |
318 free(globalList[id]); | |
319 globalList[id] = NULL; | |
320 } | |
321 | |
322 /** | |
298 | 323 * mainMem_alloc で確保したメインメモリの領域アドレスを返す。 |
324 * これは Fifo, Cell で共通 | |
109 | 325 */ |
326 void* | |
327 Scheduler::mainMem_get(int id) | |
328 { | |
329 return mainMemList[id]; | |
42 | 330 } |
331 | |
421
cd77224d4224
Code load implementation... (not yet tested)
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
403
diff
changeset
|
332 /** |
cd77224d4224
Code load implementation... (not yet tested)
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
403
diff
changeset
|
333 * Task load API |
cd77224d4224
Code load implementation... (not yet tested)
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
403
diff
changeset
|
334 */ |
425 | 335 void |
442 | 336 Scheduler::allocate_code_segment(int size, int count) |
425 | 337 { |
437 | 338 // 既に overlay 領域があるので、それを追加する必要がある... |
442 | 339 code_segment_pool = createMemList(size, count); |
425 | 340 } |
42 | 341 |
421
cd77224d4224
Code load implementation... (not yet tested)
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
403
diff
changeset
|
342 static void |
cd77224d4224
Code load implementation... (not yet tested)
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
403
diff
changeset
|
343 load_task(Scheduler *m, int task_id) |
cd77224d4224
Code load implementation... (not yet tested)
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
403
diff
changeset
|
344 { |
cd77224d4224
Code load implementation... (not yet tested)
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
403
diff
changeset
|
345 MemorySegment *s = m->get_segment( |
cd77224d4224
Code load implementation... (not yet tested)
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
403
diff
changeset
|
346 task_list[task_id].location, |
437 | 347 m->code_segment_pool, |
348 task_list[task_id].end-task_list[task_id].location); | |
421
cd77224d4224
Code load implementation... (not yet tested)
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
403
diff
changeset
|
349 task_list[task_id].segment = s; |
506 | 350 #if 0 |
461 | 351 fprintf(stderr,"loadng task id %d at 0x%x entry 0x%x\n",task_id, |
352 (unsigned int)(task_list[task_id].segment->data ), | |
353 (unsigned int)( | |
354 (char*)task_list[task_id].segment->data + | |
355 task_list[task_id].entry_offset)); | |
506 | 356 #endif |
421
cd77224d4224
Code load implementation... (not yet tested)
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
403
diff
changeset
|
357 } |
cd77224d4224
Code load implementation... (not yet tested)
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
403
diff
changeset
|
358 |
cd77224d4224
Code load implementation... (not yet tested)
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
403
diff
changeset
|
359 static void |
cd77224d4224
Code load implementation... (not yet tested)
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
403
diff
changeset
|
360 null_loader(Scheduler *m, int task_id) |
cd77224d4224
Code load implementation... (not yet tested)
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
403
diff
changeset
|
361 { |
cd77224d4224
Code load implementation... (not yet tested)
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
403
diff
changeset
|
362 } |
cd77224d4224
Code load implementation... (not yet tested)
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
403
diff
changeset
|
363 |
cd77224d4224
Code load implementation... (not yet tested)
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
403
diff
changeset
|
364 static void |
cd77224d4224
Code load implementation... (not yet tested)
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
403
diff
changeset
|
365 wait_load(Scheduler *m, int task_id) |
cd77224d4224
Code load implementation... (not yet tested)
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
403
diff
changeset
|
366 { |
523 | 367 #if 0 |
442 | 368 MemorySegment *s = task_list[task_id].segment; |
369 if (s) | |
370 fprintf(stderr,"wait load task id %d 0x%x\n",task_id,(int)s->data); | |
371 else | |
372 fprintf(stderr,"wait load task id %d 000000\n",task_id); | |
506 | 373 #endif |
421
cd77224d4224
Code load implementation... (not yet tested)
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
403
diff
changeset
|
374 // wait for code segment load |
cd77224d4224
Code load implementation... (not yet tested)
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
403
diff
changeset
|
375 m->wait_segment(task_list[task_id].segment); |
cd77224d4224
Code load implementation... (not yet tested)
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
403
diff
changeset
|
376 // calcurate call address |
464
01b321c86747
task run is mere C function now.
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
461
diff
changeset
|
377 TaskObjectRun run = |
01b321c86747
task run is mere C function now.
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
461
diff
changeset
|
378 (TaskObjectRun)( |
421
cd77224d4224
Code load implementation... (not yet tested)
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
403
diff
changeset
|
379 (char*)task_list[task_id].segment->data + |
cd77224d4224
Code load implementation... (not yet tested)
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
403
diff
changeset
|
380 task_list[task_id].entry_offset); |
464
01b321c86747
task run is mere C function now.
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
461
diff
changeset
|
381 task_list[task_id].run = run; |
506 | 382 #if 0 |
439 | 383 fprintf(stderr,"wait load task id %d done. creator = 0x%x entry_offset = 0x%x\n",task_id, |
464
01b321c86747
task run is mere C function now.
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
461
diff
changeset
|
384 (unsigned int)run, |
439 | 385 task_list[task_id].entry_offset); |
506 | 386 #endif |
421
cd77224d4224
Code load implementation... (not yet tested)
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
403
diff
changeset
|
387 } |
cd77224d4224
Code load implementation... (not yet tested)
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
403
diff
changeset
|
388 |
cd77224d4224
Code load implementation... (not yet tested)
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
403
diff
changeset
|
389 static void |
cd77224d4224
Code load implementation... (not yet tested)
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
403
diff
changeset
|
390 null_waiter(Scheduler *m, int task_id) |
cd77224d4224
Code load implementation... (not yet tested)
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
403
diff
changeset
|
391 { |
cd77224d4224
Code load implementation... (not yet tested)
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
403
diff
changeset
|
392 } |
cd77224d4224
Code load implementation... (not yet tested)
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
403
diff
changeset
|
393 |
cd77224d4224
Code load implementation... (not yet tested)
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
403
diff
changeset
|
394 extern void |
464
01b321c86747
task run is mere C function now.
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
461
diff
changeset
|
395 register_task(int cmd, TaskObjectRun run) |
42 | 396 { |
464
01b321c86747
task run is mere C function now.
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
461
diff
changeset
|
397 task_list[cmd].run = run; |
421
cd77224d4224
Code load implementation... (not yet tested)
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
403
diff
changeset
|
398 task_list[cmd].load = null_loader; |
cd77224d4224
Code load implementation... (not yet tested)
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
403
diff
changeset
|
399 task_list[cmd].wait = null_waiter; |
42 | 400 } |
373 | 401 |
421
cd77224d4224
Code load implementation... (not yet tested)
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
403
diff
changeset
|
402 extern void |
cd77224d4224
Code load implementation... (not yet tested)
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
403
diff
changeset
|
403 register_dynamic_task(int cmd, |
441 | 404 memaddr start, int size, |
464
01b321c86747
task run is mere C function now.
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
461
diff
changeset
|
405 TaskObjectRun run, int entry_offset) |
421
cd77224d4224
Code load implementation... (not yet tested)
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
403
diff
changeset
|
406 { |
464
01b321c86747
task run is mere C function now.
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
461
diff
changeset
|
407 task_list[cmd].run = run; |
421
cd77224d4224
Code load implementation... (not yet tested)
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
403
diff
changeset
|
408 task_list[cmd].location = start; |
442 | 409 size &= 0xfffffffe; |
441 | 410 task_list[cmd].end = start+size; |
421
cd77224d4224
Code load implementation... (not yet tested)
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
403
diff
changeset
|
411 task_list[cmd].entry_offset = entry_offset; |
cd77224d4224
Code load implementation... (not yet tested)
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
403
diff
changeset
|
412 task_list[cmd].load = load_task; |
cd77224d4224
Code load implementation... (not yet tested)
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
403
diff
changeset
|
413 task_list[cmd].wait = wait_load; |
506 | 414 #if 0 |
439 | 415 fprintf(stderr,"cmd = %d\n",cmd); |
441 | 416 fprintf(stderr,"locatation = 0x%x\n",start); |
417 fprintf(stderr,"end = 0x%x\n",start+size); | |
418 fprintf(stderr,"size = 0x%x\n",size); | |
439 | 419 fprintf(stderr,"entry = 0x%x\n",entry_offset); |
506 | 420 #endif |
439 | 421 |
421
cd77224d4224
Code load implementation... (not yet tested)
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
403
diff
changeset
|
422 } |
cd77224d4224
Code load implementation... (not yet tested)
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
403
diff
changeset
|
423 |
cd77224d4224
Code load implementation... (not yet tested)
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
403
diff
changeset
|
424 |
373 | 425 /*! |
386 | 426 |
427 size 単位のMemory Segment を count 個作る | |
428 | |
373 | 429 @param [size] リストの要素1つのサイズ |
430 @param [count] 要素数 | |
431 @return allocate した領域のポインタ | |
432 | |
433 */ | |
434 MemList* | |
435 Scheduler::createMemList(int size, int count) | |
436 { | |
437 uint32 head_size = round_up16(sizeof(MemorySegment)); | |
438 uint32 seg_size = round_up16(head_size+size); | |
439 char* mseg = (char*)allocate(seg_size*count); | |
440 MemList* mlist = new MemList((MemorySegment*)mseg); | |
441 | |
388
82cb9368e3ff
MemHash (OS X version)
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
387
diff
changeset
|
442 if (!hash) { |
82cb9368e3ff
MemHash (OS X version)
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
387
diff
changeset
|
443 hash = new MemHash(); |
82cb9368e3ff
MemHash (OS X version)
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
387
diff
changeset
|
444 } |
82cb9368e3ff
MemHash (OS X version)
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
387
diff
changeset
|
445 |
373 | 446 for(int i = 0; i < count; i++) { |
447 MemorySegment* next = (MemorySegment*)(mseg+seg_size*i); | |
448 char* data = (char*)next+head_size; | |
449 next->data = (void*)data; | |
386 | 450 next->size = size; |
395 | 451 next->address = (memaddr)next; |
373 | 452 mlist->addLast(next); |
453 } | |
454 | |
455 return mlist; | |
456 } | |
386 | 457 |
458 /*! | |
459 | |
460 Main Memory のSegmentを取得する | |
461 | |
462 @param [addr] Main Memory のアドレス | |
463 @param [m] Mem List | |
464 @return allocate した領域のポインタ | |
465 memory directory にあるべきだが... | |
466 | |
467 */ | |
387
5e2d30bfbf23
no compile error but not worked.
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
386
diff
changeset
|
468 MemorySegment * |
386 | 469 Scheduler::get_segment(memaddr addr, MemList *m) |
470 { | |
449
4f11245e3504
get_segment fixed. and test_nogl rollback to 426. move!
kazz@henri.cr.ie.u-ryukyu.ac.jp
parents:
442
diff
changeset
|
471 MemorySegment *s = m->getFirst(); |
4f11245e3504
get_segment fixed. and test_nogl rollback to 426. move!
kazz@henri.cr.ie.u-ryukyu.ac.jp
parents:
442
diff
changeset
|
472 return get_segment(addr, m, s->size); |
437 | 473 } |
474 | |
475 MemorySegment * | |
476 Scheduler::get_segment(memaddr addr, MemList *m, int size) | |
477 { | |
478 // memory segment のsizeをoverride する場合がある | |
386 | 479 MemorySegment *s = hash->get(addr); |
480 if (s) { | |
481 /* 既に load されている */ | |
439 | 482 // fprintf(stderr,"get_segement loaded %llx 0x%x size 0x%d\n",addr,s->data,size); |
391 | 483 m->moveToFirst(s); |
386 | 484 return s; |
485 } | |
486 | |
487 /* LRU なので、もっとも使われてない segment を上書きする */ | |
488 s = m->getLast(); | |
489 m->moveToFirst(s); | |
490 | |
491 memaddr old_addr = s->address; | |
387
5e2d30bfbf23
no compile error but not worked.
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
386
diff
changeset
|
492 s->tag = get_tag(); |
5e2d30bfbf23
no compile error but not worked.
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
386
diff
changeset
|
493 dma_load(s->data, addr, |
437 | 494 size, s->tag); |
386 | 495 /* 前のをhashから削除 */ |
496 hash->remove(old_addr); | |
497 /* 新しいaddress を登録 */ | |
498 s->address = addr; | |
499 hash->put(s->address, s); | |
500 | |
439 | 501 // fprintf(stderr,"get_segement %llx 0x%x size 0x%d\n",addr, s->data,size); |
502 | |
386 | 503 return s; |
504 } | |
505 | |
421
cd77224d4224
Code load implementation... (not yet tested)
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
403
diff
changeset
|
506 |
386 | 507 uint32 |
508 Scheduler::get_tag() | |
509 { | |
458 | 510 static int tag = 16; |
511 tag ++; | |
512 tag &= 0x0f; | |
513 return tag+16; | |
386 | 514 } |
515 | |
516 /*! | |
517 | |
518 Main Memory のSegmentを書き出す | |
519 Segment は get_segement されていて、 | |
520 追い出されていてはいけない。 | |
521 それを保証するのは難しい? | |
522 | |
523 @param [addr] Main Memory のアドレス | |
524 @param [m] Mem List | |
525 @return allocate した領域のポインタ | |
526 | |
527 */ | |
528 void | |
529 Scheduler::put_segment(MemorySegment *s) | |
530 { | |
387
5e2d30bfbf23
no compile error but not worked.
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
386
diff
changeset
|
531 dma_store(s->data, s->address, |
386 | 532 s->size, s->tag); |
533 } | |
534 | |
535 /*! | |
536 | |
537 Main Memory のSegmentを読込、書き出しを待つ | |
538 | |
539 @param [id] MemorySegment のid | |
540 | |
541 */ | |
542 void | |
387
5e2d30bfbf23
no compile error but not worked.
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
386
diff
changeset
|
543 Scheduler::wait_segment(MemorySegment *s) |
386 | 544 { |
391 | 545 // えーと、dma してない時には、skip しないとだめなんじゃないの? |
546 | |
547 if (s->tag) dma_wait(s->tag); | |
548 s->tag = 0; | |
386 | 549 } |
550 | |
551 /* end */ |