--- a/TaskManager/ChangeLog	Thu Dec 10 22:55:55 2009 +0900
+++ b/TaskManager/ChangeLog	Sat Dec 12 17:38:30 2009 +0900
@@ -1,4 +1,20 @@
-
+2009-12-12 Shinji KONO <kono@ie.u-ryukyu.ac.jp>
+
+   SchedTask::next で、TaskArray を認識して、そこで、
+   SchedTaskArrayLoad を作る。次のSchedTask を用意して、
+   SchedTaskArrayLoad にsavedSchedTaskとして引き渡す。
+   
+   SchedTaskArrayLoad::read は、TaskArray をload する。
+   SchedTaskArrayLoad::next は、SchedTaskArray を返す。
+   この時に、saveedSchedTask を引き継ぐ。
+   write/exec は何もしない。(これで、pipe line を空ける)
+
+   SchedTaskArray::read は、List DMA をload する。
+   SchedTaskArrayLoad::next は、TaskArray 上のTaskを返す。
+   exec/write は、List DMA 対応で動作する。
+   もうない場合には、SchedTaskArrayLoad から伝えられた
+   saveされた SchedTask を返す。mail も送る。
+
 2009-12-7 Shinji KONO <kono@ie.u-ryukyu.ac.jp>
 
     pipeline stageは、loop local だから、instance 変数である必

--- a/TaskManager/Makefile.def	Thu Dec 10 22:55:55 2009 +0900
+++ b/TaskManager/Makefile.def	Sat Dec 12 17:38:30 2009 +0900
@@ -32,11 +32,7 @@
 SIMPLE_TASK=-DSIMPLE_TASK
 # SIMPLE_TASK=
 
-<<<<<<< local
 # OPT = -O9 
-=======
-#OPT = -O9 
->>>>>>> other
 OPT =  -g
 
 CC     = g++   

--- a/TaskManager/kernel/ppe/Task.h	Thu Dec 10 22:55:55 2009 +0900
+++ b/TaskManager/kernel/ppe/Task.h	Sat Dec 12 17:38:30 2009 +0900
@@ -70,6 +70,16 @@
 	return p + sizeof(ListElement)* index;
     }
 
