Mercurial > hg > Members > kono > Cerium

changeset 945:a9c7784e5dae

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
sort example fix ( simple task accepts one param and more compatible with old task)
author Shinji KONO <kono@ie.u-ryukyu.ac.jp>
date Sun, 01 Aug 2010 19:29:27 +0900
parents 208e0478eaac
children a8b6ee80c108
files TaskManager/include/types.h TaskManager/kernel/ppe/HTask.h TaskManager/kernel/ppe/SimpleTask.h TaskManager/kernel/ppe/TaskManagerImpl.cc TaskManager/kernel/schedule/SchedTask.cc TaskManager/kernel/schedule/SchedTaskArray.cc TaskManager/kernel/sys_task/SysFunc.h TaskManager/kernel/sys_task/SysTasks.h example/many_task/Func.h example/many_task/main.cc example/many_task/ppe/QuickSort.cc example/many_task/sort-compat.cc example/many_task/sort.cc example/many_task/sort.h example/many_task/spe/QuickSort.cc example/many_task/task_init.cc
diffstat 16 files changed, 256 insertions(+), 224 deletions(-) [+]
line wrap: on
line diff
--- a/TaskManager/include/types.h	Sat Jul 31 21:40:30 2010 +0900
+++ b/TaskManager/include/types.h	Sun Aug 01 19:29:27 2010 +0900
@@ -40,6 +40,11 @@
 #define round_up16(value)  ROUND_UP_ALIGN(value, 16)
 #define round_up128(value) ROUND_UP_ALIGN(value, 128)
 
+#define TaskArray (-1)
+#define TaskArray1 (-2)
+
+// SPU 依存 (よろしくないが...)
+
 // ここも typedef しとくか？
 enum {
 // どの方向かで enum 分けるだろjk...
--- a/TaskManager/kernel/ppe/HTask.h	Sat Jul 31 21:40:30 2010 +0900
+++ b/TaskManager/kernel/ppe/HTask.h	Sun Aug 01 19:29:27 2010 +0900
@@ -91,8 +91,12 @@
 	t->set_param_t(param_index++, param);
     }
     void set_param_t(int index, memaddr param) {
-	Task *t = (Task*)rbuf;
-	t->set_param_t(index, param);
+	if (command==TaskArray1) {
+	    Task *t = (Task*)rbuf;
+	    t->set_param_t(index, param);
+	} else {
+	    this->param = param;
+	}
     }
 
     void no_auto_free() {
--- a/TaskManager/kernel/ppe/SimpleTask.h	Sat Jul 31 21:40:30 2010 +0900
+++ b/TaskManager/kernel/ppe/SimpleTask.h	Sun Aug 01 19:29:27 2010 +0900
@@ -18,7 +18,7 @@
     int  r_size;
     int  w_size;
     memaddr from;
-    int  dm1;       //  sizeof(SimpleTask)==32
+    memaddr param;       //  sizeof(SimpleTask)==32
 
 
 public: // functions
@@ -31,6 +31,8 @@
 
     void set_input(memaddr i,int size) { r_size = size; rbuf= i; }
     void set_output(memaddr o,int size) { w_size = size; wbuf= o; } 
+    void set_param(memaddr data) { param = data; }
+    memaddr get_param() { return param; }
 
 } __attribute__ ((aligned (DEFAULT_ALIGNMENT)));
 
--- a/TaskManager/kernel/ppe/TaskManagerImpl.cc	Sat Jul 31 21:40:30 2010 +0900
+++ b/TaskManager/kernel/ppe/TaskManagerImpl.cc	Sun Aug 01 19:29:27 2010 +0900
@@ -48,6 +48,9 @@
     // append_waitTask(systask_finish);
 }
 
+/**
+ *   Create Simple Task
+ */
 HTaskPtr
 TaskManagerImpl::create_task(int cmd,memaddr rbuf, long r_size, memaddr wbuf, long w_size, void *from) {
     HTaskPtr new_task;
@@ -60,6 +63,9 @@
     return new_task;
 }
 
+/**
+ *   Create Compatible Task (TaskArray1)
+ */
 HTaskPtr
 TaskManagerImpl::create_task(int cmd,void *from)
 {
@@ -77,6 +83,9 @@
     return new_task;
 }
 
