--- a/TaskManager/kernel/schedule/SchedTask.cc	Sat Nov 14 21:17:02 2009 +0900
+++ b/TaskManager/kernel/schedule/SchedTask.cc	Sun Nov 15 02:02:30 2009 +0900
@@ -10,8 +10,6 @@
 
 extern Scheduler::TaskObject task_list[MAX_TASK_OBJECT];
 
-//#define NO_PIPELINE
-
 /**
    Task Object を作る
  */
@@ -46,19 +44,11 @@
     readbuf     = NULL;
     writebuf    = NULL;
     scheduler   = NULL;
-    taskGroup   = NULL;
-    renew_flag  = 0;
     cur_index   = 0;
-    flag_renewTask = SCHED_TASK_NORMAL;
     this->stdout_ = stdout;
     this->stderr_ = stderr;
     this->stdin_ = stdin;
 
-    ex_init  = &SchedTask::ex_init_normal;
-    ex_read  = &SchedTask::ex_read_normal;
-    ex_exec  = &SchedTask::ex_exec_normal;
-    ex_write = &SchedTask::ex_write_normal;
-    ex_next  = &SchedTask::ex_next_normal;
 
 }
 
@@ -67,35 +57,8 @@
  */
 SchedTask::~SchedTask()
 {
-    if (flag_renewTask == SCHED_TASK_RENEW) {
-        /**
-         * list != NULL の場合、
-         * この Task が list の最後の Task になるので (SchedTask::next 参照)
-         * このタイミングで list を解放する
-         *   (free に渡されるアドレスが正しいものとなる)。
-         * それ以外の Task では当然解放しない。
-         *  list == NULL なので、free に渡しても無問題
-         */
-        free(list);
-    }
-
-
 }
 
-/**
- * このタスクを Renew Task とし、それに応じた関数をセットする
- */
-void
-SchedTask::setRenew()
-{
-    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,
@@ -111,56 +74,14 @@
 
     scheduler->mainMem_wait();
 
-    (this->*ex_init)();
 }
 
