Mercurial > hg > Members > kono > Cerium
annotate TaskManager/kernel/schedule/Scheduler.cc @ 386:6113af8f183b
MemHash...
| author | Shinji KONO <kono@ie.u-ryukyu.ac.jp> |
|---|---|
| date | Thu, 06 Aug 2009 19:31:51 +0900 |
| parents | eab18aa0c7f6 |
| children | 5e2d30bfbf23 |
| 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 { | |
| 26 init_impl(); | |
| 109 | 27 |
| 28 for (int i = 0; i < 2; i++) { | |
| 373 | 29 buff_taskList[i] = (TaskListPtr)allocate(sizeof(TaskList)); |
| 30 buff_inListData[i] = (ListDataPtr)allocate(sizeof(ListData)); | |
| 31 buff_outListData[i] = (ListDataPtr)allocate(sizeof(ListData)); | |
| 109 | 32 } |
| 373 | 33 |
| 109 | 34 buffFlag_taskList = 0; |
| 35 buffFlag_inListData = 0; | |
| 36 buffFlag_outListData = 0; | |
| 37 flag_renewTaskList = 0; | |
| 38 | |
| 298 | 39 // bzero でもいいけど |
| 109 | 40 for (int i = 0; i < MAX_GLOBAL_AREA; i++) { |
| 373 | 41 globalList[i] = NULL; |
| 109 | 42 } |
| 43 | |
| 44 for (int i = 0; i < MAX_MAINMEM_AREA; i++) { | |
| 373 | 45 mainMemList[i] = NULL; |
| 109 | 46 } |
| 373 | 47 |
| 109 | 48 |
| 49 taskGroup = new TaskGroup; | |
| 50 renewTop_taskList = NULL; | |
| 51 renewCur_taskList = NULL; | |
| 42 | 52 } |
| 53 | |
| 54 void | |
| 55 Scheduler::run(void) | |
| 56 { | |
| 57 SchedTaskBase* taskTmp; | |
| 109 | 58 |
| 42 | 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(); | |
| 42 | 69 |
| 373 | 70 taskTmp = task3; |
| 71 task3 = task2; | |
| 72 task2 = task1; | |
| 73 task1 = task1->next(this, taskTmp); | |
| 42 | 74 } while (task1); |
| 75 | |
| 76 delete task3; | |
| 77 delete task2; | |
| 50 | 78 } |
| 48 | 79 |
| 50 | 80 |
| 81 void | |
| 82 Scheduler::finish(void) | |
| 83 { | |
| 109 | 84 free(buff_taskList[0]); |
| 85 free(buff_taskList[1]); | |
| 86 free(buff_inListData[0]); | |
| 87 free(buff_inListData[1]); | |
| 88 free(buff_outListData[0]); | |
| 89 free(buff_outListData[1]); | |
| 42 | 90 } |
| 91 | |
| 109 | 92 /** |
| 298 | 93 * あらかじめ memory allocte してある TaskList の領域を |
| 94 * パイプラインの各処理が交代して使う。 | |
| 109 | 95 */ |
| 42 | 96 TaskListPtr |
| 97 Scheduler::get_curListBuf(void) | |
| 98 { | |
| 109 | 99 buffFlag_taskList ^= 1; |
| 100 | |
| 101 return buff_taskList[buffFlag_taskList]; | |
| 102 } | |
| 103 | |
| 104 | |
| 105 /** | |
| 298 | 106 * あらかじめ memory allocte してある ListData の領域を |
| 107 * パイプラインの各処理が交代して使う。 | |
| 109 | 108 */ |
| 109 ListDataPtr | |
| 110 Scheduler::get_curWriteBuf(void) | |
| 111 { | |
| 112 buffFlag_outListData ^= 1; | |
| 113 return buff_outListData[buffFlag_outListData]; | |
| 114 } | |
| 115 | |
| 116 | |
| 117 ListDataPtr | |
| 118 Scheduler::get_curReadBuf(void) | |
| 119 { | |
| 120 buffFlag_inListData ^= 1; | |
| 121 return buff_inListData[buffFlag_inListData]; | |
| 122 } | |
| 123 | |
| 124 /** | |
| 298 | 125 * タスク内で生成されたタスクを格納する TaskList を取得する |
| 126 * 現在格納に使っている TaskList (renewCur_taskList) が使えるならそれを返す | |
| 127 * もしそうでないなら、新しく TaskList を allocate してそれを返す | |
| 128 * コード中で renewCur_taskList が NULL になるのは | |
| 129 * - プログラム開始時 | |
| 130 * - タスク内生成タスクがある TaskList の実行を新しく始める (Nop2Ready 参照) | |
| 131 * 以上の場合です | |
| 109 | 132 */ |
| 133 TaskListPtr | |
| 134 Scheduler::get_renewListBuf(void) | |
| 135 { | |
| 136 if (renewCur_taskList && renewCur_taskList->length < TASK_MAX_SIZE) { | |
| 373 | 137 return renewCur_taskList; |
| 109 | 138 } else { |
| 373 | 139 TaskListPtr newList = (TaskListPtr)allocate(sizeof(TaskList)); |
| 140 newList->length = 0; | |
| 141 newList->next = NULL; | |
| 142 renewTop_taskList = TaskList::append(renewTop_taskList, newList); | |
| 143 renewCur_taskList = newList; | |
| 144 return newList; | |
| 109 | 145 } |
| 146 } | |
| 147 | |
| 184 | 148 /** |
| 298 | 149 * 次に実行する Renew Task List を返す |
| 184 | 150 * |
| 298 | 151 * @param[in] curList 現在実行中の TaskList |
| 152 * 中断して RenewTaskList を行うため | |
| 153 * バックアップを取っておく | |
| 184 | 154 * @return next RenewTaskList |
| 155 */ | |
| 156 SchedTaskList* | |
| 187 | 157 Scheduler::get_nextRenewTaskList(void) |
| 184 | 158 { |
| 159 if (renewTop_taskList) { | |
| 373 | 160 TaskListPtr list = renewTop_taskList; |
| 161 renewTop_taskList = renewTop_taskList->next; | |
| 162 renewCur_taskList = NULL; | |
| 233 | 163 |
| 373 | 164 list->next = NULL; |
| 165 SchedTaskList *sched | |
| 166 = createSchedTaskList((uint32)list, this, SCHED_TASKLIST_RENEW); | |
| 167 return sched; | |
| 184 | 168 } else { |
| 373 | 169 return NULL; |
| 184 | 170 } |
| 171 } | |
| 172 | |
| 187 | 173 void |
| 174 Scheduler::set_backupTaskList(TaskListPtr cur_taskList) | |
| 175 { | |
| 176 bak_curTaskList = cur_taskList; | |
| 177 } | |
| 178 | |
| 179 void | |
| 180 Scheduler::set_backupTaskListIndex(int cur_index) | |
| 181 { | |
| 182 bakIndex_taskList = cur_index; | |
| 183 } | |
| 184 | |
| 184 | 185 /** |
| 298 | 186 * RenewTaskList 実行前に中断した TaskList を返す |
| 187 * NULL の場合、中断した TaskList は無い。 | |
| 184 | 188 * |
| 189 * @return TaskList | |
| 190 */ | |
| 191 TaskListPtr | |
| 192 Scheduler::get_backupTaskList(void) | |
| 193 { | |
| 187 | 194 TaskListPtr ret = bak_curTaskList; |
| 373 | 195 |
| 187 | 196 bak_curTaskList = NULL; |
| 197 return ret; | |
| 198 } | |
| 199 | |
| 200 int | |
| 201 Scheduler::get_backupTaskListIndex(void) | |
| 202 { | |
| 203 int ret = bakIndex_taskList; | |
| 204 | |
| 205 bakIndex_taskList = 0; | |
| 206 return ret; | |
| 184 | 207 } |
| 208 | |
| 109 | 209 void |
| 210 Scheduler::dma_load(void *buf, uint32 addr, uint32 size, uint32 mask) | |
| 211 { | |
| 212 connector->dma_load(buf, addr, size, mask); | |
| 213 } | |
| 214 | |
| 215 void | |
| 216 Scheduler::dma_store(void *buf, uint32 addr, uint32 size, uint32 mask) | |
| 217 { | |
| 218 connector->dma_store(buf, addr, size, mask); | |
| 219 } | |
| 220 | |
| 221 void | |
| 222 Scheduler::dma_wait(uint32 mask) | |
| 223 { | |
| 224 connector->dma_wait(mask); | |
| 225 } | |
| 226 | |
| 227 void | |
| 228 Scheduler::dma_loadList(ListDataPtr list, void *buff, uint32 mask) | |
| 229 { | |
| 230 connector->dma_loadList(list, buff, mask); | |
| 42 | 231 } |
| 232 | |
| 233 | |
| 109 | 234 void |
| 235 Scheduler::dma_storeList(ListDataPtr list, void *buff, uint32 mask) | |
| 236 { | |
| 237 return connector->dma_storeList(list, buff, mask); | |
| 238 } | |
| 239 | |
| 240 void | |
| 241 Scheduler::mail_write(uint32 data) | |
| 242 { | |
| 243 connector->mail_write(data); | |
| 244 } | |
| 245 | |
| 246 uint32 | |
| 247 Scheduler::mail_read(void) | |
| 248 { | |
| 249 return connector->mail_read(); | |
| 250 } | |
| 251 | |
| 252 TaskGroupPtr | |
| 253 Scheduler::set_groupTask(uint32 command) | |
| 254 { | |
| 255 TaskGroupPtr ret = taskGroup; | |
| 256 | |
| 257 reload_groupTask(); | |
| 258 | |
| 259 ret->command = command; | |
| 260 return ret; | |
| 261 } | |
| 262 | |
| 263 void | |
| 264 Scheduler::add_groupTask(TaskGroupPtr group, TaskPtr task) | |
| 265 { | |
| 266 group->add(task); | |
| 267 } | |
| 268 | |
| 269 void | |
| 270 Scheduler::remove_groupTask(TaskGroupPtr group, TaskPtr task) | |
| 42 | 271 { |
| 109 | 272 group->remove(task); |
| 273 } | |
| 274 | |
| 275 void | |
| 276 Scheduler::reload_groupTask(void) | |
| 277 { | |
| 278 taskGroup = new TaskGroup; | |
| 279 } | |
| 280 | |
| 281 uint32 | |
| 282 Scheduler::status_groupTask(TaskGroupPtr group) | |
| 283 { | |
| 284 return group->status(); | |
| 285 } | |
| 286 | |
| 386 | 287 /* |
| 288 ここから下は、memory 以下にあるべき | |
| 289 */ | |
| 290 | |
| 109 | 291 void* |
| 292 Scheduler::global_alloc(int id, int size) | |
| 293 { | |
| 294 globalList[id] = allocate(size); | |
| 295 return globalList[id]; | |
| 296 } | |
| 297 | |
| 298 void* | |
| 299 Scheduler::global_get(int id) | |
| 300 { | |
| 301 return globalList[id]; | |
| 302 } | |
| 303 | |
| 304 void | |
| 373 | 305 Scheduler::global_set(int id, void *addr) |
| 306 { | |
| 307 globalList[id] = addr; | |
| 308 } | |
| 309 | |
| 310 void | |
| 109 | 311 Scheduler::global_free(int id) |
| 312 { | |
| 313 free(globalList[id]); | |
| 314 globalList[id] = NULL; | |
| 315 } | |
| 316 | |
| 317 /** | |
| 298 | 318 * mainMem_alloc で確保したメインメモリの領域アドレスを返す。 |
| 319 * これは Fifo, Cell で共通 | |
| 109 | 320 */ |
| 321 void* | |
| 322 Scheduler::mainMem_get(int id) | |
| 323 { | |
| 324 return mainMemList[id]; | |
| 42 | 325 } |
| 326 | |
| 327 | |
| 109 | 328 /** |
| 298 | 329 * 本当は Scheduler クラスに入れるべきなんだろうか。。。 |
| 330 * なんか手抜きの感がある | |
| 109 | 331 */ |
| 332 void | |
| 333 register_task(int cmd, Scheduler::TaskObject task) | |
| 42 | 334 { |
| 109 | 335 task_list[cmd] = task; |
| 42 | 336 } |
| 373 | 337 |
| 338 /*! | |
| 386 | 339 |
| 340 size 単位のMemory Segment を count 個作る | |
| 341 | |
| 373 | 342 @param [size] リストの要素１つのサイズ |
| 343 @param [count] 要素数 | |
| 344 @return allocate した領域のポインタ | |
| 345 | |
| 346 */ | |
| 347 MemList* | |
| 348 Scheduler::createMemList(int size, int count) | |
| 349 { | |
| 350 uint32 head_size = round_up16(sizeof(MemorySegment)); | |
| 351 uint32 seg_size = round_up16(head_size+size); | |
| 352 char* mseg = (char*)allocate(seg_size*count); | |
| 353 MemList* mlist = new MemList((MemorySegment*)mseg); | |
| 354 | |
| 355 for(int i = 0; i < count; i++) { | |
| 356 MemorySegment* next = (MemorySegment*)(mseg+seg_size*i); | |
| 357 char* data = (char*)next+head_size; | |
| 358 next->data = (void*)data; | |
| 386 | 359 next->size = size; |
| 373 | 360 mlist->addLast(next); |
| 361 } | |
| 362 | |
| 363 return mlist; | |
| 364 } | |
| 386 | 365 |
| 366 /*! | |
| 367 | |
| 368 Main Memory のSegmentを取得する | |
| 369 | |
| 370 @param [addr] Main Memory のアドレス | |
| 371 @param [m] Mem List | |
| 372 @return allocate した領域のポインタ | |
| 373 | |
| 374 memory directory にあるべきだが... | |
| 375 | |
| 376 */ | |
| 377 MemorySegement * | |
| 378 Scheduler::get_segment(memaddr addr, MemList *m) | |
| 379 { | |
| 380 MemorySegment *s = hash->get(addr); | |
| 381 if (s) { | |
| 382 /* 既に load されている */ | |
| 383 return s; | |
| 384 } | |
| 385 | |
| 386 /* LRU なので、もっとも使われてない segment を上書きする */ | |
| 387 s = m->getLast(); | |
| 388 m->moveToFirst(s); | |
| 389 | |
| 390 memaddr old_addr = s->address; | |
| 391 s->tag = getTag(); | |
| 392 smanager->dma_load(s->data, addr, | |
| 393 s->size, s->tag); | |
| 394 /* 前のをhashから削除 */ | |
| 395 hash->remove(old_addr); | |
| 396 /* 新しいaddress を登録 */ | |
| 397 s->address = addr; | |
| 398 hash->put(s->address, s); | |
| 399 | |
| 400 return s; | |
| 401 } | |
| 402 | |
| 403 uint32 | |
| 404 Scheduler::get_tag() | |
| 405 { | |
| 406 return 0; | |
| 407 } | |
| 408 | |
| 409 /*! | |
| 410 | |
| 411 Main Memory のSegmentを書き出す | |
| 412 Segment は get_segement されていて、 | |
| 413 追い出されていてはいけない。 | |
| 414 それを保証するのは難しい? | |
| 415 | |
| 416 @param [addr] Main Memory のアドレス | |
| 417 @param [m] Mem List | |
| 418 @return allocate した領域のポインタ | |
| 419 | |
| 420 */ | |
| 421 void | |
| 422 Scheduler::put_segment(MemorySegment *s) | |
| 423 { | |
| 424 smanager->dma_store(s->data, s->addr, | |
| 425 s->size, s->tag); | |
| 426 } | |
| 427 | |
| 428 /*! | |
| 429 | |
| 430 Main Memory のSegmentを読込、書き出しを待つ | |
| 431 | |
| 432 @param [id] MemorySegment のid | |
| 433 | |
| 434 */ | |
| 435 void | |
| 436 Scheduelr::wait_segment(MemorySegment *s) | |
| 437 { | |
| 438 smanager->dma_wait(s->tag); | |
| 439 } | |
| 440 | |
| 441 /* end */ |