+    ListElement *inListData() {
+	memaddr data = (memaddr)this;
+	return (ListElement*)(data+inData_offset);
+    }
+
+    ListElement *outListData() {
+	memaddr data = (memaddr)this;
+	return (ListElement*)(data+outData_offset);
+    }
+
     void set_param_length(int i) { 
 	param_size = i; 
 	inData_offset = round_up16(sizeof(Task))+param_size*sizeof(memaddr);
@@ -113,8 +123,8 @@
 
     Task * next()
     {
-	char *p = (char*)t;
-	p += t->size();
+	char *p = (char*)this;
+	p += size();
 	return (Task*)p;
     }
 

--- a/TaskManager/kernel/schedule/SchedTask.cc	Thu Dec 10 22:55:55 2009 +0900
+++ b/TaskManager/kernel/schedule/SchedTask.cc	Sat Dec 12 17:38:30 2009 +0900
@@ -1,7 +1,9 @@
 #include <stdlib.h>
 #include <string.h>
 #include "SchedTask.h"
+#include "SysFunc.h"
 #include "SchedTaskList.h"
+#include "SchedTaskArrayLoad.h"
 #include "SchedNop2Ready.h"
 #include "DmaManager.h"
 #include "error.h"
@@ -32,7 +34,7 @@
    最初の一回は SchedTaskList:: next から呼ばれる。
    この段階では、SchedTask object は、まだ作られてない。
  */
-static void
+extern void
 loadSchedTask(Scheduler *scheduler,TaskPtr task)
 {
 // fprintf(stderr,"loadSchedTask %d\n",task->command);
@@ -98,14 +100,12 @@
 	loadSchedTask(scheduler, &list->tasks[cur_index]);
     }
 #ifdef SIMPLE_TASK
-    writebuf = scheduler->allocate(task->w_size);
     // 読むデータが一つもなければ無視
     if (task->r_size == 0) return;
     // load Input Data
     readbuf = scheduler->allocate(task->r_size);
     scheduler->dma_load(readbuf, task->rbuf,task->r_size, DMA_READ);
 #else
-    writebuf = scheduler->allocate(outListData->size);
 
     // 読むデータが一つもなければ無視
     if (inListData->length == 0) return;
@@ -132,10 +132,12 @@
     // 書き込む領域がなければ無視
 #ifdef SIMPLE_TASK
     if (task->w_size > 0) {
+	writebuf = scheduler->allocate(task->w_size);
 	scheduler->dma_store(writebuf, task->wbuf,task->w_size, DMA_WRITE);
     }
 #else
     if (outListData->length > 0) {
+	writebuf = scheduler->allocate(outListData->size);
         scheduler->dma_storeList(outListData, writebuf, DMA_WRITE);
     }
 #endif
@@ -166,6 +168,11 @@
 	// この up cast は汚い...
 	((SchedTask*)nextSched)->init(list, nextTask, cur_index,
 					  scheduler);
+	if (nextTask->command==TaskArray) {
+	    // Start Task Array
+	    return (SchedTaskBase*)(new SchedTaskArrayLoad(nextSched));
+	}
+
 	return nextSched;
     } else {
         memaddr nextList = (memaddr)list->next;

--- a/TaskManager/kernel/schedule/SchedTask.h	Thu Dec 10 22:55:55 2009 +0900
+++ b/TaskManager/kernel/schedule/SchedTask.h	Sat Dec 12 17:38:30 2009 +0900
@@ -19,21 +19,21 @@
 
     BASE_NEW_DELETE(SchedTask);
 
+    // Task を実行するスケジューラ自身
+    Scheduler *scheduler;
+
 private:
     /* variables */
-
-    // Task を実行するスケジューラ自身
-    Scheduler *scheduler;
     
     // 現在スケジューラが実行している TaskList と、このタスクに対応する Task
     TaskListPtr list;
 
+#ifndef SIMPLE_TASK
+    TaskPtr task;
+    memaddr *param;
     // read/write 用の ListData
     ListDataPtr inListData;
     ListDataPtr outListData;
-#ifndef SIMPLE_TASK
-    TaskPtr task;
-    memaddr *param;
 #else
     SimpleTaskPtr task;
 #endif
@@ -166,6 +166,7 @@
 extern SchedTask* createSchedTask(Scheduler *,TaskPtr);
 #endif
 
+extern void loadSchedTask(Scheduler *scheduler,TaskPtr task);
 
 #endif
 

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/TaskManager/kernel/schedule/SchedTaskArray.cc	Sat Dec 12 17:38:30 2009 +0900
@@ -0,0 +1,94 @@
+#include "SchedTaskArray.h"
+#include "SchedTask.h"
+
+extern Scheduler::TaskObject task_list[MAX_TASK_OBJECT];
+
+SchedTaskArray::SchedTaskArray(SchedTaskBase *savedTask_, Task *curTask_, Task *_array)
+{
+    savedTask = savedTask_;
+    task = curTask_;
+    array = _array;
+}
+
+/**
+ * dma_store の wait を行う
+ */
+SchedTaskArray::~SchedTaskArray()
+{
+}
+
+void
+SchedTaskArray::read()
+{
+    __debug("[SchedTaskArrayArray:%s]\n", __FUNCTION__);
+
+    // object creation をSchedTaskArray生成時にやらないので、
+    // exec の直前のread で十分に間に合う
+    loadSchedTask(scheduler, task);
+
+    // 読むデータが一つもなければ無視
+    if (task->inData_size == 0) return;
+
+    // load Input Data
+    readbuf = scheduler->allocate(task->inListData()->size);
+    scheduler->dma_loadList(task->inListData(), readbuf, DMA_READ);
+
+}
+
+
+void
+SchedTaskArray::exec()
+{
+    __debug("[SchedTaskArrayArray:%s]\n", __FUNCTION__);
+
+    scheduler->dma_wait(DMA_READ);
+    task_list[task->command].wait(scheduler,task->command);
+    task_list[task->command].run(this, readbuf, writebuf);
+    free(readbuf);
+    // 書き込む領域がなければ無視
+    if (task->outData_size > 0) {
+	writebuf = scheduler->allocate(task->outListData()->size);
+        scheduler->dma_storeList(task->outListData(), writebuf, DMA_WRITE);
+    }
+}
+
+void
+SchedTaskArray::write()
+{
+    __debug("[SchedTaskArrayArray:%s]\n", __FUNCTION__);
+
+    scheduler->dma_wait(DMA_WRITE);
+    free(writebuf);
+
+    // このTaskArrayは終り。終了を知らせる。
+    if (task->next() >= last()) {
+	scheduler->mail_write((memaddr)savedTask->task->self);
+	free(array);
+    }
+
+}
+
+Task *SchedTaskArray::last()
+{
+   return  (Task*)(((char*)array)+ savedTask->read_size());
+}
+
+SchedTaskBase*
+SchedTaskArray::next(Scheduler *scheduler, SchedTaskArrayBase *p)
+{
+    __debug("[SchedTaskArray:%s]\n", __FUNCTION__);
+
+
+    if (task->next() < last()) {
+	// Task List が残っているので、次を準備
+	return (SchedTaskBase*)new SchedTaskArray(savedTask, next, array);
+    } else {
+	// このTaskArrayは終り。save していた Task の次を返す。
+	// savedTask の read/exec は実行されない (command = TaskArray)
+	return savedTask->next();
+    }
+}
+
+
+
+/* end */

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/TaskManager/kernel/schedule/SchedTaskArray.h	Sat Dec 12 17:38:30 2009 +0900
@@ -0,0 +1,40 @@
+#ifndef INCLUDED_SCHED_TASK_ARRAY
+#define INCLUDED_SCHED_TASK_ARRAY
+
+#include "base.h"
+#include "Scheduler.h"
+#include "SchedTask.h"
+
+class SchedTaskArray : public SchedTask {
+public:
+    /* constructor */
+    SchedTaskArray(SchedTaskBase *savedTask_, Task *task_, Task *array_);
+    virtual ~SchedTaskArray();
+
+    BASE_NEW_DELETE(SchedTaskArray);
+
+    SchedTaskBase *savedTask;
+    Task *array;
+
+private:
+    /* variables */
+
+    void *readbuf;
+    void *writebuf;
+
+    TaskPtr task;
+    /* functions */
+    Task *last();
+
+    // override
+    void read();
+    void exec();
+    void write();
+    SchedTaskBase* next(Scheduler *, SchedTaskBase *);
+
+
+};
+
+
+#endif
+

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/TaskManager/kernel/schedule/SchedTaskArrayLoad.cc	Sat Dec 12 17:38:30 2009 +0900
@@ -0,0 +1,34 @@
+#include "SchedTaskArrayLoad.h"
+#include "SchedTaskArray.h"
+#include "Task.h"
+
+SchedTaskArrayLoad::SchedTaskArrayLoad(SchedTaskBase *savedTask_)
+{
+    savedTask = saveTask_;
+}
+
+~SchedTaskArrayLoad::SchedTaskArrayLoad() {}
+
+void
+SchedTaskArrayLoad::read()
+{
+    if (task->r_size == 0) return;
+    // load Task Array Data
+    readbuf = scheduler->allocate(task->r_size);
+    scheduler->dma_load(readbuf, task->rbuf,task->r_size, DMA_READ);
+}
+
+void
+SchedTaskArrayLoad::exec() {}  // to empty the pipeline
+
+void
+SchedTaskArrayLoad::write() {} // to empty the pipeline
+
+SchedTaskBase*
+SchedNop::next(Scheduler *scheduler, SchedTaskBase *p)
+{
+    Task *nextTask = (Task *)readbuf;
+    return new SchedTaskArray(savedTask, nextTask, nextTask);
+}
+
+/* end */

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/TaskManager/kernel/schedule/SchedTaskArrayLoad.h	Sat Dec 12 17:38:30 2009 +0900
@@ -0,0 +1,35 @@
+#ifndef INCLUDED_SCHED_TASK_ARRAY_LOAD
+#define INCLUDED_SCHED_TASK_ARRAY_LOAD
+
+#include "base.h"
+#include "Scheduler.h"
+#include "SchedTask.h"
+
+class SchedTaskArrayLoad : public SchedTask {
+public:
+    /* constructor */
+    SchedTaskArrayLoad(SchedTaskBase *savedTask_);
+    virtual ~SchedTaskArrayLoad();
+
+    BASE_NEW_DELETE(SchedTaskArrayLoad);
+
+    SchedTaskBase *savedTask;
+
+private:
+    /* variables */
+
+    TaskPtr task;
+    /* functions */
+
+    // override
+    void read();
+    void exec();
+    void write();
+    SchedTaskBase* next(Scheduler *, SchedTaskBase *);
+
+
+};
+
+
+#endif
+