--- a/TaskManager/Cell/spe/SchedExit.cc	Mon Jun 08 18:21:01 2009 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,14 +0,0 @@
-#include <stdio.h>
-#include "SchedExit.h"
-#include "error.h"
-
-SchedTaskBase*
-SchedExit::next(Scheduler *m, SchedTaskBase *p)
-{
-    delete p;
-
-    m->show_dma_wait();
-    __debug("SchedExit::next()\n");
-
-    return NULL;
-}

--- a/TaskManager/Cell/spe/SchedMail.cc	Mon Jun 08 18:21:01 2009 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,25 +0,0 @@
-#include "SchedMail.h"
-#include "SchedTaskList.h"
-#include "SchedExit.h"
-#include "error.h"
-
-SchedMail::SchedMail(Scheduler *sched)
-{
-    scheduler = sched;
-}
-
-SchedTaskBase*
-SchedMail::next(Scheduler *m, SchedTaskBase *p)
-{
-    delete p;
-    
-    params_addr = scheduler->mail_read();
-
-    __debug("[SchedMail:%s]\n", __FUNCTION__);
-
-    if ((int)params_addr == MY_SPE_COMMAND_EXIT) {
-        return new SchedExit();
-    } else {
-	return new SchedTaskList(params_addr, m);
-    }
-}

--- a/TaskManager/Cell/spe/SchedNop.cc	Mon Jun 08 18:21:01 2009 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,14 +0,0 @@
-#include <stdio.h>
-#include "SchedNop.h"
-#include "SchedMail.h"
-#include "error.h"
-
-SchedTaskBase*
-SchedNop::next(Scheduler *m, SchedTaskBase *p)
-{
-    __debug("[SPE] SchedNop::next()");
-    
-    delete p;
-
-    return new SchedMail(m);
-}

--- a/TaskManager/Cell/spe/SchedNop2Ready.cc	Mon Jun 08 18:21:01 2009 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,38 +0,0 @@
-#include <stdio.h>
-#include "SchedNop2Ready.h"
-#include "SchedTaskList.h"
-#include "SchedMail.h"
-#include "error.h"
-
-SchedNop2Ready::SchedNop2Ready(Scheduler *cn)
-{
-    scheduler = cn;
-}
-
-void
-SchedNop2Ready::exec(void)
-{
-    __debug("[SchedNop2Ready:%s]\n", __FUNCTION__);
-
-    //scheduler->mail_write(MY_SPE_STATUS_READY);
-}
-
-SchedTaskBase*
-SchedNop2Ready::next(Scheduler *m, SchedTaskBase *p)
-{
-    SchedTaskBase *nextSched;
-
-    __debug("[SchedNop2Ready:%s]\n", __FUNCTION__);
-    
-    delete p;
-
-    nextSched = scheduler->get_nextRenewTaskList();
-	
-    // RenewTask がある
-    if (nextSched) {
-	return nextSched;
-    } else {
-	scheduler->mail_write(MY_SPE_STATUS_READY);
-	return new SchedMail(scheduler);
-    }
-}