-/**
- * PPE 内で生成されたタスクの ex_init()
- */
-void
-SchedTask::ex_init_normal()
-{
-#if 0
-    // task list に入れたので既に読んでいる?
-    //
-    scheduler->dma_load(inListData, (uint32)&task->inData,
-                          sizeof(ListData), DMA_READ_IN_LIST);
-    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_OUT_LIST);
-#endif
-#endif
-
-    taskGroup = new TaskGroup;
-    taskGroup->command = (int)task->self;
-}
-
-/**
- * SPE 内で生成されたタスクの ex_init()
- * 各データは SPE 内の create_task 時に生成もしくは引き継がれているので
- * ex_init_normal() と違い、ここでは値を渡すだけ
- */
-void
-SchedTask::ex_init_renew()
-{
-    inListData = &task->inData;
-    outListData = &task->outData;
-    taskGroup = (TaskGroupPtr)task->self;
-}
 
 void
 SchedTask::read()
 {
     __debug("[SchedTask:%s]\n", __FUNCTION__);
 
-#if 0
-#if !defined(NO_PIPELINE)
-    scheduler->dma_wait(DMA_READ_IN_LIST);
-    scheduler->dma_wait(DMA_READ_OUT_LIST);
-#endif
-#endif
     // object creation をSchedTask生成時にやらないので、
     // exec の直前のread で十分に間に合う
     if (cur_index < list->length) {
@@ -177,61 +98,24 @@
     readbuf = scheduler->allocate(inListData->size);
     scheduler->dma_loadList(inListData, readbuf, DMA_READ);
 
-#if defined(NO_PIPELINE)
-    scheduler->dma_wait(DMA_READ);
-#endif
 
-    (this->*ex_read)();
 }
 
-/**
- * PPE 内で生成されたタスクの ex_read()
- *
- * [Todo]
- *   データの読み込み場所を readbuf ではなく、
- *   ユーザ自身で決めれるようになるといいかもしれない。
- *
- *   # TaskManager が勝手に消すことなく、
- *   # ユーザが SPE 上に持ち続けることができるため。
- *   # もちろん管理はユーザに任せるわけだ。
- */
-void
-SchedTask::ex_read_normal()
-{
-}
 
 void
 SchedTask::exec()
 {
     __debug("[SchedTask:%s]\n", __FUNCTION__);
 
-#if !defined(NO_PIPELINE)
     scheduler->dma_wait(DMA_READ);
     task_list[task->command].wait(scheduler,task->command);
-#endif
-
     task_list[task->command].run(this, readbuf, writebuf);
-
     free(readbuf);
 
-    if (taskGroup->status() != 0) {
-        task->self = (int)taskGroup->command;
-        delete taskGroup;
-        taskGroup = NULL;
-    }
-
-
     // 書き込む領域がなければ無視
     if (outListData->length > 0) {
         scheduler->dma_storeList(outListData, writebuf, DMA_WRITE);
-
-#if defined(NO_PIPELINE)
-        scheduler->dma_wait(DMA_WRITE);
-        free(writebuf);
-#endif
     }
-
-    (this->*ex_exec)();
 }
 
 void
@@ -239,187 +123,40 @@
 {
     __debug("[SchedTask:%s]\n", __FUNCTION__);
 
-#if !defined(NO_PIPELINE)
     scheduler->dma_wait(DMA_WRITE);
     free(writebuf);
-#endif
 
-    if ((int)task->self == MY_SPE_NOP) return;
-
-    (this->*ex_write)();
-}
-
-
-/**
- * SPE 内で生成されたタスクの ex_read()
- */
-void
-SchedTask::ex_read_renew()
-{
-    writebuf = scheduler->allocate(outListData->size);
-}
-
-/**
- * PPE 内で生成されたタスクの ex_exec()
- */
-void
-SchedTask::ex_exec_normal()
-{
-}
-
-/**
- * SPE 内で生成されたタスクの ex_exec()
- */
-void
-SchedTask::ex_exec_renew()
-{
+    scheduler->mail_write((int)task->self);
 }
 
 
-
-/**
- * PPE 内で生成されたタスクの ex_write()
- *
- * このタスク内で新たにタスクが生成され、
- * 且つそのタスクの終了を待つ必要がある場合、
- * PPE に終了したことは知らせない(command は送信しない)
- */
-void
-SchedTask::ex_write_normal()
-{
-    /**
-     * このタスク内で新たにタスクが生成されなかった
-     * or 生成されたが、そのタスクの終了を待つ必要は無い
-     */
-    if (renew_flag == 0) {
-        scheduler->mail_write((int)task->self);
-    }
-}
-
-/**
- * SPE 内で生成されたタスクの ex_write()
- *
- *  A <- 親タスク
- *  | \
- *  B   C <- SPE 内で生成されたタスク
- *
- * A は SPE 内で B, C を生成したとする。
- * B と C が終了したら、A が PPE に送るはずだったコマンドが
- * 子タスクに引き継がれているので、最後に実行された子タスクが
- * PPE に mail 送信する。
- */
-void
-SchedTask::ex_write_renew()
-{
-    uint32 cmd;
-
-    taskGroup->remove(task);
-    cmd = taskGroup->status();
-
-    // タスク内で作られた全てのタスクが終了した
-    if (cmd != 0) {
-        delete taskGroup;
-        scheduler->mail_write(cmd);
-    }
-}
-
 SchedTaskBase*
 SchedTask::next(Scheduler *scheduler, SchedTaskBase *p)
 {
     __debug("[SchedTask:%s]\n", __FUNCTION__);
 
-    // delete p;  move to Scheduler
-
-    return (this->*ex_next)();
-}
-
-SchedTaskBase*
-SchedTask::ex_next_normal()
-{
     if (cur_index < list->length) {
-        SchedTaskBase *nextSched;
-
-        nextSched = scheduler->get_nextRenewTaskList();
+	// Task List が残っているので、次を準備
 
-        // RenewTask がある
-        if (nextSched) {
-            scheduler->set_backupTaskList(list);
-            scheduler->set_backupTaskListIndex(cur_index);
-            return nextSched;
-        } else {
-            TaskPtr nextTask = &list->tasks[cur_index++];
-            nextSched = createSchedTask(scheduler, nextTask);
-            ((SchedTask*)nextSched)->init(list, nextTask, cur_index,
-                                              // scheduler->get_curReadBuf(),
-                                              // scheduler->get_curWriteBuf(),
-                                              scheduler);
-            return nextSched;
-        }
+	TaskPtr nextTask = &list->tasks[cur_index++];
+        SchedTaskBase *nextSched = createSchedTask(scheduler, nextTask);
+	// この up cast は汚い...
+	((SchedTask*)nextSched)->init(list, nextTask, cur_index,
+					  scheduler);
+	return nextSched;
     } else {
         memaddr nextList = (memaddr)list->next;
-
         if (nextList == 0) {
+	    // もう何もする必要がない
             return new SchedNop2Ready(scheduler);
         } else {
+	    // 新しいリストに取り掛かる
             return createSchedTaskList(nextList, scheduler,
                                        SCHED_TASKLIST_NORMAL);
         }
     }
 }
 
-/**
- *
- */
-SchedTaskBase*
-SchedTask::ex_next_renew()
-{
-    TaskPtr nextTask;
-    SchedTask *nextSched;
-
-    if (cur_index < list->length) {
-        nextTask = &list->tasks[cur_index++];
-        nextSched = createSchedTask(scheduler, nextTask);
-
-        // RenewTaskList を実行中なので
-        nextSched->setRenew();
-        nextSched->init(list, nextTask, cur_index,
-                            // scheduler->get_curReadBuf(),
-                            // scheduler->get_curWriteBuf(),
-                            scheduler);
-
-        /**
-         * この理由は SchedTask:~SchedTask() で
-         */
-        list = NULL;
-        return nextSched;
-    } else {
-        SchedTaskBase *nextList;
-
-        nextList = scheduler->get_nextRenewTaskList();
-
-        if (nextList) {
-            return nextList;
-        } else {
-            TaskListPtr nextList = scheduler->get_backupTaskList();
-
-            // 中断した TaskList がある
-            if (nextList) {
-                cur_index = scheduler->get_backupTaskListIndex();
-
-                nextTask = &nextList->tasks[cur_index++];
-                nextSched = createSchedTask(scheduler, nextTask);
-
-                nextSched->init(nextList, nextTask, cur_index,
-                                    // scheduler->get_curReadBuf(),
-                                    // scheduler->get_curWriteBuf(),
-                                    scheduler);
-                return nextSched;
-            } else {
-                return new SchedNop2Ready(scheduler);
-            }
-        }
-    }
-}
 
 int
 SchedTask::get_cpuid()
@@ -496,39 +233,6 @@
     return task->param[index];
 }
 