+/**
+ *   Create Task Array
+ */
 HTaskPtr
 TaskManagerImpl::create_task_array(int id, int num_task, int num_param, int num_inData, int num_outData, void *from)
 {
--- a/TaskManager/kernel/schedule/SchedTask.cc	Sat Jul 31 21:40:30 2010 +0900
+++ b/TaskManager/kernel/schedule/SchedTask.cc	Sun Aug 01 19:29:27 2010 +0900
@@ -34,14 +34,10 @@
 
 }
 
-/**
- * dma_store の wait を行う
- */
 SchedTask::~SchedTask()
 {
 }
 
-
 void
 SchedTask::init(TaskListPtr _list, TaskPtr _task, int index, Scheduler* sc)
 {
@@ -164,16 +160,17 @@
     scheduler->free_(p);
 }
 
+/**
+ *    SimpleTask has one parameter , one input, one output
+ */
 
-void* SchedTask::get_input(void *buff, int index) {
-  scheduler->printf("Cannot use inData in SimpleTask use TaskArray\n");
-  return NULL; }
-memaddr SchedTask::get_inputAddr(int index) { return 0; }
-int SchedTask::get_inputSize(int index) {return 0; }
-void* SchedTask::get_output(void *buff, int index) {return 0; }
-memaddr SchedTask::get_outputAddr(int index) { return 0; }
-int SchedTask::get_outputSize(int index) { return 0; }
-memaddr SchedTask::get_param(int index) { return 0; }
+void* SchedTask::get_input(void *buff, int index) { return readbuf; }
+memaddr SchedTask::get_inputAddr(int index) { return task->rbuf; }
+int SchedTask::get_inputSize(int index) {return task->r_size; }
+void* SchedTask::get_output(void *buff, int index) {return writebuf; }
+memaddr SchedTask::get_outputAddr(int index) { return task->wbuf; }
+int SchedTask::get_outputSize(int index) { return task->w_size; }
+memaddr SchedTask::get_param(int index) { return task->param; }
 
 
 void*
--- a/TaskManager/kernel/schedule/SchedTaskArray.cc	Sat Jul 31 21:40:30 2010 +0900
+++ b/TaskManager/kernel/schedule/SchedTaskArray.cc	Sun Aug 01 19:29:27 2010 +0900
@@ -126,7 +126,7 @@
         //}
     }
     scheduler->dma_wait(DMA_READ);
-    run(this, readbuf, writebuf);
+    run(this, get_input(readbuf, 0), get_output(writebuf, 0));
     free(readbuf);
     // 書き込む領域がなければ無視
 
@@ -250,8 +250,7 @@
 int
 SchedTaskArray::read_size()
 {
-    printf("Don't use read_size() in TaskArray, use get_inputSize(index)\n");
-    return 0;
+    return get_inputSize(0);
 }
 
 
--- a/TaskManager/kernel/sys_task/SysFunc.h	Sat Jul 31 21:40:30 2010 +0900
+++ b/TaskManager/kernel/sys_task/SysFunc.h	Sun Aug 01 19:29:27 2010 +0900
@@ -1,3 +1,8 @@
+#ifndef SYSFUNCH
+#define SYSFUNCH
+
 enum systask {
 #include "SysTasks.h"
 };
+
+#endif
--- a/TaskManager/kernel/sys_task/SysTasks.h	Sat Jul 31 21:40:30 2010 +0900
+++ b/TaskManager/kernel/sys_task/SysTasks.h	Sun Aug 01 19:29:27 2010 +0900
@@ -3,5 +3,3 @@
 ShowTime,
 StartProfile,
 #define Dummy StartTask
-#define TaskArray (-1)
-#define TaskArray1 (-2)
--- a/example/many_task/Func.h	Sat Jul 31 21:40:30 2010 +0900
+++ b/example/many_task/Func.h	Sun Aug 01 19:29:27 2010 +0900
@@ -1,5 +1,6 @@
 enum {
 #include "SysTasks.h"
     QUICK_SORT,
-    RESTART,
+    SortSimple,
+    SortCompat,
 };
--- a/example/many_task/main.cc	Sat Jul 31 21:40:30 2010 +0900
+++ b/example/many_task/main.cc	Sun Aug 01 19:29:27 2010 +0900
@@ -3,10 +3,14 @@
 #include <stdlib.h>
 #include <sys/time.h>
 #include "TaskManager.h"
+#include "SchedTask.h"
+
 #include "Func.h"
 #include "sort.h"
 
-extern void task_init(void);
+extern void task_init();
+extern int get_split_num(int len, int num);
+
 
 // sort.cc
 extern int data_length;
