Mercurial > hg > Members > kono > Cerium

--- a/TaskManager/Fifo/FifoDmaManager.h	Fri Oct 16 17:57:17 2009 +0900
+++ b/TaskManager/Fifo/FifoDmaManager.h	Tue Oct 20 20:34:47 2009 +0900
@@ -24,7 +24,6 @@

     void dma_loadList(ListDataPtr list, void *buff, uint32 mask);
     void dma_storeList(ListDataPtr, void *buff, uint32 mask);
-    //void* dma_loadList(ListDataPtr list, void *buff, uint32 mask);
 };

 #endif
--- a/TaskManager/kernel/ppe/HTask.cc	Fri Oct 16 17:57:17 2009 +0900
+++ b/TaskManager/kernel/ppe/HTask.cc	Tue Oct 20 20:34:47 2009 +0900
@@ -1,13 +1,4 @@
 #include "HTask.h"
-#include "ListData.h"
-#include "TaskManagerImpl.h"
-
-
-void
-HTask::spawn()
-{
-    mimpl->spawn_task(this);
-}

 /*!
   @brief この Task が待ち合わせする Task を指定する
@@ -32,3 +23,18 @@

 }

+void
+HTask::set_cpu(CPU_TYPE type)
+{
+    cpu_type = type;
+}
+
+void
+HTask::set_post(PostFunction func_,void *read, void *write)
+{
+    post_func = func_;
+    post_arg1 = read;
+    post_arg2 = write;
+}
+
+/* end */
--- a/TaskManager/kernel/ppe/HTask.h	Fri Oct 16 17:57:17 2009 +0900
+++ b/TaskManager/kernel/ppe/HTask.h	Tue Oct 20 20:34:47 2009 +0900
@@ -9,6 +9,8 @@
 class TaskManagerImpl;
 class SchedTask;

+typedef void (*PostFunction)(SchedTask *s, void *read, void *write);
+
 /*!
   @class
--- a/TaskManager/kernel/ppe/HTaskInfo.cc	Fri Oct 16 17:57:17 2009 +0900
+++ b/TaskManager/kernel/ppe/HTaskInfo.cc	Tue Oct 20 20:34:47 2009 +0900
@@ -64,13 +64,13 @@
     q->waiter = NULL;

     q->command  = cmd;
-    q->inData.clear();
-    q->outData.clear();
+    // q->inData.clear();
+    // q->outData.clear();
     q->self = (int) q;
     q->param_size = 0;

     q->post_func = NULL;
-    q->mimpl     = NULL;
+    // q->mimpl     = NULL;
     q->cpu_type  = CPU_PPE;

     // q->wait_me.clear();
--- a/TaskManager/kernel/ppe/Task.cc	Fri Oct 16 17:57:17 2009 +0900
+++ b/TaskManager/kernel/ppe/Task.cc	Tue Oct 20 20:34:47 2009 +0900
@@ -11,6 +11,7 @@
 int
 Task::add_inData_t(unsigned int addr, int size)
 {
+    ListData *inData = (ListData*) rbuf;
     return add_data(inData, addr, size);
 }

@@ -25,6 +26,7 @@
 int
 Task::add_outData_t(unsigned int addr, int size)
 {
+    ListData *outData = (ListData*) wbuf;
     return add_data(outData, addr, size);
 }

@@ -50,34 +52,21 @@
  * perror みたいにしたほうがわかりやすいかな。
  */
 int
-Task::add_data(ListData& list, uint32 addr, int size)
+Task::add_data(ListData *list, uint32 addr, int size)
 {
-    if (list.length >= MAX_LIST_DMA_SIZE) return -1;
+    if (list->length >= MAX_LIST_DMA_SIZE) return -1;

-    list.bound[list.length] = list.size;
+    list->bound[list->length] = list->size;

     // size でも制限かけるべき？
-    list.size += size;
+    list->size += size;

-    ListElementPtr elm = &list.element[list.length++];
+    ListElementPtr elm = &list->element[list->length++];
     elm->addr = addr;
     elm->size = size;

     return 0;
 }

-void
-Task::set_cpu(CPU_TYPE type)
-{
-    cpu = type;
-}
-
-void
-Task::set_post(PostFunction func_,void *read, void *write)
-{
-    post_func = func_;
-    post_arg1 = read;
-    post_arg2 = write;
-}

 /* end */