-TaskPtr
-SchedTask::create_task(int cmd)
-{
-    TaskListPtr taskList = scheduler->get_renewListBuf();
-    TaskPtr p = &taskList->tasks[taskList->length++];
-    p->command = cmd;
-
-    // already allocated 
-    // p->inData = (ListData*)scheduler->allocate(sizeof(ListData));
-    // p->outData = (ListData*)scheduler->allocate(sizeof(ListData));
-
-    p->inData.clear();
-    p->outData.clear();
-
-    p->self = (int)MY_SPE_NOP;
-    p->param_size = 0;
-
-    return p;
-}
-
-/**
- *
- * @param[in] waitTask タスク内で生成したタスクの登録(spawn()に相当)
- */
-void
-SchedTask::wait_task(TaskPtr waitTask)
-{
-    waitTask->self = (memaddr)taskGroup;
-
-    scheduler->add_groupTask(taskGroup, waitTask);
-
-    renew_flag++;
-}
 
 void*
 SchedTask::global_alloc(int id, int size) {
@@ -570,11 +274,6 @@
     return scheduler->mainMem_get(id);
 }
 
-void*
-SchedTask::allocate(int size) {
-    return scheduler->allocate(size);
-}
-
 
 void
 SchedTask::dma_load(void *buf, uint32 addr, uint32 size, uint32 mask) {
@@ -608,6 +307,42 @@
     scheduler->wait_segment(s);
 }
 
+
+HTaskPtr SchedTask::create_task(int cmd)
+{
+    return scheduler->create_task(cmd);
+}
+
+void SchedTask::set_task_depend(HTaskPtr master, HTaskPtr slave)
+{
+    scheduler->set_task_depend(master, slave);
+}
+
+void SchedTask::spawn_task(HTaskPtr t)
+{
+    scheduler->spawn_task(t);
+}
+
+void SchedTask::set_task_cpu(HTaskPtr t, CPU_TYPE cpu)
+{
+    scheduler->set_task_cpu(t, cpu);
+}
+
+void* SchedTask::allocate(int size) 
+{
+    return scheduler->allocate(size) ;
+}
+
+void* SchedTask::allocate(int size,int align) 
+{
+    return scheduler->allocate(size,align) ;
+}
+
+Scheduler* SchedTask::get_scheduler() 
+{
+    return scheduler;
+}
+
 /* system call */
 
 int