@@ -14,6 +18,8 @@
 extern int all;
 int all = 0;
 
+static int sort_task = SortSimple;
+
 // 計測用
 static double st_time;
 static double ed_time;
@@ -24,7 +30,7 @@
 void TMend(TaskManager *);
 
 static double
-getTime(void)
+getTime()
 {
     struct timeval tv;
     gettimeofday(&tv, NULL);
@@ -58,12 +64,58 @@
         if (strcmp(argv[i], "-a") == 0 ) {
             all = 1;
         }
+        if (strcmp(argv[i], "-c") == 0 ) {
+            sort_task = SortCompat;
+        }
+        if (strcmp(argv[i], "-s") == 0 ) {
+            sort_task = SortSimple;
+        }
 
     }
 
     return 0;
 }
 
+Sort sorter;
+
+static void 
+check_data()
+{
+    for(int i=0; i< sorter.data_length-1;i++) {
+        if (sorter.data[i].index>sorter.data[i+1].index)  {
+            printf("Data are not sorted at %d. %d > %d \n",i, sorter.data[i].index,sorter.data[i+1].index);
+            return;
+        }
+    }
+    printf("Data are sorted\n");
+}
+
+
+static void
+sort_init(SchedTask *manager, void *a, void *b)
+{
+    sorter.cpuNum = (int)a;
+    int length = (int)b;
+
+    sorter.data = (DataPtr)manager->allocate(sizeof(Data)*length);
+    sorter.data_length = length;
+
+    sorter.split_num = get_split_num(sorter.data_length, sorter.cpuNum); // data の分割数
+    int half_num = sorter.split_num-1;
+    sorter.fsort = (HTaskPtr*)manager->allocate(sizeof(HTaskPtr)*sorter.split_num);
+    sorter.bsort = (HTaskPtr*)manager->allocate(sizeof(HTaskPtr)*half_num);
+    memset((void*)sorter.bsort,0, sizeof(HTaskPtr)*half_num);
+
+    for (int i = 0; i < length; i++) {
+        sorter.data[i].index = manager->get_random()%10000;
+        sorter.data[i].ptr   = i;
+    }
+
+    HTaskPtr restart = manager->create_task(sort_task,0,0,0,0);
+    restart->set_param(0,(memaddr)&sorter);
+    restart->spawn();
+}
+
 unsigned int ts, te;
 
 int
@@ -95,8 +147,6 @@
     return 0;
 }
 