--- a/TaskManager/kernel/ppe/Task.h	Fri Oct 16 17:57:17 2009 +0900
+++ b/TaskManager/kernel/ppe/Task.h	Tue Oct 20 20:34:47 2009 +0900
@@ -32,26 +32,27 @@
 class Task {
 public: // variables

-typedef void (*PostFunction)(SchedTask *s, void *read, void *write);
-
     BASE_NEW_DELETE(Task);

     int command;         // 4 byte
     int self;         // 4 byte
-
+    int rsize;
+    int wsize;
     int param_size;        // 4 byte
-    int param[MAX_PARAMS]; // 4*MAX_PARAMS byte
+    void *rbuf;
+    void *wbuf;
+    int param[MAX_PARAMS];

+#if 0
     ListData inData  __attribute__ ((aligned (DEFAULT_ALIGNMENT)));  // 4 byte 64bit であるべき
     ListData outData  __attribute__ ((aligned (DEFAULT_ALIGNMENT))); // 4 byte 64bit であるべき
+#endif

 public: // functions
     int add_inData_t(unsigned int addr, int size);  // unsigned int ではなく 64bit
     int add_outData_t(unsigned int addr, int size); // unsigned int ではなく 64bit
-    int add_data(ListData &list, unsigned int addr, int size);
+    int add_data(ListData *list, unsigned int addr, int size);
     int add_param(int param);
-    void set_cpu(CPU_TYPE type);
-    void set_post(PostFunction func, void *read, void *write);

 #define add_inData(addr, size)			\
     add_inData_t((unsigned int)(addr), (size));
--- a/TaskManager/kernel/ppe/TaskManager.cc	Fri Oct 16 17:57:17 2009 +0900
+++ b/TaskManager/kernel/ppe/TaskManager.cc	Tue Oct 20 20:34:47 2009 +0900
@@ -54,6 +54,12 @@
     return m_impl->create_task(cmd);
 }

+HTaskPtr
+TaskManager::create_task(int cmd, void *read, int rsize, void *write, int wsize)
+{
+    return m_impl->create_task(cmd,read,rsize,write,wsize);
+}
+
 /**
  * TaskManaer 終了時に実行される関数の設定
  */
--- a/TaskManager/kernel/ppe/TaskManager.h	Fri Oct 16 17:57:17 2009 +0900
+++ b/TaskManager/kernel/ppe/TaskManager.h	Tue Oct 20 20:34:47 2009 +0900
@@ -19,6 +19,8 @@

     /* user function */
     HTaskPtr create_task(int cmd);
+    /* simple task creation */
+    HTaskPtr create_task(int cmd, void *read, int rsize, void *write, int wsize);
     void run();
     void *allocate(int size);
     void set_TMend(void (*endf)(TaskManager *manager));
--- a/TaskManager/kernel/ppe/TaskManagerImpl.cc	Fri Oct 16 17:57:17 2009 +0900
+++ b/TaskManager/kernel/ppe/TaskManagerImpl.cc	Tue Oct 20 20:34:47 2009 +0900
@@ -34,10 +34,10 @@

     schedTaskManager = new SchedTaskManager(this);

-    systask_start = create_task(SYSTASK_START);
-    systask_finish = create_task(SYSTASK_FINISH);
+    systask_start = create_task(SYSTASK_START,0,0,0,0);
+    systask_finish = create_task(SYSTASK_FINISH,0,0,0,0);

-    systask_start->spawn();
+    spawn(systask_start);

     // systask_finish で spawn すると
     //   systask_finish->wait_for(systask_finish);
@@ -46,6 +46,19 @@
     append_waitTask(systask_finish);
 }

+void *
+TaskManagerImpl::get_rbuf()
+{
+    return 0;
+}
+
+void *
+TaskManagerImpl::get_wbuf()
+{
+    return 0;
+}
+
+
 HTaskPtr
 TaskManagerImpl::create_task(int cmd)
 {
@@ -53,18 +66,35 @@

     new_task = htaskImpl->create(cmd);
     new_task->post_func = noaction;
-    new_task->mimpl = this;
+    new_task->rbuf = get_rbuf();
+    new_task->wbuf = get_wbuf();

     return new_task;
 }

+HTaskPtr
+TaskManagerImpl::create_task(int cmd, void *read, int rsize, void *write, int wsize)
+{
+    HTaskPtr new_task;
+
+    new_task = htaskImpl->create(cmd);
+    new_task->post_func = noaction;
+    new_task->rbuf = read;
+    new_task->rsize = rsize;
+    new_task->wbuf = write;
+    new_task->wsize = wsize;
+
+    return new_task;
+}
+
+
 /**
  * タスクを実行可能キューまたは待機キューへ追加する。
  * 依存関係が満たされていれば active, まだだったら wait へ。
  * task->spawn();
  */
 void
