Mercurial > hg > Members > kono > Cerium
annotate TaskManager/kernel/schedule/Scheduler.cc @ 468:bd5b93d39597
test_nogl on Mac OS X worked.
| author | Shinji KONO <kono@ie.u-ryukyu.ac.jp> |
|---|---|
| date | Fri, 02 Oct 2009 16:40:43 +0900 |
| parents | 01b321c86747 |
| children | 0b933bef0328 |
| 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 | |
| 15 Scheduler::~Scheduler(void) | |
| 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 |
| 24 Scheduler::init(void) | |
| 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)); |
| 31 buff_inListData[i] = (ListDataPtr)allocate(sizeof(ListData)); | |
| 32 buff_outListData[i] = (ListDataPtr)allocate(sizeof(ListData)); | |
| 109 | 33 } |
| 373 | 34 |
| 109 | 35 buffFlag_taskList = 0; |
| 36 buffFlag_inListData = 0; | |
| 37 buffFlag_outListData = 0; | |
| 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; | |
| 42 | 53 } |
| 54 | |
| 55 void | |
| 56 Scheduler::run(void) | |
| 57 { | |
| 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(); | |
|
468
bd5b93d39597
test_nogl on Mac OS X worked.
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
464
diff
changeset
|
68 delete task3; |
| 42 | 69 |
| 373 | 70 task3 = task2; |
| 71 task2 = task1; | |
|
468
bd5b93d39597
test_nogl on Mac OS X worked.
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
464
diff
changeset
|
72 task1 = task1->next(this, 0); |
| 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 | |
| 386 | 286 /* |
| 287 ここから下は、memory 以下にあるべき | |
| 288 */ | |
| 289 | |
| 109 | 290 void* |
| 291 Scheduler::global_alloc(int id, int size) | |
| 292 { | |
| 293 globalList[id] = allocate(size); | |
| 294 return globalList[id]; | |
| 295 } | |
| 296 | |
| 297 void* | |
| 298 Scheduler::global_get(int id) | |
| 299 { | |
| 300 return globalList[id]; | |
| 301 } | |
| 302 | |
| 303 void | |
| 373 | 304 Scheduler::global_set(int id, void *addr) |
| 305 { | |
| 306 globalList[id] = addr; | |
| 307 } | |
| 308 | |
| 309 void | |
| 109 | 310 Scheduler::global_free(int id) |
| 311 { | |
| 312 free(globalList[id]); | |
| 313 globalList[id] = NULL; | |
| 314 } | |
| 315 | |
| 316 /** | |
| 298 | 317 * mainMem_alloc で確保したメインメモリの領域アドレスを返す。 |
| 318 * これは Fifo, Cell で共通 | |
| 109 | 319 */ |
| 320 void* | |
| 321 Scheduler::mainMem_get(int id) | |
| 322 { | |
| 323 return mainMemList[id]; | |
| 42 | 324 } |
| 325 | |
|
421
cd77224d4224
Code load implementation... (not yet tested)
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
403
diff
changeset
|
326 /** |
|
cd77224d4224
Code load implementation... (not yet tested)
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
403
diff
changeset
|
327 * Task load API |
|
cd77224d4224
Code load implementation... (not yet tested)
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
403
diff
changeset
|
328 */ |
| 425 | 329 void |
| 442 | 330 Scheduler::allocate_code_segment(int size, int count) |
| 425 | 331 { |
| 437 | 332 // 既に overlay 領域があるので、それを追加する必要がある... |
| 442 | 333 code_segment_pool = createMemList(size, count); |
| 425 | 334 } |
| 42 | 335 |
|
421
cd77224d4224
Code load implementation... (not yet tested)
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
403
diff
changeset
|
336 static void |
|
cd77224d4224
Code load implementation... (not yet tested)
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
403
diff
changeset
|
337 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
|
338 { |
|
cd77224d4224
Code load implementation... (not yet tested)
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
403
diff
changeset
|
339 MemorySegment *s = m->get_segment( |
|
cd77224d4224
Code load implementation... (not yet tested)
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
403
diff
changeset
|
340 task_list[task_id].location, |
| 437 | 341 m->code_segment_pool, |
| 342 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
|
343 task_list[task_id].segment = s; |
| 461 | 344 |
| 345 fprintf(stderr,"loadng task id %d at 0x%x entry 0x%x\n",task_id, | |
| 346 (unsigned int)(task_list[task_id].segment->data ), | |
| 347 (unsigned int)( | |
| 348 (char*)task_list[task_id].segment->data + | |
| 349 task_list[task_id].entry_offset)); | |
|
421
cd77224d4224
Code load implementation... (not yet tested)
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
403
diff
changeset
|
350 } |
|
cd77224d4224
Code load implementation... (not yet tested)
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
403
diff
changeset
|
351 |
|
cd77224d4224
Code load implementation... (not yet tested)
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
403
diff
changeset
|
352 static void |
|
cd77224d4224
Code load implementation... (not yet tested)
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
403
diff
changeset
|
353 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
|
354 { |
|
cd77224d4224
Code load implementation... (not yet tested)
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
403
diff
changeset
|
355 } |
|
cd77224d4224
Code load implementation... (not yet tested)
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
403
diff
changeset
|
356 |
|
cd77224d4224
Code load implementation... (not yet tested)
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
403
diff
changeset
|
357 static void |
|
cd77224d4224
Code load implementation... (not yet tested)
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
403
diff
changeset
|
358 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
|
359 { |
| 442 | 360 MemorySegment *s = task_list[task_id].segment; |
| 361 if (s) | |
| 362 fprintf(stderr,"wait load task id %d 0x%x\n",task_id,(int)s->data); | |
| 363 else | |
| 364 fprintf(stderr,"wait load task id %d 000000\n",task_id); | |
|
421
cd77224d4224
Code load implementation... (not yet tested)
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
403
diff
changeset
|
365 // wait for code segment load |
|
cd77224d4224
Code load implementation... (not yet tested)
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
403
diff
changeset
|
366 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
|
367 // calcurate call address |
|
464
01b321c86747
task run is mere C function now.
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
461
diff
changeset
|
368 TaskObjectRun run = |
|
01b321c86747
task run is mere C function now.
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
461
diff
changeset
|
369 (TaskObjectRun)( |
|
421
cd77224d4224
Code load implementation... (not yet tested)
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
403
diff
changeset
|
370 (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
|
371 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
|
372 task_list[task_id].run = run; |
| 439 | 373 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
|
374 (unsigned int)run, |
| 439 | 375 task_list[task_id].entry_offset); |
|
421
cd77224d4224
Code load implementation... (not yet tested)
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
403
diff
changeset
|
376 } |
|
cd77224d4224
Code load implementation... (not yet tested)
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
403
diff
changeset
|
377 |
|
cd77224d4224
Code load implementation... (not yet tested)
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
403
diff
changeset
|
378 static void |
|
cd77224d4224
Code load implementation... (not yet tested)
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
403
diff
changeset
|
379 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
|
380 { |
|
cd77224d4224
Code load implementation... (not yet tested)
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
403
diff
changeset
|
381 } |
|
cd77224d4224
Code load implementation... (not yet tested)
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
403
diff
changeset
|
382 |
|
cd77224d4224
Code load implementation... (not yet tested)
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
403
diff
changeset
|
383 extern void |
|
464
01b321c86747
task run is mere C function now.
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
461
diff
changeset
|
384 register_task(int cmd, TaskObjectRun run) |
| 42 | 385 { |
|
464
01b321c86747
task run is mere C function now.
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
461
diff
changeset
|
386 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
|
387 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
|
388 task_list[cmd].wait = null_waiter; |
| 42 | 389 } |
| 373 | 390 |
|
421
cd77224d4224
Code load implementation... (not yet tested)
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
403
diff
changeset
|
391 extern void |
|
cd77224d4224
Code load implementation... (not yet tested)
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
403
diff
changeset
|
392 register_dynamic_task(int cmd, |
| 441 | 393 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
|
394 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
|
395 { |
|
464
01b321c86747
task run is mere C function now.
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
461
diff
changeset
|
396 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
|
397 task_list[cmd].location = start; |
| 442 | 398 size &= 0xfffffffe; |
| 441 | 399 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
|
400 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
|
401 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
|
402 task_list[cmd].wait = wait_load; |
| 439 | 403 fprintf(stderr,"cmd = %d\n",cmd); |
| 441 | 404 fprintf(stderr,"locatation = 0x%x\n",start); |
| 405 fprintf(stderr,"end = 0x%x\n",start+size); | |
| 406 fprintf(stderr,"size = 0x%x\n",size); | |
| 439 | 407 fprintf(stderr,"entry = 0x%x\n",entry_offset); |
| 408 | |
|
421
cd77224d4224
Code load implementation... (not yet tested)
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
403
diff
changeset
|
409 } |
|
cd77224d4224
Code load implementation... (not yet tested)
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
403
diff
changeset
|
410 |
|
cd77224d4224
Code load implementation... (not yet tested)
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
403
diff
changeset
|
411 |
| 373 | 412 /*! |
| 386 | 413 |
| 414 size 単位のMemory Segment を count 個作る | |
| 415 | |
| 373 | 416 @param [size] リストの要素１つのサイズ |
| 417 @param [count] 要素数 | |
| 418 @return allocate した領域のポインタ | |
| 419 | |
| 420 */ | |
| 421 MemList* | |
| 422 Scheduler::createMemList(int size, int count) | |
| 423 { | |
| 424 uint32 head_size = round_up16(sizeof(MemorySegment)); | |
| 425 uint32 seg_size = round_up16(head_size+size); | |
| 426 char* mseg = (char*)allocate(seg_size*count); | |
| 427 MemList* mlist = new MemList((MemorySegment*)mseg); | |
| 428 | |
|
388
82cb9368e3ff
MemHash (OS X version)
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
387
diff
changeset
|
429 if (!hash) { |
|
82cb9368e3ff
MemHash (OS X version)
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
387
diff
changeset
|
430 hash = new MemHash(); |
|
82cb9368e3ff
MemHash (OS X version)
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
387
diff
changeset
|
431 } |
|
82cb9368e3ff
MemHash (OS X version)
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
387
diff
changeset
|
432 |
| 373 | 433 for(int i = 0; i < count; i++) { |
| 434 MemorySegment* next = (MemorySegment*)(mseg+seg_size*i); | |
| 435 char* data = (char*)next+head_size; | |
| 436 next->data = (void*)data; | |
| 386 | 437 next->size = size; |
| 395 | 438 next->address = (memaddr)next; |
| 373 | 439 mlist->addLast(next); |
| 440 } | |
| 441 | |
| 442 return mlist; | |
| 443 } | |
| 386 | 444 |
| 445 /*! | |
| 446 | |
| 447 Main Memory のSegmentを取得する | |
| 448 | |
| 449 @param [addr] Main Memory のアドレス | |
| 450 @param [m] Mem List | |
| 451 @return allocate した領域のポインタ | |
| 452 memory directory にあるべきだが... | |
| 453 | |
| 454 */ | |
|
387
5e2d30bfbf23
no compile error but not worked.
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
386
diff
changeset
|
455 MemorySegment * |
| 386 | 456 Scheduler::get_segment(memaddr addr, MemList *m) |
| 457 { | |
|
449
4f11245e3504
get_segment fixed. and test_nogl rollback to 426. move!
kazz@henri.cr.ie.u-ryukyu.ac.jp
parents:
442
diff
changeset
|
458 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
|
459 return get_segment(addr, m, s->size); |
| 437 | 460 } |
| 461 | |
| 462 MemorySegment * | |
| 463 Scheduler::get_segment(memaddr addr, MemList *m, int size) | |
| 464 { | |
| 465 // memory segment のsizeをoverride する場合がある | |
| 386 | 466 MemorySegment *s = hash->get(addr); |
| 467 if (s) { | |
| 468 /* 既に load されている */ | |
| 439 | 469 // fprintf(stderr,"get_segement loaded %llx 0x%x size 0x%d\n",addr,s->data,size); |
| 391 | 470 m->moveToFirst(s); |
| 386 | 471 return s; |
| 472 } | |
| 473 | |
| 474 /* LRU なので、もっとも使われてない segment を上書きする */ | |
| 475 s = m->getLast(); | |
| 476 m->moveToFirst(s); | |
| 477 | |
| 478 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
|
479 s->tag = get_tag(); |
|
5e2d30bfbf23
no compile error but not worked.
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
386
diff
changeset
|
480 dma_load(s->data, addr, |
| 437 | 481 size, s->tag); |
| 386 | 482 /* 前のをhashから削除 */ |
| 483 hash->remove(old_addr); | |
| 484 /* 新しいaddress を登録 */ | |
| 485 s->address = addr; | |
| 486 hash->put(s->address, s); | |
| 487 | |
| 439 | 488 // fprintf(stderr,"get_segement %llx 0x%x size 0x%d\n",addr, s->data,size); |
| 489 | |
| 386 | 490 return s; |
| 491 } | |
| 492 | |
|
421
cd77224d4224
Code load implementation... (not yet tested)
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
403
diff
changeset
|
493 |
| 386 | 494 uint32 |
| 495 Scheduler::get_tag() | |
| 496 { | |
| 458 | 497 static int tag = 16; |
| 498 tag ++; | |
| 499 tag &= 0x0f; | |
| 500 return tag+16; | |
| 386 | 501 } |
| 502 | |
| 503 /*! | |
| 504 | |
| 505 Main Memory のSegmentを書き出す | |
| 506 Segment は get_segement されていて、 | |
| 507 追い出されていてはいけない。 | |
| 508 それを保証するのは難しい? | |
| 509 | |
| 510 @param [addr] Main Memory のアドレス | |
| 511 @param [m] Mem List | |
| 512 @return allocate した領域のポインタ | |
| 513 | |
| 514 */ | |
| 515 void | |
| 516 Scheduler::put_segment(MemorySegment *s) | |
| 517 { | |
|
387
5e2d30bfbf23
no compile error but not worked.
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
386
diff
changeset
|
518 dma_store(s->data, s->address, |
| 386 | 519 s->size, s->tag); |
| 520 } | |
| 521 | |
| 522 /*! | |
| 523 | |
| 524 Main Memory のSegmentを読込、書き出しを待つ | |
| 525 | |
| 526 @param [id] MemorySegment のid | |
| 527 | |
| 528 */ | |
| 529 void | |
|
387
5e2d30bfbf23
no compile error but not worked.
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
386
diff
changeset
|
530 Scheduler::wait_segment(MemorySegment *s) |
| 386 | 531 { |
| 391 | 532 // えーと、dma してない時には、skip しないとだめなんじゃないの? |
| 533 | |
| 534 if (s->tag) dma_wait(s->tag); | |
| 535 s->tag = 0; | |
| 386 | 536 } |
| 537 | |
| 538 /* end */ |