--- a/TaskManager/Cell/spe/SchedTask.cc	Mon Jun 08 18:21:01 2009 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,555 +0,0 @@
-#include <stdlib.h>
-#include <string.h>
-#include "SchedTask.h"
-#include "SchedTaskList.h"
-#include "SchedNop2Ready.h"
-#include "DmaManager.h"
-#include "error.h"
-#include "TaskManager.h"
-
-extern Scheduler::TaskObject task_list[MAX_TASK_OBJECT];
-
-//#define NO_PIPELINE 
-
-SchedTask*
-createSchedTask(TaskPtr task)
-{
-    return task_list[task->command]();
-}
-
-SchedTask::SchedTask(void)
-{
-    __list        = NULL;
-    __task        = NULL;
-    __inListData  = NULL;
-    __outListData = NULL;
-    __readbuf     = NULL;
-    __writebuf    = NULL;
-    __scheduler   = NULL;
-    __taskGroup   = NULL;
-    __renew_flag  = 0;
-    __cur_index   = 0;
-    __flag_renewTask = SCHED_TASK_NORMAL;
-    
-    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;
-
-    run_func = &SchedTask::run;
-}
-
-/**
- * dma_store の wait を行う
- * このタスクが RenewTask だった場合、
- * __inListData や __outListData は
- * Scheduler の持つ、使い回しの buffer ではなく
- * 新たに allocate されたものなので、ここで free する
- */
-SchedTask::~SchedTask(void)
-{
-    if (__flag_renewTask == SCHED_TASK_RENEW) {
-	free(__inListData);
-        free(__outListData);
- 
-	/**
-	 * __list != NULL の場合、
-	 * この Task が __list の最後の Task になるので (SchedTask::next 参照)
-	 * このタイミングで __list を解放する
-	 *   (free に渡されるアドレスが正しいものとなる)。
-	 * それ以外の Task では当然解放しない。
-	 *  __list == NULL なので、free に渡しても無問題
-	 */
-	free(__list);
-    }
-
-    delete smanager;
-}
-
-/**                                                                         
- * このタスクを Renew Task とし、それに応じた関数をセットする
- */
-void
-SchedTask::__setRenew(void)
-{
-    __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  = rbuf;
-    __outListData = wbuf;
-    __scheduler   = sc;
-    __cur_index   = index;
-
-    smanager = new STaskManager(this);
-
-    __scheduler->mainMem_wait();
-
-    (this->*ex_init)();
-}
-
-/**
- * PPE 内で生成されたタスクの ex_init()
- */
-void
-SchedTask::ex_init_normal(void)
-{
-    __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
-    
-    __taskGroup = new TaskGroup;
-    __taskGroup->command = __task->self;
-}
-
-/**
- * SPE 内で生成されたタスクの ex_init()
- * 各データは SPE 内の create_task 時に生成もしくは引き継がれているので
- * ex_init_normal() と違い、ここでは値を渡すだけ
- */
-void
-SchedTask::ex_init_renew(void)
-{
-    __inListData = __task->inData;
-    __outListData = __task->outData;
-    __taskGroup = (TaskGroupPtr)__task->self;    
-}
-
-/**
- * [Todo]
- *   データの読み込み場所を readbuf ではなく、
- *   ユーザ自身で決めれるようになるといいかもしれない。
- *
- *   # TaskManager が勝手に消すことなく、
- *   # ユーザが SPE 上に持ち続けることができるため。
- *   # もちろん管理はユーザに任せるわけだ。
- */
-void
-SchedTask::read(void)
-{    
-    __debug("[SchedTask:%s]\n", __FUNCTION__);
-
-#if !defined(NO_PIPELINE)
-    __scheduler->dma_wait(DMA_READ_IN_LIST);
-    __scheduler->dma_wait(DMA_READ_OUT_LIST);
-#endif
-
-    __writebuf = __scheduler->allocate(__outListData->size);
-    
-    // 読むデータが一つもなければ無視
-    if (__inListData->length == 0) return;
-
-    // load Input Data
-    __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)();
-}
-
-void
-SchedTask::exec(void)
-{
-    __debug("[SchedTask:%s]\n", __FUNCTION__);
-
-#if !defined(NO_PIPELINE)
-    __scheduler->dma_wait(DMA_READ);
-#endif
-
-    //run(__readbuf, __writebuf);
-    (this->*run_func)(__readbuf, __writebuf);
-
-    free(__readbuf);
-
-    if (__taskGroup->status() != 0) {
-	__task->self = __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
-SchedTask::write(void)
-{
-    __debug("[SchedTask:%s]\n", __FUNCTION__);
-    
-#if !defined(NO_PIPELINE)
-    __scheduler->dma_wait(DMA_WRITE);
-    free(__writebuf);
-#endif
-
-    if (__task->self == MY_SPE_NOP) return;
-
-    (this->*ex_write)();
-}
-
-/**
- * PPE 内で生成されたタスクの ex_read()
- */
-void
-SchedTask::ex_read_normal(void)
-{
-}
-
-/**
- * SPE 内で生成されたタスクの ex_read()
- */
-void
-SchedTask::ex_read_renew(void)
-{
-}
-
-/**
- * PPE 内で生成されたタスクの ex_exec()
- */
-void
-SchedTask::ex_exec_normal(void)
-{
-}
-
-/**
- * SPE 内で生成されたタスクの ex_exec()
- */
-void
-SchedTask::ex_exec_renew(void)
-{
-}
-
-
-
-/**
- * PPE 内で生成されたタスクの ex_write()
- * 
- * このタスク内で新たにタスクが生成され、
- * 且つそのタスクの終了を待つ必要がある場合、
- * PPE に終了したことは知らせない(command は送信しない)
- */
-void
-SchedTask::ex_write_normal(void)
-{
-    /**
-     * このタスク内で新たにタスクが生成されなかった
-     * or 生成されたが、そのタスクの終了を待つ必要は無い
-     */
-    if (__renew_flag == 0) {
-	__scheduler->mail_write(__task->self);
-    }
-}
-
-/**
- * SPE 内で生成されたタスクの ex_write()
- *
- *  A <- 親タスク
- *  | \
- *  B   C <- SPE 内で生成されたタスク
- *
- * A は SPE 内で B, C を生成したとする。
- * B と C が終了したら、A が PPE に送るはずだったコマンドが
- * 子タスクに引き継がれているので、最後に実行された子タスクが
- * PPE に mail 送信する。
- */
-void
-SchedTask::ex_write_renew(void)
-{
-    uint32 cmd;
-	
-    __taskGroup->remove(__task);
-    cmd = __taskGroup->status();    
-
-    // タスク内で作られた全てのタスクが終了した
-    if (cmd != 0) {
-	delete __taskGroup;
-	__scheduler->mail_write(cmd);
-    }
-}
-    
-SchedTaskBase*
-SchedTask::next(Scheduler *m, SchedTaskBase *p)
-{
-    __debug("[SchedTask:%s]\n", __FUNCTION__);
-
-    delete p;
-
-    return (this->*ex_next)();
-}
-
-SchedTaskBase*
-SchedTask::ex_next_normal(void)
-{
-    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(nextTask);
-	    ((SchedTask*)nextSched)->__init__(__list, nextTask, __cur_index,
-					      __scheduler->get_curReadBuf(),
-					      __scheduler->get_curWriteBuf(),
-					      __scheduler);
-	    return nextSched;
-	}
-    } else {
-	uint32 nextList = (uint32)__list->next;
-	
-	if (nextList == 0) {
-	    return new SchedNop2Ready(__scheduler);
-	} else {
-	    return createSchedTaskList(nextList, __scheduler,
-				       SCHED_TASKLIST_NORMAL);
-	}
-    }
-}
-
-/**
- *
- */
-SchedTaskBase*
-SchedTask::ex_next_renew(void)
-{
-    TaskPtr nextTask;
-    SchedTask *nextSched;
-
-    if (__cur_index < __list->length) {
-	nextTask = &__list->tasks[__cur_index++];
-	nextSched = createSchedTask(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(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(void)
-{
-    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)
-{
-    return __task->param[index];
-}
-
-TaskPtr
-SchedTask::create_task(int cmd)
-{
-    TaskListPtr taskList = __scheduler->get_renewListBuf();
-    TaskPtr p = &taskList->tasks[taskList->length++];
-    p->command = cmd;
-
-    p->inData = (ListData*)__scheduler->allocate(sizeof(ListData));
-    p->outData = (ListData*)__scheduler->allocate(sizeof(ListData));
-
-    p->inData->clear();
-    p->outData->clear();
-
-    p->self = MY_SPE_NOP;
-    p->param_size = 0;
-
-    return p;
-}
-
-/**
- * 生成したタスクが終了してから、メインスケジューラ(PPE) に
- * タスクが終了した旨を知らせる。
- *
- * @param[in] waitTask タスク内で生成したタスク
- */
-void
-SchedTask::wait_task(TaskPtr waitTask)
-{
-    waitTask->self = (uint32)__taskGroup;
-
-    __scheduler->add_groupTask(__taskGroup, waitTask);
-
-    __renew_flag++;
-}
-
-void*
-SchedTask::global_alloc(int id, int size) {
-    return __scheduler->global_alloc(id, size);
-}
-
-void*
-SchedTask::global_get(int id) {
-    return __scheduler->global_get(id);
-}
-
-void
-SchedTask::global_free(int id) {
-    __scheduler->global_free(id);
-}
-
-void
-SchedTask::mainMem_alloc(int id, int size) {
-    __scheduler->mainMem_alloc(id, size);
-}
-
-void
-SchedTask::mainMem_wait(void) {
-    __scheduler->mainMem_wait();
-}
-
-void*
-SchedTask::mainMem_get(int id) {
-    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) {
-    __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);
-}
-
-void
-SchedTask::dma_wait(uint32 mask) {
-    __scheduler->dma_wait(mask);
-}

--- a/TaskManager/Cell/spe/SchedTaskList.cc	Mon Jun 08 18:21:01 2009 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,84 +0,0 @@
-#include <stdlib.h>
-#include <string.h>
-#include "SchedTaskList.h"
-#include "SchedTask.h"
-#include "SchedNop2Ready.h"
-#include "DmaManager.h"
-#include "error.h"
-
-/**
- * SchedTaskList を返す
- *
- * @param[in] next_list 次の実行する TaskList のアドレス
- * @param[in] next_list がメインメモリのアドレスか、
- *            SPE で生成されたアドレスかのフラグ
- *            SPE で生成されている場合、DMA の必要は無い
- *            0: メインメモリ, 1: SPE
- */
-SchedTaskList*
-createSchedTaskList(uint32 next_list, Scheduler* scheduler, int renew_flag)
-{
-    SchedTaskList* sched = new SchedTaskList(next_list, scheduler);
-    sched->flag_renewTaskList = renew_flag;
-    return sched;
-}
-
-SchedTaskList::SchedTaskList(unsigned int addr, Scheduler *sched)
-{
-    params_addr = addr;
-    list = NULL;
-    scheduler = sched;
-
-    flag_renewTaskList = 0;
-}
-
-
-void
-SchedTaskList::read(void)
-{
-    __debug("[SchedTaskList:%s]\n", __FUNCTION__);
-
-    if (flag_renewTaskList == SCHED_TASKLIST_NORMAL) {
-	list = scheduler->get_curListBuf();
-	scheduler->dma_load(list, params_addr,
-			    sizeof(TaskList), DMA_READ_TASKLIST);
-    } else {
-	list = (TaskListPtr)params_addr;
-    }
-}
-
-SchedTaskBase*
-SchedTaskList::next(Scheduler *m, SchedTaskBase *p)
-{
-    SchedTaskBase *nextSched;
-
-    __debug("[SchedTaskList:%s]\n", __FUNCTION__);
-
-    delete p;
-
-    scheduler->dma_wait(DMA_READ_TASKLIST);
-
-    if (list->length < 1) {
-	nextSched = new SchedNop2Ready(scheduler);
-
-	if (flag_renewTaskList == SCHED_TASKLIST_RENEW) {
-	    free(list);
-	}
-
-    } else {
-	TaskPtr nextTask = &list->tasks[0];
-	nextSched = createSchedTask(nextTask);
-
-	if (flag_renewTaskList == SCHED_TASKLIST_RENEW) {
-	    ((SchedTask*)nextSched)->__setRenew();
-	}
-	
-	((SchedTask*)nextSched)->__init__(list, nextTask, 1,
-					  scheduler->get_curReadBuf(),
-					  scheduler->get_curWriteBuf(),
-					  scheduler);
-    }
-
-    return nextSched;
-}
-

--- a/TaskManager/Cell/spe/Scheduler.cc	Mon Jun 08 18:21:01 2009 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,320 +0,0 @@
-#include <stdio.h>
-#include <stdlib.h>
-#include "Scheduler.h"
-#include "SchedNop.h"
-#include "error.h"
-
-Scheduler::TaskObject task_list[MAX_TASK_OBJECT];
-
-Scheduler::~Scheduler(void)
-{
-    delete connector;
-}
-
-/*! @brief speTaskの入出力のパイプラインバッファを確保する
- */
-
-void
-Scheduler::init(void)
-{
-    init_impl();
-
-    for (int i = 0; i < 2; i++) {
-	buff_taskList[i]    = (TaskListPtr)allocate(sizeof(TaskList));
-	buff_inListData[i]  = (ListDataPtr)allocate(sizeof(ListData));
-	buff_outListData[i] = (ListDataPtr)allocate(sizeof(ListData));
-    }
-    
-    buffFlag_taskList = 0;
-    buffFlag_inListData = 0;
-    buffFlag_outListData = 0;
-    flag_renewTaskList = 0;
-
-    // bzero でもいいけど
-    for (int i = 0; i < MAX_GLOBAL_AREA; i++) {
-	globalList[i] = NULL;
-    }
-
-    for (int i = 0; i < MAX_MAINMEM_AREA; i++) {
-	mainMemList[i] = NULL;
-    }
-    
-
-    taskGroup = new TaskGroup;
-    renewTop_taskList = NULL;
-    renewCur_taskList = NULL;
-}
-
-void
-Scheduler::run(void)
-{
-    SchedTaskBase* taskTmp;
-
-    task1 = new SchedNop();
-    task2 = new SchedNop();
-    task3 = new SchedNop();
-
-    // main loop
-    do {
-	__debug("----------\n");
-	task3->write();
-	task2->exec();
-	task1->read();
-
-	taskTmp = task3;
-	task3 = task2;
-	task2 = task1;
-	task1 = task1->next(this, taskTmp);
-    } while (task1);
-
-    delete task3;
-    delete task2;
-}
-
-
-void
-Scheduler::finish(void)
-{
-    free(buff_taskList[0]);
-    free(buff_taskList[1]);
-    free(buff_inListData[0]);
-    free(buff_inListData[1]);
-    free(buff_outListData[0]);
-    free(buff_outListData[1]);
-}
-
-/**
- * あらかじめ memory allocte してある TaskList の領域を
- * パイプラインの各処理が交代して使う。
- */
-TaskListPtr
-Scheduler::get_curListBuf(void)
-{
-    buffFlag_taskList ^= 1;
-
-    return buff_taskList[buffFlag_taskList];
-}
-
-
-/**
- * あらかじめ memory allocte してある ListData の領域を
- * パイプラインの各処理が交代して使う。
- */
-ListDataPtr
-Scheduler::get_curWriteBuf(void)
-{
-    buffFlag_outListData ^= 1;
-    return buff_outListData[buffFlag_outListData];
-}
-
-
-ListDataPtr
-Scheduler::get_curReadBuf(void)
-{
-    buffFlag_inListData ^= 1;
-    return buff_inListData[buffFlag_inListData];
-}
-
-/**
- * タスク内で生成されたタスクを格納する TaskList を取得する
- * 現在格納に使っている TaskList (renewCur_taskList) が使えるならそれを返す
- * もしそうでないなら、新しく TaskList を allocate してそれを返す
- * コード中で renewCur_taskList が NULL になるのは
- *   - プログラム開始時
- *   - タスク内生成タスクがある TaskList の実行を新しく始める (Nop2Ready 参照)
- * 以上の場合です
- */
-TaskListPtr
-Scheduler::get_renewListBuf(void)
-{
-    if (renewCur_taskList && renewCur_taskList->length < TASK_MAX_SIZE) {
-	return renewCur_taskList;
-    } else {
-	TaskListPtr newList = (TaskListPtr)allocate(sizeof(TaskList));
-	newList->length = 0;
-	newList->next = NULL;
-	renewTop_taskList = TaskList::append(renewTop_taskList, newList);
-	renewCur_taskList = newList;
-	return newList;
-    }
-}
-
-/**
- * 次に実行する Renew Task List を返す
- *
- * @param[in] curList 現在実行中の TaskList
- *                    中断して RenewTaskList を行うため
- *                    バックアップを取っておく
- * @return next RenewTaskList
- */
-SchedTaskList*
-Scheduler::get_nextRenewTaskList(void)
-{
-    if (renewTop_taskList) {
-	TaskListPtr list  = renewTop_taskList;
-	renewTop_taskList = renewTop_taskList->next;
-	renewCur_taskList = NULL;
-
-	list->next = NULL;
-	SchedTaskList *sched
-	    = createSchedTaskList((uint32)list, this, SCHED_TASKLIST_RENEW);
-	return sched;
-    } else {
-	return NULL;
-    }
-}
-
-void
-Scheduler::set_backupTaskList(TaskListPtr cur_taskList)
-{
-    bak_curTaskList = cur_taskList;
-}
-
-void
-Scheduler::set_backupTaskListIndex(int cur_index)
-{
-    bakIndex_taskList = cur_index;
-}
-
-/**
- * RenewTaskList 実行前に中断した TaskList を返す
- * NULL の場合、中断した TaskList は無い。
- *
- * @return TaskList
- */
-TaskListPtr
-Scheduler::get_backupTaskList(void)
-{
-    TaskListPtr ret = bak_curTaskList;
-    
-    bak_curTaskList = NULL;
-    return ret;
-}
-
-int
-Scheduler::get_backupTaskListIndex(void)
-{
-    int ret = bakIndex_taskList;
-
-    bakIndex_taskList = 0;
-    return ret;
-}
-
-void
-Scheduler::dma_load(void *buf, uint32 addr, uint32 size, uint32 mask)
-{
-    connector->dma_load(buf, addr, size, mask);
-}
-
-void
-Scheduler::dma_store(void *buf, uint32 addr, uint32 size, uint32 mask)
-{
-    connector->dma_store(buf, addr, size, mask);
-}
-
-void
-Scheduler::dma_wait(uint32 mask)
-{
-    connector->dma_wait(mask);
-}
-
-void
-Scheduler::dma_loadList(ListDataPtr list, void *buff, uint32 mask)
-{
-    connector->dma_loadList(list, buff, mask);
-}
-
-
-void
-Scheduler::dma_storeList(ListDataPtr list, void *buff, uint32 mask)
-{
-    return connector->dma_storeList(list, buff, mask);
-}
-
-void
-Scheduler::mail_write(uint32 data)
-{
-    connector->mail_write(data);
-}
-
-uint32
-Scheduler::mail_read(void)
-{
-    return connector->mail_read();
-}
-
-TaskGroupPtr
-Scheduler::set_groupTask(uint32 command)
-{
-    TaskGroupPtr ret = taskGroup;
-
-    reload_groupTask();
-
-    ret->command = command;
-    return ret;
-}
-
-void
-Scheduler::add_groupTask(TaskGroupPtr group, TaskPtr task)
-{
-    group->add(task);
-}
-
-void
-Scheduler::remove_groupTask(TaskGroupPtr group, TaskPtr task)
-{
-    group->remove(task);
-}
-
-void
-Scheduler::reload_groupTask(void)
-{
-    taskGroup = new TaskGroup;
-}
-
-uint32
-Scheduler::status_groupTask(TaskGroupPtr group)
-{
-    return group->status();
-}
-
-void*
-Scheduler::global_alloc(int id, int size)
-{
-    globalList[id] = allocate(size);
-    return globalList[id];
-}
-
-void*
-Scheduler::global_get(int id)
-{
-    return globalList[id];
-}
-
-void
-Scheduler::global_free(int id)
-{
-    free(globalList[id]);
-    globalList[id] = NULL;
-}
-
-/**
- * mainMem_alloc で確保したメインメモリの領域アドレスを返す。
- * これは Fifo, Cell で共通
- */
-void*
-Scheduler::mainMem_get(int id)
-{
-    return mainMemList[id];
-}
-
-
-/**
- * 本当は Scheduler クラスに入れるべきなんだろうか。。。
- * なんか手抜きの感がある
- */
-void
-register_task(int cmd, Scheduler::TaskObject task)
-{
-    task_list[cmd] = task;
-}

--- a/TaskManager/Cell/spe/TaskGroup.cc	Mon Jun 08 18:21:01 2009 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,55 +0,0 @@
-#include "TaskGroup.h"
-
-void
-TaskGroup::add(TaskPtr add_task) {
-    TaskQueuePtr q = new TaskQueue(add_task);
-    group = TaskQueue::append(group, q);
-}
-
-void
-TaskGroup::remove(TaskPtr delete_task) {
-    TaskQueuePtr p = group;
-    TaskQueuePtr p1;
-
-    if (p == NULL) return;
-
-    if (p->task == delete_task) {
-	group = group->next;
-	delete p;
-    } else {
-	p1 = p->next;
-	while (p1 && p1->task != delete_task) {
-	    p1 = p1->next;
-	    p = p->next;
-	}
-	if (p1) {
-	    p->next = p1->next;
-	    delete p1;
-	}
-    }
-}
-
-/**
- * 自分が持つ TaskGroup に Task が残っていれば NULL を返す。
- * もう全てのタスクが終了していれば、この TaskGroup を作った
- * (一番最初にタスク内タスク生成を行った)タスクが PPE に返すべきだった
- * command を返す。
- */
-unsigned int
-TaskGroup::status(void) {
-    /**                                                                     
-     * bool の                                                              
-     *  true == 1;                                                          
-     *  false == 0;                                                         
-     * って保証されてるんだっけ？                                           
-     */
-#if 1
-    return (group == NULL) * command;
-#else
-    if (group.empty()) {
-	return command;
-    } else {
-	return 0;
-    }
-#endif
-}

--- a/TaskManager/Makefile.cell	Mon Jun 08 18:21:01 2009 +0900
+++ b/TaskManager/Makefile.cell	Mon Jun 08 18:28:18 2009 +0900
@@ -3,6 +3,8 @@
 TARGET    = libCellManager.a
 SPETARGET = libspemanager.a
 
+CELL_SPE_DIR  = $(IMPL_CELL_DIR)/spe
+
 CELL_SPE_SCHEDULE_SRC = $(CELL_SPE_DIR)/SchedExit.cc       \
     $(CELL_SPE_DIR)/SchedNop2Ready.cc  \
     $(CELL_SPE_DIR)/SchedTaskList.cc \
@@ -14,8 +16,16 @@
     $(CELL_SPE_DIR)/TaskGroup.cc
 CELL_SPE_SCHEDULE_OBJ = $(CELL_SPE_SCHEDULE_SRC:.cc=.o)
 
-CELL_SPE_DIR  = $(IMPL_CELL_DIR)/spe
-CELL_SPE_SRCS = $(wildcard $(CELL_SPE_DIR)/*.cc)
+CELL_SPE_SRCS =  \
+    $(CELL_SPE_DIR)/CellDmaManager.cc   \
+    $(CELL_SPE_DIR)/TaskList.cc \
+    $(CELL_SPE_DIR)/CellScheduler.cc    \
+    $(CELL_SPE_DIR)/TaskQueue.cc \
+    $(CELL_SPE_DIR)/Task.cc            \
+    $(CELL_SPE_DIR)/main.cc
+
+# $(wildcard $(CELL_SPE_DIR)/*.cc)
+
 CELL_SPE_OBJS = $(CELL_SPE_SRCS:.cc=.o) $(CELL_SPE_SCHEDULE_OBJ)
 
 SPUCC = spu-g++