-TaskManagerImpl::spawn_task(HTaskPtr task)
+TaskManagerImpl::spawn(HTask *task)
 {
     // waiter // master
     // waitee // slave
--- a/TaskManager/kernel/ppe/TaskManagerImpl.h	Fri Oct 16 17:57:17 2009 +0900
+++ b/TaskManager/kernel/ppe/TaskManagerImpl.h	Tue Oct 20 20:34:47 2009 +0900
@@ -41,9 +41,12 @@

     // user
     HTaskPtr create_task(int cmd);
-    void set_task_depend(HTaskPtr master, HTaskPtr slave);
-    void spawn_task(HTaskPtr);
+    HTaskPtr create_task(int cmd, void *read, int rsize, void *write, int wsize);
+
+    void spawn(HTaskPtr);
     void set_task_cpu(HTaskPtr, CPU_TYPE);
+    void *get_rbuf();
+    void *get_wbuf();
     virtual void* allocate(int size) = 0;
     virtual void* allocate(int size,int align) = 0;
     virtual Scheduler* get_scheduler() = 0;
--- a/TaskManager/kernel/schedule/SchedTask.cc	Fri Oct 16 17:57:17 2009 +0900
+++ b/TaskManager/kernel/schedule/SchedTask.cc	Tue Oct 20 20:34:47 2009 +0900
@@ -10,8 +10,6 @@

 extern Scheduler::TaskObject task_list[MAX_TASK_OBJECT];

-//#define NO_PIPELINE
-
 /**
    Task Object を作る
  */
@@ -54,12 +52,6 @@
     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,87 +59,19 @@
  */
 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,
-                    // ListDataPtr rbuf, ListDataPtr wbuf,
 		    Scheduler* sc)
 {
     list        = _list;
     task        = _task;
-    inListData  = &_task->inData;
-    outListData = &_task->outData;
     scheduler   = sc;
     cur_index   = index;
-
     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
@@ -155,83 +79,39 @@
 {
     __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) {
-	// load next task
-	loadSchedTask(scheduler, &list->tasks[cur_index]);
-    }
-
-    writebuf = scheduler->allocate(outListData->size);
+    // next task の load
+    loadSchedTask(scheduler, &list->tasks[cur_index]);
+    writebuf = scheduler->allocate(wsize);

     // 読むデータが一つもなければ無視
-    if (inListData->length == 0) return;
+    if (rsize == 0) return;

     // load Input Data
-    readbuf = scheduler->allocate(inListData->size);
-    scheduler->dma_loadList(inListData, readbuf, DMA_READ);
+    readbuf = scheduler->allocate(rsize);
+    read_tag = get_tag();
+    scheduler->dma_load(readbuf, rsize, read_tag);

-#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);
+    scheduler->dma_wait(read_tag);
     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 (wsize->length > 0) {
+	write_tag = get_tag();
+        scheduler->dma_store(writebuf, wsize, write_tag);
     }
-
-
-    // 書き込む領域がなければ無視
-    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 +119,27 @@
 {
     __debug("[SchedTask:%s]\n", __FUNCTION__);

-#if !defined(NO_PIPELINE)
-    scheduler->dma_wait(DMA_WRITE);
+    scheduler->dma_wait(write_tag);
     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()
-{
+    (*post_func)(this,0,0);
 }


-
-/**
- * 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();
-
-        // 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 = (Task*)activeQueue.poll();
+    if (nextTask) {
+        SchedTask *nextSched = createSchedTask(scheduler, nextTask);
+	nextSched->init(list, nextTask, cur_index, scheduler);
+	return nextSched;
     } else {
-        uint32 nextList = (uint32)list->next;
-
-        if (nextList == 0) {
-            return new SchedNop2Ready(scheduler);
-        } else {
-            return createSchedTaskList(nextList, scheduler,
-                                       SCHED_TASKLIST_NORMAL);
-        }
+	return new SchedNop2Ready(scheduler);
     }
 }

-/**
- *
- */
-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()
@@ -427,68 +147,6 @@
     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]);