-extern void check_data();
-
 void
 TMend(TaskManager *manager)
 {
--- a/example/many_task/ppe/QuickSort.cc	Sat Jul 31 21:40:30 2010 +0900
+++ b/example/many_task/ppe/QuickSort.cc	Sun Aug 01 19:29:27 2010 +0900
@@ -27,7 +27,7 @@
     Data *w_data = (Data*)wbuff;
 #endif
 #else
-    int end   = (int)s->get_param(0);
+    int end = s->get_inputSize(0)/sizeof(Data);
     DataPtr r_data = (DataPtr)s->get_input(0);
 #ifdef USE_MEMCPY
     DataPtr w_data = (DataPtr)s->get_output(0);
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/example/many_task/sort-compat.cc	Sun Aug 01 19:29:27 2010 +0900
@@ -0,0 +1,98 @@
+#include "TaskManager.h"
+#include "SchedTask.h"
+#include "sort.h"
+#include "Func.h"
+#include <string.h>
+
+extern void check_data();
+extern int all;  // allocate task at once
+
+SchedDefineTask1(SortCompat, sort_start_compat );
+
+static int sort_start_compat(SchedTask *manager, void *a, void *b)
+{
+    Sort *s = (Sort*)manager->get_param(0);
+    int half_num = s->split_num-1;
+    static int sort_count = s->split_num; // sort 完了に必要な回数
+
+    // 一つのタスクで sort する data 数
+    int block_num = (s->data_length + s->split_num -1)/s->split_num;
+    int half_block_num = block_num/2;
+
+    int last_block_num = s->data_length - (s->split_num-1)*block_num;
+    int last_half_block_num = half_block_num+(last_block_num/2);
+
+
+    if (--sort_count < 0) {
+	return 0;
+    }
+
+    for (int i = 0; i < s->split_num-1; i++) {
+	s->fsort[i] = manager->create_task(QUICK_SORT);
+	s->fsort[i]->add_inData(&s->data[i*block_num], sizeof(Data)*block_num);
+	s->fsort[i]->add_outData(&s->data[i*block_num], sizeof(Data)*block_num);
+	if (i>0 && s->bsort[i-1]) {
+	    s->fsort[i]->wait_for(s->bsort[i-1]);
+	}
+	if (i<s->split_num-2 && s->bsort[i]) {
+	    s->fsort[i]->wait_for(s->bsort[i]);
+	}
+	s->fsort[i]->set_cpu(SPE_ANY);
+    }
+
+    // 最後の block は端数なので last_block_num を使う
+    {
+	int i = s->split_num-1;
+
+	s->fsort[i] = manager->create_task(QUICK_SORT);
+	s->fsort[i]->add_inData(&s->data[i*block_num], sizeof(Data)*last_block_num);
+	s->fsort[i]->add_outData(&s->data[i*block_num], sizeof(Data)*last_block_num);
+	if (i>0 && s->bsort[i-1]) {
+	    s->fsort[i]->wait_for(s->bsort[i-1]);
+	}
+	s->fsort[i]->set_cpu(SPE_ANY);
+   }
+
+    if (s->split_num > 1) {
+
+	for (int i = 0; i < half_num-1; i++) {
+	    if (s->bsort[i]) manager->free_htask(s->bsort[i]);
+	    s->bsort[i] = manager->create_task(QUICK_SORT);
+	    s->bsort[i]->add_inData(&s->data[i*block_num+half_block_num],
+				 sizeof(Data)*block_num);
+	    s->bsort[i]->add_outData(&s->data[i*block_num+half_block_num],
+				  sizeof(Data)*block_num);
+	    s->bsort[i]->set_cpu(SPE_ANY);
+	}
+
+	{
+	    int i = half_num-1;
+
+	    if (s->bsort[i]) manager->free_htask(s->bsort[i]);
+	    s->bsort[i] = manager->create_task(QUICK_SORT);
+	    s->bsort[i]->add_inData(&s->data[i*block_num+half_block_num],
+				 sizeof(Data)*last_half_block_num);
+	    s->bsort[i]->add_outData(&s->data[i*block_num+half_block_num],
+				  sizeof(Data)*last_half_block_num);
+	    s->bsort[i]->set_cpu(SPE_ANY);	
+	}
+	
+	for (int i = 0; i < half_num; i++) {
+	    s->bsort[i]->wait_for(s->fsort[i]);
+	    s->bsort[i]->wait_for(s->fsort[i+1]);
+	    s->bsort[i]->no_auto_free();
+	    s->bsort[i]->spawn();
+	}
+    }
+
+    HTaskPtr restart = manager->create_task(SortCompat,0,0,0,0);
+    restart->set_param(0,(memaddr)s);
+    if (!all) restart->wait_for(s->fsort[0]);
+    for (int i = 0; i < s->split_num; i++) {
+	s->fsort[i]->spawn();
+    }
+    restart->spawn();
+
+    return 0;
+}
+
--- a/example/many_task/sort.cc	Sat Jul 31 21:40:30 2010 +0900
+++ b/example/many_task/sort.cc	Sun Aug 01 19:29:27 2010 +0900
@@ -4,14 +4,9 @@
 #include "Func.h"
 #include <string.h>
 
-extern void check_data();
+extern int get_split_num(int len, int num);
 extern int all;  // allocate task at once
 
-static void sort_start(SchedTask *);
-static int data_length;
-static int cpuNum;
-static int split_num;
-
 /**
  * 一つの block にある data の数が MAX_BLOCK_SIZE 超えないような
  * len の分割数を返す
@@ -24,7 +19,7 @@
  * TODO:
  *   len が num 以下とか考えてません
  */
-static int
+int
 get_split_num(int len, int num)
 {
     if (len / num < MAX_BLOCK_SIZE) {
@@ -36,235 +31,95 @@
 }	
 
 
-static HTaskPtr *fsort;
-static HTaskPtr *bsort;
-
-static DataPtr data;
-
 /**
  * btask が全て終了したら、再び sort_start を実行する
  * @param d 生成された btask の数
  */
 
-SchedDefineTask1(RESTART, sort_restart );
+SchedDefineTask1(SortSimple, sort_start );
 
 static int
-sort_restart(SchedTask *s, void *d, void *e)
+sort_start(SchedTask *manager, void *d, void *e)
 {
-    // static int ccc = 0;
-
-    // printf("restarted %d %% %d\n",ccc++,split_num);
-    sort_start(s);
-    return 0;
-}
-#ifdef USE_SIMPLE_TASK
-
-static void
-sort_start(SchedTask *manager)
-{
-    int half_num = split_num-1;
-    static int sort_count = split_num; // sort 完了に必要な回数
+    Sort *s =  (Sort*)manager->get_param(0);
+    int half_num = s->split_num-1;
+    static int sort_count = s->split_num; // sort 完了に必要な回数
 
     // 一つのタスクで sort する data 数
-    int block_num = (data_length + split_num -1)/split_num;
+    int block_num = (s->data_length + s->split_num -1)/s->split_num;
     int half_block_num = block_num/2;
 
-    int last_block_num = data_length - (split_num-1)*block_num;
+    int last_block_num = s->data_length - (s->split_num-1)*block_num;
     int last_half_block_num = half_block_num+(last_block_num/2);
 
     if (--sort_count < 0) {
-	return;
+	return 0;
     }
 
 
-    for (int i = 0; i < split_num-1; i++) {
-	fsort[i] = manager->create_task(QUICK_SORT,
-	    (memaddr)&data[i*block_num], sizeof(Data)*block_num,
-	    (memaddr)&data[i*block_num], sizeof(Data)*block_num);
-	if (i>0 && bsort[i-1]) {
-	    fsort[i]->wait_for(bsort[i-1]);
+    for (int i = 0; i < s->split_num-1; i++) {
+	s->fsort[i] = manager->create_task(QUICK_SORT,
+	    (memaddr)&s->data[i*block_num], sizeof(Data)*block_num,
+	    (memaddr)&s->data[i*block_num], sizeof(Data)*block_num);
+	if (i>0 && s->bsort[i-1]) {
+	    s->fsort[i]->wait_for(s->bsort[i-1]);
 	}
-	if (i<split_num-2 && bsort[i]) {
-	    fsort[i]->wait_for(bsort[i]);
+	if (i<s->split_num-2 && s->bsort[i]) {
+	    s->fsort[i]->wait_for(s->bsort[i]);
 	}
-	fsort[i]->set_cpu(SPE_ANY);
+	s->fsort[i]->set_cpu(SPE_ANY);
     }
 
     // 最後の block は端数なので last_block_num を使う
     {
-	int i = split_num-1;
+	int i = s->split_num-1;
 
-	fsort[i] = manager->create_task(QUICK_SORT,
-	    (memaddr)&data[i*block_num], sizeof(Data)*last_block_num,
-	    (memaddr)&data[i*block_num], sizeof(Data)*last_block_num);
-	if (i>0 && bsort[i-1]) {
-	    fsort[i]->wait_for(bsort[i-1]);
+	s->fsort[i] = manager->create_task(QUICK_SORT,
+	    (memaddr)&s->data[i*block_num], sizeof(Data)*last_block_num,
+	    (memaddr)&s->data[i*block_num], sizeof(Data)*last_block_num);
+	if (i>0 && s->bsort[i-1]) {
+	    s->fsort[i]->wait_for(s->bsort[i-1]);
 	}
-	fsort[i]->set_cpu(SPE_ANY);
+	s->fsort[i]->set_cpu(SPE_ANY);
    }
 
-    if (split_num > 1) {
+    if (s->split_num > 1) {
 
 	for (int i = 0; i < half_num-1; i++) {
-	    if (bsort[i]) manager->free_htask(bsort[i]);
-	    bsort[i] = manager->create_task(QUICK_SORT,
-		(memaddr)&data[i*block_num+half_block_num], sizeof(Data)*block_num,
-		(memaddr)&data[i*block_num+half_block_num], sizeof(Data)*block_num);
-	    bsort[i]->set_cpu(SPE_ANY);
+	    if (s->bsort[i]) manager->free_htask(s->bsort[i]);
+	    s->bsort[i] = manager->create_task(QUICK_SORT,
+		(memaddr)&s->data[i*block_num+half_block_num], sizeof(Data)*block_num,
+		(memaddr)&s->data[i*block_num+half_block_num], sizeof(Data)*block_num);
+	    s->bsort[i]->set_cpu(SPE_ANY);
 	}
 
 	{
 	    int i = half_num-1;
 
-	    if (bsort[i]) manager->free_htask(bsort[i]);
-	    bsort[i] = manager->create_task(QUICK_SORT,
-		(memaddr)&data[i*block_num+half_block_num], sizeof(Data)*last_half_block_num,
-		(memaddr)&data[i*block_num+half_block_num], sizeof(Data)*last_half_block_num);
-	    bsort[i]->set_cpu(SPE_ANY);	
+	    if (s->bsort[i]) manager->free_htask(s->bsort[i]);
+	    s->bsort[i] = manager->create_task(QUICK_SORT,
+		(memaddr)&s->data[i*block_num+half_block_num], sizeof(Data)*last_half_block_num,
+		(memaddr)&s->data[i*block_num+half_block_num], sizeof(Data)*last_half_block_num);
+	    s->bsort[i]->set_cpu(SPE_ANY);	
 	}
 	
 	for (int i = 0; i < half_num; i++) {
-	    bsort[i]->wait_for(fsort[i]);
-	    bsort[i]->wait_for(fsort[i+1]);
-	    bsort[i]->no_auto_free();
-	    bsort[i]->spawn();
+	    s->bsort[i]->wait_for(s->fsort[i]);
+	    s->bsort[i]->wait_for(s->fsort[i+1]);
+	    s->bsort[i]->no_auto_free();
+	    s->bsort[i]->spawn();
 	}
     }
 
-    HTaskPtr restart = manager->create_task(RESTART,0,0,0,0);
-    for (int i = 0; i < split_num; i++) {
-	if (!all) restart->wait_for(fsort[i]);
-	fsort[i]->spawn();
+    HTaskPtr restart = manager->create_task(SortSimple,0,0,0,0);
+    restart->set_param(0,(memaddr)s);
+    if (!all) restart->wait_for(s->fsort[0]);
+    for (int i = 0; i < s->split_num; i++) {
+	s->fsort[i]->spawn();
     }
     restart->spawn();
-}
-
-#else
-
-static void
-sort_start(SchedTask *manager)
-{
-    int half_num = split_num-1;
-    static int sort_count = split_num; // sort 完了に必要な回数
-
-    // 一つのタスクで sort する data 数
-    int block_num = (data_length + split_num -1)/split_num;
-    int half_block_num = block_num/2;
-
-    int last_block_num = data_length - (split_num-1)*block_num;
-    int last_half_block_num = half_block_num+(last_block_num/2);
-
-
-    if (--sort_count < 0) {
-	return;
-    }
-
-
-    for (int i = 0; i < split_num-1; i++) {
-	fsort[i] = manager->create_task(QUICK_SORT);
-	fsort[i]->add_inData(&data[i*block_num], sizeof(Data)*block_num);
-	fsort[i]->add_outData(&data[i*block_num], sizeof(Data)*block_num);
-	fsort[i]->set_param(0,(memaddr)block_num);
-	if (i>0 && bsort[i-1]) {
-	    fsort[i]->wait_for(bsort[i-1]);
-	}
-	if (i<split_num-2 && bsort[i]) {
-	    fsort[i]->wait_for(bsort[i]);
-	}
-	fsort[i]->set_cpu(SPE_ANY);
-    }
-
-    // 最後の block は端数なので last_block_num を使う
-    {
-	int i = split_num-1;
-
-	fsort[i] = manager->create_task(QUICK_SORT);
-	fsort[i]->add_inData(&data[i*block_num], sizeof(Data)*last_block_num);
-	fsort[i]->add_outData(&data[i*block_num], sizeof(Data)*last_block_num);
-	fsort[i]->set_param(0,(memaddr)last_block_num);
-	if (i>0 && bsort[i-1]) {
-	    fsort[i]->wait_for(bsort[i-1]);
-	}
-	fsort[i]->set_cpu(SPE_ANY);
-   }
-
-    if (split_num > 1) {
-
-	for (int i = 0; i < half_num-1; i++) {
-	    if (bsort[i]) manager->free_htask(bsort[i]);
-	    bsort[i] = manager->create_task(QUICK_SORT);
-	    bsort[i]->add_inData(&data[i*block_num+half_block_num],
-				 sizeof(Data)*block_num);
-	    bsort[i]->add_outData(&data[i*block_num+half_block_num],
-				  sizeof(Data)*block_num);
-	    bsort[i]->set_param(0,(memaddr)block_num);
-	    bsort[i]->set_cpu(SPE_ANY);
-	}
-
-	{
-	    int i = half_num-1;
-
-	    if (bsort[i]) manager->free_htask(bsort[i]);
-	    bsort[i] = manager->create_task(QUICK_SORT);
-	    bsort[i]->add_inData(&data[i*block_num+half_block_num],
-				 sizeof(Data)*last_half_block_num);
-	    bsort[i]->add_outData(&data[i*block_num+half_block_num],
-				  sizeof(Data)*last_half_block_num);
-	    bsort[i]->set_param(0,(memaddr)last_half_block_num);
-	    bsort[i]->set_cpu(SPE_ANY);	
-	}
-	
-	for (int i = 0; i < half_num; i++) {
-	    bsort[i]->wait_for(fsort[i]);
-	    bsort[i]->wait_for(fsort[i+1]);
-	    bsort[i]->no_auto_free();
-	    bsort[i]->spawn();
-	}
-    }
-
-    HTaskPtr restart = manager->create_task(RESTART,0,0,0,0);
-    for (int i = 0; i < split_num; i++) {
-	if (!all) restart->wait_for(fsort[i]);
-	fsort[i]->spawn();
-    }
-    restart->spawn();
-}
-
-#endif
-
-void check_data()
-{
-    for(int i=0; i< data_length-1;i++) {
-	if (data[i].index>data[i+1].index)  {
-	    printf("Data are not sorted at %d. %d > %d \n",i, data[i].index,data[i+1].index);
-	    return;
-	}
-    }
-    printf("Data are sorted\n");
+    return 0;
 }
 
 
-void
-sort_init(SchedTask *manager, void *a, void *b)
-{
-    cpuNum = (int)a;
-    int length = (int)b;
-
-    data = (DataPtr)manager->allocate(sizeof(Data)*length);
-    data_length = length;
-
-    split_num = get_split_num(data_length, cpuNum); // data の分割数
-    int half_num = split_num-1;
-    fsort = (HTaskPtr*)manager->allocate(sizeof(HTaskPtr)*split_num);
-    bsort = (HTaskPtr*)manager->allocate(sizeof(HTaskPtr)*half_num);
-    memset((void*)bsort,0, sizeof(HTaskPtr)*half_num);
-
-    for (int i = 0; i < length; i++) { 
-        data[i].index = manager->get_random()%10000;
-        data[i].ptr   = i;
-    }
-
-    sort_start(manager);
-}
-
 /* end */
--- a/example/many_task/sort.h	Sat Jul 31 21:40:30 2010 +0900
+++ b/example/many_task/sort.h	Sun Aug 01 19:29:27 2010 +0900
@@ -1,13 +1,20 @@
 #include "TaskManager.h"
 
-// array position
 typedef struct Data {
     int index;
     int ptr;
     int pad[2];
 } Data, *DataPtr;
 
-extern void sort_init(SchedTask *,void *, void *);
+typedef struct sort {
+    int data_length;
+    int cpuNum;
+    int split_num;
+    HTaskPtr *fsort;
+    HTaskPtr *bsort;
+    DataPtr data;
+} Sort, *SortPtr;
+
 
 
 #define MAX_BLOCK_SIZE (int)(1024*16/(sizeof(Data)))
--- a/example/many_task/spe/QuickSort.cc	Sat Jul 31 21:40:30 2010 +0900
+++ b/example/many_task/spe/QuickSort.cc	Sun Aug 01 19:29:27 2010 +0900
@@ -27,7 +27,7 @@
     Data *w_data = (Data*)wbuff;
 #endif
 #else
-    int end   = (int)s->get_param(0);
+    int end = s->get_inputSize(0)/sizeof(Data);
     DataPtr r_data = (DataPtr)s->get_input(0);
 #ifdef USE_MEMCPY
     DataPtr w_data = (DataPtr)s->get_output(0);
--- a/example/many_task/task_init.cc	Sat Jul 31 21:40:30 2010 +0900
+++ b/example/many_task/task_init.cc	Sun Aug 01 19:29:27 2010 +0900
@@ -2,11 +2,13 @@
 #include "Scheduler.h"
 
 SchedExternTask(QuickSort);
-SchedExternTask(RESTART);
+SchedExternTask(SortSimple);
+SchedExternTask(SortCompat);
 
 void
 task_init(void)
 {
     SchedRegisterTask(QUICK_SORT, QuickSort);
-    SchedRegister(RESTART);
+    SchedRegister(SortSimple);
+    SchedRegister(SortCompat);
 }