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