-    } else {
-        return NULL;
-    }
-}
-
-/**
- * get_input(index) のアドレスを返す
- */
-uint32
-SchedTask::get_inputAddr(int index)
-{
-    return inListData->element[index].addr;
-}
-
-/**
- * get_input(index) のサイズを返す
- */
-int
-SchedTask::get_inputSize(int index)
-{
-    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]);
-    } else {
-        return NULL;
-    }
-}
-
-/**
- * get_output(index) のアドレスを返す
- */
-uint32
-SchedTask::get_outputAddr(int index)
-{
-    return outListData->element[index].addr;
-}
-
-/**
- * get_output(index) のサイズを返す
- */
-int
-SchedTask::get_outputSize(int index)
-{
-    return outListData->element[index].size;
-}

 int
 SchedTask::get_param(int index)
@@ -500,22 +158,6 @@
 SchedTask::create_task(int cmd)
 {
     HTaskPtr htask = scheduler->create_task(cmd);
-#if 0
-    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;
-#endif
-
     return p;
 }

@@ -524,13 +166,9 @@
  * @param[in] waitTask タスク内で生成したタスクの登録(spawn()に相当)
  */
 void
-SchedTask::wait_task(TaskPtr waitTask)
+SchedTask::spawn(HTaskPtr task)
 {
-    waitTask->self = (int)taskGroup;
-
-    scheduler->add_groupTask(taskGroup, waitTask);
-
-    renew_flag++;
+    activeQueue.addFirst(task);
 }

 void*
--- a/TaskManager/kernel/schedule/SchedTask.h	Fri Oct 16 17:57:17 2009 +0900
+++ b/TaskManager/kernel/schedule/SchedTask.h	Tue Oct 20 20:34:47 2009 +0900
@@ -29,41 +29,20 @@
     TaskListPtr list;
     TaskPtr task;

-    // read/write 用の ListData
-    ListDataPtr inListData;
-    ListDataPtr outListData;
-
     /**
      * read データ、write 用のバッファ
      * readbuf には タスク登録時に設定した入力データが入っている。
      * writebuf にデータを描き込んでおくと、
      * タスク登録時に設定した出力先に書き込む
      */
+    int rsize;
     void *readbuf;
+    int wsize;
     void *writebuf;

     // Task の、Tasklist での位置。(task = &list[cur_index-1])
     int cur_index;

-    // タスク内で生成されたタスクのグループ
-    TaskGroup *taskGroup;
-
-    // このタスク内で生成されたタスクの数
-    int renew_flag;
-
-    // このタスクが SPE 内で生成されたタスクか否か 1: Yes, 0: No
-    int flag_renewTask;
-
-    // タスクがメインメモリ側で生成されたものか、
-    // SPE で生成されたものかによって、データの扱いが変わってくる。
-    // そのために if (flag_renewTask) を連発するのはよくないので
-    // 関数ポインタで持っておく
-    void (SchedTask::*ex_init)();
-    void (SchedTask::*ex_read)();
-    void (SchedTask::*ex_exec)();
-    void (SchedTask::*ex_write)();
-    SchedTaskBase* (SchedTask::*ex_next)();
-
     /* functions */

     // override
@@ -77,30 +56,12 @@
     //---  System API ---
     SchedTask* get_nextTask(TaskListPtr list);

-    /**
-     * PPE で生成されたタスクに対する
-     * init, read,exec,write,next の付属(?)処理
-     */
-    void ex_init_normal();
-    void ex_read_normal();
-    void ex_exec_normal();
-    void ex_write_normal();
-    SchedTaskBase* ex_next_normal();
-
-    /**
-     * SPE で生成されたタスクに対する
-     * inti, ead,exec,write,next の付属(?)処理
-     */
-    void ex_init_renew();
-    void ex_read_renew();
-    void ex_exec_renew();
-    void ex_write_renew();
-    SchedTaskBase* ex_next_renew();

 public:
     /* functions */

-    void setRenew();
+    void spwan(HTask *task);
+
     void init(TaskListPtr _list, TaskPtr _task, int index,
                     // ListDataPtr rbuf, ListDataPtr wbuf,
 		    Scheduler* sc);
@@ -119,8 +80,7 @@

     void set_post(PostFunction func,void *read, void *write);

-    TaskPtr create_task(int cmd);
-    void wait_task(TaskPtr waitTask);
+    HTaskPtr create_task(int cmd);

     void* global_alloc(int id, int size);
     void* global_get(int id);
@@ -172,8 +132,6 @@

 };

-const int SCHED_TASK_NORMAL = 0;
-const int SCHED_TASK_RENEW  = 1;

 extern SchedTask* createSchedTask(Scheduler *,TaskPtr);
 extern void loadSchedTask(Scheduler *scheduler,TaskPtr task);