Game/Cerium: TaskManager/kernel/schedule/SchedTask.cc comparison

comparison TaskManager/kernel/schedule/SchedTask.cc @ 483:5f4ffff2c2aa draft

renew task worked. but not test_nogl...

author	Shinji KONO <kono@ie.u-ryukyu.ac.jp>
date	Mon, 05 Oct 2009 20:29:28 +0900
parents	796f72cb21d9
children	3429986b8a28

comparison

equal deleted inserted replaced

-:314031ecd723
+:5f4ffff2c2aa
 }
 SchedTask::SchedTask()
 {
-__list        = NULL;
+list        = NULL;
-__task        = NULL;
+task        = NULL;
-__inListData  = NULL;
+inListData  = NULL;
-__outListData = NULL;
+outListData = NULL;
-__readbuf     = NULL;
+readbuf     = NULL;
-__writebuf    = NULL;
+writebuf    = NULL;
-__scheduler   = NULL;
+scheduler   = NULL;
-__taskGroup   = NULL;
+taskGroup   = NULL;
-__renew_flag  = 0;
+renew_flag  = 0;
-__cur_index   = 0;
+cur_index   = 0;
-__flag_renewTask = SCHED_TASK_NORMAL;
+flag_renewTask = SCHED_TASK_NORMAL;
 this->stdout_ = stdout;
 this->stderr_ = stderr;
 this->stdin_ = stdin;
 ex_init  = &SchedTask::ex_init_normal;
 }
 /**
 * dma_store の wait を行う
 * このタスクが RenewTask だった場合、
-* __inListData や __outListData は
+* inListData や outListData は
 * Scheduler の持つ、使い回しの buffer ではなく
 * 新たに allocate されたものなので、ここで free する
 */
 SchedTask::~SchedTask()
 {
-if (__flag_renewTask == SCHED_TASK_RENEW) {
+if (flag_renewTask == SCHED_TASK_RENEW) {
-free(__inListData);
+free(inListData);
-free(__outListData);
+free(outListData);
 /**
-* __list != NULL の場合、
+* list != NULL の場合、
-* この Task が __list の最後の Task になるので (SchedTask::next 参照)
+* この Task が list の最後の Task になるので (SchedTask::next 参照)
-* このタイミングで __list を解放する
+* このタイミングで list を解放する
 *   (free に渡されるアドレスが正しいものとなる)。
 * それ以外の Task では当然解放しない。
-*  __list == NULL なので、free に渡しても無問題
+*  list == NULL なので、free に渡しても無問題
 */
-free(__list);
+free(list);
 }
 }
 /**
 * このタスクを Renew Task とし、それに応じた関数をセットする
 */
 void
-SchedTask::__setRenew()
+SchedTask::setRenew()
 {
-__flag_renewTask = SCHED_TASK_RENEW;
+flag_renewTask = SCHED_TASK_RENEW;
 ex_init   = &SchedTask::ex_init_renew;
 ex_read   = &SchedTask::ex_read_renew;
 ex_exec   = &SchedTask::ex_exec_renew;
 ex_write  = &SchedTask::ex_write_renew;
 ex_next   = &SchedTask::ex_next_renew;
 }
 void
-SchedTask::__init__(TaskListPtr _list, TaskPtr _task, int index,
+SchedTask::init(TaskListPtr _list, TaskPtr _task, int index,
 ListDataPtr rbuf, ListDataPtr wbuf, Scheduler* sc)
 {
-__list        = _list;
+list        = _list;
-__task        = _task;
+task        = _task;
-__inListData  = rbuf;
+inListData  = rbuf;
-__outListData = wbuf;
+outListData = wbuf;
-__scheduler   = sc;
+scheduler   = sc;
-__cur_index   = index;
+cur_index   = index;
-__scheduler->mainMem_wait();
+scheduler->mainMem_wait();
 (this->*ex_init)();
 }
 /**
 * PPE 内で生成されたタスクの ex_init()
 */
 void
 SchedTask::ex_init_normal()
 {
-__scheduler->dma_load(__inListData, (uint32)__task->inData,
+scheduler->dma_load(inListData, (uint32)task->inData,
 sizeof(ListData), DMA_READ_IN_LIST);
-__scheduler->dma_load(__outListData, (uint32)__task->outData,
+scheduler->dma_load(outListData, (uint32)task->outData,
 sizeof(ListData), DMA_READ_OUT_LIST);
 #if defined(NO_PIPELINE)
-__scheduler->dma_wait(DMA_READ_IN_LIST);
+scheduler->dma_wait(DMA_READ_IN_LIST);
-__scheduler->dma_wait(DMA_READ_OUT_LIST);
+scheduler->dma_wait(DMA_READ_OUT_LIST);
 #endif
-__taskGroup = new TaskGroup;
+taskGroup = new TaskGroup;
-__taskGroup->command = __task->self;
+taskGroup->command = task->self;
 }
 /**
 * SPE 内で生成されたタスクの ex_init()
 * 各データは SPE 内の create_task 時に生成もしくは引き継がれているので
 * ex_init_normal() と違い、ここでは値を渡すだけ
 */
 void
 SchedTask::ex_init_renew()
 {
-__inListData = __task->inData;
+inListData = task->inData;
-__outListData = __task->outData;
+outListData = task->outData;
-__taskGroup = (TaskGroupPtr)__task->self;
+taskGroup = (TaskGroupPtr)task->self;
 }
 /**
 * [Todo]
 *   データの読み込み場所を readbuf ではなく、
 SchedTask::read()
 {
 __debug("[SchedTask:%s]\n", __FUNCTION__);
 #if !defined(NO_PIPELINE)
-__scheduler->dma_wait(DMA_READ_IN_LIST);
+scheduler->dma_wait(DMA_READ_IN_LIST);
-__scheduler->dma_wait(DMA_READ_OUT_LIST);
+scheduler->dma_wait(DMA_READ_OUT_LIST);
 #endif
-__writebuf = __scheduler->allocate(__outListData->size);
+writebuf = scheduler->allocate(outListData->size);
 // 読むデータが一つもなければ無視
-if (__inListData->length == 0) return;
+if (inListData->length == 0) return;
 // load Input Data
-__readbuf = __scheduler->allocate(__inListData->size);
+readbuf = scheduler->allocate(inListData->size);
-__scheduler->dma_loadList(__inListData, __readbuf, DMA_READ);
+scheduler->dma_loadList(inListData, readbuf, DMA_READ);
 #if defined(NO_PIPELINE)
-__scheduler->dma_wait(DMA_READ);
+scheduler->dma_wait(DMA_READ);
 #endif
 (this->*ex_read)();
 }
 SchedTask::exec()
 {
 __debug("[SchedTask:%s]\n", __FUNCTION__);
 #if !defined(NO_PIPELINE)
-__scheduler->dma_wait(DMA_READ);
+scheduler->dma_wait(DMA_READ);
-task_list[__task->command].wait(__scheduler,__task->command);
+task_list[task->command].wait(scheduler,task->command);
 #endif
-task_list[__task->command].run(this, __readbuf, __writebuf);
+task_list[task->command].run(this, readbuf, writebuf);
-free(__readbuf);
+free(readbuf);
-if (__taskGroup->status() != 0) {
+if (taskGroup->status() != 0) {
-__task->self = __taskGroup->command;
+task->self = taskGroup->command;
-delete __taskGroup;
+delete taskGroup;
-__taskGroup = NULL;
+taskGroup = NULL;
 }
 // 書き込む領域がなければ無視
-if (__outListData->length > 0) {
+if (outListData->length > 0) {
-__scheduler->dma_storeList(__outListData, __writebuf, DMA_WRITE);
+scheduler->dma_storeList(outListData, writebuf, DMA_WRITE);
 #if defined(NO_PIPELINE)
-__scheduler->dma_wait(DMA_WRITE);
+scheduler->dma_wait(DMA_WRITE);
-free(__writebuf);
+free(writebuf);
 #endif
 }
 (this->*ex_exec)();
 }
 SchedTask::write()
 {
 __debug("[SchedTask:%s]\n", __FUNCTION__);
 #if !defined(NO_PIPELINE)
-__scheduler->dma_wait(DMA_WRITE);
+scheduler->dma_wait(DMA_WRITE);
-free(__writebuf);
+free(writebuf);
 #endif
-if (__task->self == MY_SPE_NOP) return;
+if (task->self == MY_SPE_NOP) return;
 (this->*ex_write)();
 }
 /**
 {
 /**
 * このタスク内で新たにタスクが生成されなかった
 * or 生成されたが、そのタスクの終了を待つ必要は無い
 */
-if (__renew_flag == 0) {
+if (renew_flag == 0) {
-__scheduler->mail_write(__task->self);
+scheduler->mail_write(task->self);
 }
 }
 /**
 * SPE 内で生成されたタスクの ex_write()
 void
 SchedTask::ex_write_renew()
 {
 uint32 cmd;
-__taskGroup->remove(__task);
+taskGroup->remove(task);
-cmd = __taskGroup->status();
+cmd = taskGroup->status();
 // タスク内で作られた全てのタスクが終了した
 if (cmd != 0) {
-delete __taskGroup;
+delete taskGroup;
-__scheduler->mail_write(cmd);
+scheduler->mail_write(cmd);
 }
 }
 SchedTaskBase*
 SchedTask::next(Scheduler *scheduler, SchedTaskBase *p)
 }
 SchedTaskBase*
 SchedTask::ex_next_normal()
 {
-if (__cur_index < __list->length) {
+if (cur_index < list->length) {
 SchedTaskBase *nextSched;
-nextSched = __scheduler->get_nextRenewTaskList();
+nextSched = scheduler->get_nextRenewTaskList();
 // RenewTask がある
 if (nextSched) {
-__scheduler->set_backupTaskList(__list);
+scheduler->set_backupTaskList(list);
-__scheduler->set_backupTaskListIndex(__cur_index);
+scheduler->set_backupTaskListIndex(cur_index);
 return nextSched;
 } else {
-TaskPtr nextTask = &__list->tasks[__cur_index++];
+TaskPtr nextTask = &list->tasks[cur_index++];
-	    if (__cur_index < __list->length) {
+	    if (cur_index < list->length) {
 		// load next task
-		loadSchedTask(__scheduler, &__list->tasks[__cur_index]);
+		loadSchedTask(scheduler, &list->tasks[cur_index]);
 	    }
-nextSched = createSchedTask(__scheduler, nextTask);
+nextSched = createSchedTask(scheduler, nextTask);
-((SchedTask*)nextSched)->__init__(__list, nextTask, __cur_index,
+((SchedTask*)nextSched)->init(list, nextTask, cur_index,
-__scheduler->get_curReadBuf(),
+scheduler->get_curReadBuf(),
-__scheduler->get_curWriteBuf(),
+scheduler->get_curWriteBuf(),
-__scheduler);
+scheduler);
 return nextSched;
 }
 } else {
-uint32 nextList = (uint32)__list->next;
+uint32 nextList = (uint32)list->next;
 if (nextList == 0) {
-return new SchedNop2Ready(__scheduler);
+return new SchedNop2Ready(scheduler);
 } else {
-return createSchedTaskList(nextList, __scheduler,
+return createSchedTaskList(nextList, scheduler,
 SCHED_TASKLIST_NORMAL);
 }
 }
 }
 SchedTask::ex_next_renew()
 {
 TaskPtr nextTask;
 SchedTask *nextSched;
-if (__cur_index < __list->length) {
+if (cur_index < list->length) {
-nextTask = &__list->tasks[__cur_index++];
+nextTask = &list->tasks[cur_index++];
-	if (__cur_index < __list->length) {
+	if (cur_index < list->length) {
 	    // load next task
-	    loadSchedTask(__scheduler, &__list->tasks[__cur_index]);
+	    loadSchedTask(scheduler, &list->tasks[cur_index]);
 	}
-nextSched = createSchedTask(__scheduler, nextTask);
+nextSched = createSchedTask(scheduler, nextTask);
 // RenewTaskList を実行中なので
-nextSched->__setRenew();
+nextSched->setRenew();
-nextSched->__init__(__list, nextTask, __cur_index,
+nextSched->init(list, nextTask, cur_index,
-__scheduler->get_curReadBuf(),
+scheduler->get_curReadBuf(),
-__scheduler->get_curWriteBuf(),
+scheduler->get_curWriteBuf(),
-__scheduler);
+scheduler);
 /**
 * この理由は SchedTask:~SchedTask() で
 */
-__list = NULL;
+list = NULL;
 return nextSched;
 } else {
 SchedTaskBase *nextList;
-nextList = __scheduler->get_nextRenewTaskList();
+nextList = scheduler->get_nextRenewTaskList();
 if (nextList) {
 return nextList;
 } else {
-TaskListPtr nextList = __scheduler->get_backupTaskList();
+TaskListPtr nextList = scheduler->get_backupTaskList();
 // 中断した TaskList がある
 if (nextList) {
-__cur_index = __scheduler->get_backupTaskListIndex();
+cur_index = scheduler->get_backupTaskListIndex();
-nextTask = &nextList->tasks[__cur_index++];
+nextTask = &nextList->tasks[cur_index++];
-		if (__cur_index < __list->length) {
+		if (cur_index < list->length) {
 		    // load next task
-		    loadSchedTask(__scheduler, &__list->tasks[__cur_index]);
+		    loadSchedTask(scheduler, &list->tasks[cur_index]);
 		}
-nextSched = createSchedTask(__scheduler, nextTask);
+nextSched = createSchedTask(scheduler, nextTask);
-nextSched->__init__(nextList, nextTask, __cur_index,
+nextSched->init(nextList, nextTask, cur_index,
-__scheduler->get_curReadBuf(),
+scheduler->get_curReadBuf(),
-__scheduler->get_curWriteBuf(),
+scheduler->get_curWriteBuf(),
-__scheduler);
+scheduler);
 return nextSched;
 } else {
-return new SchedNop2Ready(__scheduler);
+return new SchedNop2Ready(scheduler);
 }
 }
 }
 }
 int
 SchedTask::get_cpuid()
 {
-return __scheduler->id;
+return scheduler->id;
 }
 /**
 * task->add_inData で与えられた順番に対応する index (0〜n-1) で、
 * buffer から対応するデータを返す。
 */
 void*
 SchedTask::get_input(void *buff, int index)
 {
 if (buff != NULL) {
-return (void*)((int)buff + __inListData->bound[index]);
+return (void*)((int)buff + inListData->bound[index]);
 } else {
 return NULL;
 }
 }
 * get_input(index) のアドレスを返す
 */
 uint32
 SchedTask::get_inputAddr(int index)
 {
-return __inListData->element[index].addr;
+return inListData->element[index].addr;
 }
 /**
 * get_input(index) のサイズを返す
 */
 int
 SchedTask::get_inputSize(int index)
 {
-return __inListData->element[index].size;
+return inListData->element[index].size;
 }
 /**
 * write buffer の領域を返す。
 */
 void*
 SchedTask::get_output(void *buff, int index)
 {
 if (buff != NULL) {
-return (void*)((int)buff + __outListData->bound[index]);
+return (void*)((int)buff + outListData->bound[index]);
 } else {
 return NULL;
 }
 }
 * get_output(index) のアドレスを返す
 */
 uint32
 SchedTask::get_outputAddr(int index)
 {
-return __outListData->element[index].addr;
+return outListData->element[index].addr;
 }
 /**
 * get_output(index) のサイズを返す
 */
 int
 SchedTask::get_outputSize(int index)
 {
-return __outListData->element[index].size;
+return outListData->element[index].size;
 }
 int
 SchedTask::get_param(int index)
 {
-return __task->param[index];
+return task->param[index];
 }
 TaskPtr
 SchedTask::create_task(int cmd)
 {
-TaskListPtr taskList = __scheduler->get_renewListBuf();
+TaskListPtr taskList = scheduler->get_renewListBuf();
 TaskPtr p = &taskList->tasks[taskList->length++];
 p->command = cmd;
-p->inData = (ListData*)__scheduler->allocate(sizeof(ListData));
+p->inData = (ListData*)scheduler->allocate(sizeof(ListData));
-p->outData = (ListData*)__scheduler->allocate(sizeof(ListData));
+p->outData = (ListData*)scheduler->allocate(sizeof(ListData));
 p->inData->clear();
 p->outData->clear();
 p->self = MY_SPE_NOP;
 return p;
 }
 /**
-* 生成したタスクが終了してから、メインスケジューラ(PPE) に
-* タスクが終了した旨を知らせる。
 *
-* @param[in] waitTask タスク内で生成したタスク
+* @param[in] waitTask タスク内で生成したタスクの登録(spawn()に相当)
 */
 void
 SchedTask::wait_task(TaskPtr waitTask)
 {
-waitTask->self = (uint32)__taskGroup;
+waitTask->self = (uint32)taskGroup;
-__scheduler->add_groupTask(__taskGroup, waitTask);
+scheduler->add_groupTask(taskGroup, waitTask);
-__renew_flag++;
+renew_flag++;
 }
 void*
 SchedTask::global_alloc(int id, int size) {
-return __scheduler->global_alloc(id, size);
+return scheduler->global_alloc(id, size);
 }
 void*
 SchedTask::global_get(int id) {
-return __scheduler->global_get(id);
+return scheduler->global_get(id);
 }
 void
 SchedTask::global_set(int id, void *addr) {
-__scheduler->global_set(id, addr);
+scheduler->global_set(id, addr);
 }
 void
 SchedTask::global_free(int id) {
-__scheduler->global_free(id);
+scheduler->global_free(id);
 }
 MemList*
 SchedTask::createMemList(int size, int count) {
-return __scheduler->createMemList(size, count);
+return scheduler->createMemList(size, count);
 }
 void
 SchedTask::mainMem_alloc(int id, int size) {
-__scheduler->mainMem_alloc(id, size);
+scheduler->mainMem_alloc(id, size);
 }
 void
 SchedTask::mainMem_wait() {
-__scheduler->mainMem_wait();
+scheduler->mainMem_wait();
 }
 void*
 SchedTask::mainMem_get(int id) {
-return __scheduler->mainMem_get(id);
+return scheduler->mainMem_get(id);
 }
 void*
 SchedTask::allocate(int size) {
-return __scheduler->allocate(size);
+return scheduler->allocate(size);
 }
 void
 SchedTask::dma_load(void *buf, uint32 addr, uint32 size, uint32 mask) {
-__scheduler->dma_load(buf, addr, size, mask);
+scheduler->dma_load(buf, addr, size, mask);
 }
 void
 SchedTask::dma_store(void *buf,uint32 addr, uint32 size, uint32 mask) {
-__scheduler->dma_store(buf, addr, size, mask);
+scheduler->dma_store(buf, addr, size, mask);
 }
 void
 SchedTask::dma_wait(uint32 mask) {
-__scheduler->dma_wait(mask);
+scheduler->dma_wait(mask);
 }
 void
 SchedTask::show_dma_wait() {
-__scheduler->show_dma_wait();
+scheduler->show_dma_wait();
 }
 MemorySegment * SchedTask::get_segment(memaddr addr, MemList *m) {
-return __scheduler->get_segment(addr,m);
+return scheduler->get_segment(addr,m);
 }
 void SchedTask::put_segment(MemorySegment *s) {
-__scheduler->put_segment(s);
+scheduler->put_segment(s);
 }
 void SchedTask::wait_segment(MemorySegment *s) {
-__scheduler->wait_segment(s);
+scheduler->wait_segment(s);
 }
 /* system call */
 int

Mercurial > hg > Game > Cerium

comparison TaskManager/kernel/schedule/SchedTask.cc @ 483:5f4ffff2c2aa draft