Mercurial > hg > Members > kono > Cerium
annotate TaskManager/kernel/schedule/Scheduler.cc @ 313:c9f8cfcdc5c2
fix ppu mail box waiting (mainMem allocate)
| author | kono@localhost.localdomain |
|---|---|
| date | Tue, 09 Jun 2009 00:10:36 +0900 |
| parents | bcb81858aa62 |
| children | b89ba1d96fff |
| 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++) { | |
| 28 buff_taskList[i] = (TaskListPtr)allocate(sizeof(TaskList)); | |
| 29 buff_inListData[i] = (ListDataPtr)allocate(sizeof(ListData)); | |
| 30 buff_outListData[i] = (ListDataPtr)allocate(sizeof(ListData)); | |
| 31 } | |
| 42 | 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++) { |
| 40 globalList[i] = NULL; | |
| 41 } | |
| 42 | |
| 43 for (int i = 0; i < MAX_MAINMEM_AREA; i++) { | |
| 44 mainMemList[i] = NULL; | |
| 45 } | |
| 46 | |
| 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 { | |
| 64 __debug("----------\n"); | |
| 65 task3->write(); | |
| 66 task2->exec(); | |
| 67 task1->read(); | |
| 68 | |
| 69 taskTmp = task3; | |
| 70 task3 = task2; | |
| 71 task2 = task1; | |
| 72 task1 = task1->next(this, taskTmp); | |
| 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) { | |
| 136 return renewCur_taskList; | |
| 137 } else { | |
| 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; | |
| 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) { | |
| 159 TaskListPtr list = renewTop_taskList; | |
| 160 renewTop_taskList = renewTop_taskList->next; | |
| 161 renewCur_taskList = NULL; | |
| 233 | 162 |
| 187 | 163 list->next = NULL; |
| 184 | 164 SchedTaskList *sched |
| 165 = createSchedTaskList((uint32)list, this, SCHED_TASKLIST_RENEW); | |
| 166 return sched; | |
| 167 } else { | |
| 168 return NULL; | |
| 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; |
| 194 | |
| 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 | |
| 300 Scheduler::global_free(int id) | |
| 301 { | |
| 302 free(globalList[id]); | |
| 303 globalList[id] = NULL; | |
| 304 } | |
| 305 | |
| 306 /** | |
| 298 | 307 * mainMem_alloc で確保したメインメモリの領域アドレスを返す。 |
| 308 * これは Fifo, Cell で共通 | |
| 109 | 309 */ |
| 310 void* | |
| 311 Scheduler::mainMem_get(int id) | |
| 312 { | |
| 313 return mainMemList[id]; | |
| 42 | 314 } |
| 315 | |
| 316 | |
| 109 | 317 /** |
| 298 | 318 * 本当は Scheduler クラスに入れるべきなんだろうか。。。 |
| 319 * なんか手抜きの感がある | |
| 109 | 320 */ |
| 321 void | |
| 322 register_task(int cmd, Scheduler::TaskObject task) | |
| 42 | 323 { |
| 109 | 324 task_list[cmd] = task; |
| 42 | 325 } |