--- a/TaskManager/Cell/CellTaskManagerImpl.cc	Mon Oct 05 08:56:56 2009 +0900
+++ b/TaskManager/Cell/CellTaskManagerImpl.cc	Mon Oct 05 10:36:37 2009 +0900
@@ -53,6 +53,7 @@
     } 
     // PPE 側の管理をする Manager
     ppeManager = new FifoTaskManagerImpl(machineNum);
+    // 大半のTaskQueueInfoは、共有される
     ppeManager->init(new PpeScheduler, this);
 }
 
@@ -185,7 +186,7 @@
 CellTaskManagerImpl::mail_check(MailQueuePtr mail_list)
 {
     // PPE Scheduler からの mail check
-    ppeManager->mail_check(mail_list, &waitTaskQueue);
+    ppeManager->mail_check(mail_list);
 
     do {
 	unsigned int data;

--- a/TaskManager/Fifo/FifoTaskManagerImpl.cc	Mon Oct 05 08:56:56 2009 +0900
+++ b/TaskManager/Fifo/FifoTaskManagerImpl.cc	Mon Oct 05 10:36:37 2009 +0900
@@ -66,9 +66,12 @@
     taskListImpl  = tm-> taskListImpl  ;
     taskQueueImpl = tm-> taskQueueImpl ;
     htaskImpl     = tm-> htaskImpl     ;
+    waitTaskQueue     = tm->waitTaskQueue; 
+    // activeQueue は?
 
     mainTaskList = taskListImpl->create();
 
+
 }
 
 /**
@@ -219,13 +222,6 @@
     }
 }
 
-void
-FifoTaskManagerImpl::mail_check(MailQueuePtr mail_list, TaskQueuePtr *wait)
-{
-    waitTaskQueue = *wait;
-    mail_check(mail_list);
-}
-
 void*
 FifoTaskManagerImpl::allocate(int size)
 {

--- a/TaskManager/Fifo/FifoTaskManagerImpl.h	Mon Oct 05 08:56:56 2009 +0900
+++ b/TaskManager/Fifo/FifoTaskManagerImpl.h	Mon Oct 05 10:36:37 2009 +0900
@@ -13,7 +13,7 @@
 
     /* variables */
     int machineNum;
-    TaskListPtr mainTaskList;
+    TaskListPtr mainTaskList;  // activeTask であるべきなんじゃないの?
 
     MailManager *mailManager;
     MainScheduler *scheduler;
@@ -24,7 +24,6 @@
     void init(MainScheduler*, TaskManagerImpl*);
     void run(void);
     void mail_check(MailQueuePtr mail_list);
-    void mail_check(MailQueuePtr mail_list, TaskQueuePtr *waitQueue);
     TaskListPtr get_runTaskList(void);
     MailQueuePtr schedule(TaskListPtr);
 

--- a/TaskManager/kernel/ppe/HTask.h	Mon Oct 05 08:56:56 2009 +0900
+++ b/TaskManager/kernel/ppe/HTask.h	Mon Oct 05 10:36:37 2009 +0900
@@ -6,6 +6,7 @@
 #include "Task.h"
 #include "TaskQueueInfo.h"
 
+class TaskQueueInfo;
 class TaskManagerImpl;
 
 /*!
@@ -23,8 +24,8 @@
 public:
     BASE_NEW_DELETE(HTask);
 
-    TaskQueuePtr wait_me;  // List of task waiting for me
-    TaskQueuePtr wait_i;   // List of task for which I am waiting
+    TaskQueueInfo *wait_me;  // List of task waiting for me
+    TaskQueueInfo *wait_i;   // List of task for which I am waiting
     void (*post_func)(void *arg);
     void *post_arg;
     CPU_TYPE cpu_type;

--- a/TaskManager/kernel/ppe/TaskManagerImpl.cc	Mon Oct 05 08:56:56 2009 +0900
+++ b/TaskManager/kernel/ppe/TaskManagerImpl.cc	Mon Oct 05 10:36:37 2009 +0900
@@ -62,8 +62,9 @@
     m = taskQueueImpl->create(master);
     s = taskQueueImpl->create(slave);
 
-    master->wait_me = TaskQueue::append(master->wait_me, s);
-    slave->wait_i   = TaskQueue::append(slave->wait_i, m);
+    master->wait_me->addLast(s);
+    slave->wait_i->addLast(m);
+    m->waiter = s;
 }
 
 /**
@@ -91,10 +92,8 @@
 void
 TaskManagerImpl::append_activeTask(HTaskPtr task)
 {
-    TaskQueuePtr q;
-
-    q = taskQueueImpl->create(task);
-    activeTaskQueue = TaskQueue::append(activeTaskQueue, q);
+    TaskQueuePtr q = taskQueueImpl->create(task);
+    activeTaskQueue->addLast(q);
 }
 
 /**
@@ -112,46 +111,36 @@
 /**
  * 終了したタスクから依存の処理とか
  * post_func() はこのタスクが終了したら実行する関数。
- * 今のところ使ってないっす
  *
  * @param [task] 終了したタスク
  */
 void
 TaskManagerImpl::check_task_finish(HTaskPtr task)
 {
-    notify_wait_taskQueue(task, task->wait_me);
+    TaskQueue *p = task->wait_me->getFirst();
+    while(p) {
+	TaskQueue *next = p->next;
+	HTaskPtr htask = (HTaskPtr)p->task;
+	TaskQueueInfo *wait_i = htask->wait_i;
+	// 相手の wait queue から自分(を指しているTaskQueue)を削除
+	wait_i->remove(p->waiter);
+
+	// queue を free する
+	wait_i->free(p->waiter);
+	wait_i->free(p);
+	p = next;
+    }
+
     task->post_func(task->post_arg);
     htaskImpl->free(task);
 }
 
-/**
- * 終了したタスク [depend] を待っている TaskList に
- * 終わった事を知らせる(削除する
- */
-void
-TaskManagerImpl::notify_wait_taskQueue(HTaskPtr depend, TaskQueuePtr list)
-{
-    TaskQueuePtr p;
-    HTaskPtr task;
-
-    p = list; // wait task list
-
-    while (p) {
-        task = (HTaskPtr)p->task;
-        task->wait_i = remove_taskQueue_eq_task(task->wait_i, depend);
-        p = p->next;
-    }
-
-    remove_taskQueue_all(list);
-}
 
 void
 TaskManagerImpl::append_waitTask(HTaskPtr task)
 {
-    TaskQueuePtr q;
-
-    q = taskQueueImpl->create(task);
-    waitTaskQueue = TaskQueue::append(waitTaskQueue, q);
+    TaskQueuePtr q = taskQueueImpl->create(task);
+    waitTaskQueue ->addLast(q);
 }
 
 /**
@@ -161,87 +150,16 @@
 void
 TaskManagerImpl::wakeup_waitTask(void)
 {
-    TaskQueuePtr p, tmp;
-
-    p = waitTaskQueue;
+    TaskQueuePtr p = waitTaskQueue->getFirst();
     while (p) {
         HTaskPtr task = (HTaskPtr)p->task;
-        tmp = p;
-        p = p->next;
+        TaskQueue *next = p->next;
         if (task->wait_i == NULL) {
-            append_activeTask(task);
-            waitTaskQueue = remove_taskQueue(waitTaskQueue, tmp);
+	    waitTaskQueue->remove(p);
+	    activeTaskQueue->addLast(p);
         }
-    }
-}
-
-void
-TaskManagerImpl::remove_taskQueue_all(TaskQueuePtr list)
-{
-    TaskQueuePtr p = list;
-    TaskQueuePtr p1;
-
-    while (p != NULL) {
-        p1 = p->next;
-        taskQueueImpl->free(p);
-        p = p1;
+	p = next;
     }
 }
 
-/**
- * [list] が持つ queue->task の中に [task] と同じ奴があれば
- * 削除する。まあ remove_taskQueue() の HTask で比較するverです。
- * こういうのはオーバーロードでやるもんなのかな？
- */
-TaskQueuePtr
-TaskManagerImpl::remove_taskQueue_eq_task(TaskQueuePtr list, HTaskPtr task)
-{
-    TaskQueuePtr p = list;
-    TaskQueuePtr p1;
-
-    if (p == NULL) return p;
-
-    if (p->task == task) {
-        list = list->next;
-        taskQueueImpl->free(p);
-    } else {
-        p1 = p->next;
-        while (p1 && p1->task && p1->task != task) {
-            p1 = p1->next;
-            p = p->next;
-        }
-        if (p1) {
-            p->next = p1->next;
-            taskQueueImpl->free(p1);
-        }
-    }
-
-    return list;
-}
-
-TaskQueuePtr
-TaskManagerImpl::remove_taskQueue(TaskQueuePtr list, TaskQueuePtr q)
-{
-    TaskQueuePtr p = list;
-    TaskQueuePtr p1;
-
-    if (!p) return p;
-
-    if (p == q) {
-        list = list->next;
-        taskQueueImpl->free(p);
-    } else {
-        p1 = p->next;
-        while (p1 && p1 != q) {
-            p1 = p1->next;
-            p = p->next;
-        }
-        if (p1) {
-            p->next = p1->next;
-            taskQueueImpl->free(p1);
-        }
-    }
-
-    return list;
-}
-
+/* end */

--- a/TaskManager/kernel/ppe/TaskManagerImpl.h	Mon Oct 05 08:56:56 2009 +0900
+++ b/TaskManager/kernel/ppe/TaskManagerImpl.h	Mon Oct 05 10:36:37 2009 +0900
@@ -17,8 +17,8 @@
 
     /* variables */
     int machineNum;
-    TaskQueuePtr activeTaskQueue;
-    TaskQueuePtr waitTaskQueue;
+    TaskQueueInfo *activeTaskQueue;
+    TaskQueueInfo *waitTaskQueue;
 
     /* variables */
     TaskListInfo *taskListImpl;
@@ -33,10 +33,6 @@
     virtual void append_waitTask(HTaskPtr);
 
     void check_task_finish(HTaskPtr task);
-    void notify_wait_taskQueue(HTaskPtr depend, TaskQueuePtr list);
-    TaskQueuePtr remove_taskQueue(TaskQueuePtr list, TaskQueuePtr task);
-    TaskQueuePtr remove_taskQueue_eq_task(TaskQueuePtr list, HTaskPtr task);
-    void remove_taskQueue_all(TaskQueuePtr list);
     void wakeup_waitTask(void);
 
     void systask_init(void);

--- a/TaskManager/kernel/ppe/TaskQueue.cc	Mon Oct 05 08:56:56 2009 +0900
+++ b/TaskManager/kernel/ppe/TaskQueue.cc	Mon Oct 05 10:36:37 2009 +0900
@@ -1,21 +1,10 @@
 #include "TaskQueue.h"
 
-TaskQueue::TaskQueue(TaskPtr q)
+TaskQueue::TaskQueue(Task *q)
 {
     task = q;
     next = NULL;
+    prev = NULL;
+    waiter = NULL;
 }
 
-TaskQueuePtr
-TaskQueue::append(TaskQueuePtr list, TaskQueuePtr q)
-{
-    TaskQueuePtr p = list;
-
-    if (!p) {
-	return q;
-    } else {
-	while(p->next) p = p->next;
-	p->next = q;
-	return list;
-    }
-}

--- a/TaskManager/kernel/ppe/TaskQueue.h	Mon Oct 05 08:56:56 2009 +0900
+++ b/TaskManager/kernel/ppe/TaskQueue.h	Mon Oct 05 10:36:37 2009 +0900
@@ -2,20 +2,20 @@
 #define INCLUDED_TASK_QUEUE
 
 #include "base.h"
-#include "Task.h"
 
-#include <stdio.h>
+class Task;
 
 class TaskQueue {
 public:
-    TaskQueue(TaskPtr q = NULL);
+    TaskQueue(Task *q = NULL);
 
     BASE_NEW_DELETE(TaskQueue);
 
-    TaskPtr task;
-    class TaskQueue *next;
+    Task *task;
+    TaskQueue *next;
+    TaskQueue *prev;
 
-    static TaskQueue* append(TaskQueue* list, TaskQueue* q);
+    TaskQueue *waiter;
 };
 
 typedef TaskQueue* TaskQueuePtr;

--- a/TaskManager/kernel/ppe/TaskQueueInfo.cc	Mon Oct 05 08:56:56 2009 +0900
+++ b/TaskManager/kernel/ppe/TaskQueueInfo.cc	Mon Oct 05 10:36:37 2009 +0900
@@ -13,6 +13,8 @@
     if (taskQueuePool == NULL) {
 	return extend_pool(num);
     }
+    // 最初の一つは自分
+    next = prev = this;
     return 0;
 }
 
@@ -51,7 +53,7 @@
     freeTaskQueue = freeTaskQueue->next;
 
     q->task = task;
-    q->next = NULL;
+    q->next = q->prev = NULL;
 
     return q;
 }
@@ -61,6 +63,7 @@
 TaskQueueInfo::free(TaskQueuePtr q)
 {
     q->next = freeTaskQueue;
+    q->prev = NULL;
     freeTaskQueue = q;
 }
 
@@ -86,3 +89,120 @@
 
 
 }
+
+
+/*!
+  TaskQueueInfo は空にならない。最低1個は要素が入っていて
+  1個目は特別扱いする。getFirst すると first->next を返す
+ */
+
+/*!
+  最初の1個は特別扱いなので、それの後に追加していく
+ */
+void
+TaskQueueInfo::addFirst(TaskQueue* e)
+{
+    e->prev = first;
+    e->next = first->next;
+    first->next->prev = e;
+    first->next = e;
+}
+
+void
+TaskQueueInfo::addLast(TaskQueue* e)
+{
+    e->next = first;
+    e->prev = last;
+    last->next = e;
+    last = e;
+}
+
+TaskQueue*
+TaskQueueInfo::getFirst()
+{
+    return first->next;
+}
+
+TaskQueue*
+TaskQueueInfo::getLast()
+{
+    return last;
+}
+
+int
+TaskQueueInfo::remove(TaskQueue* e)
+{
+    e->prev->next = e->next;
+    e->next->prev = e->prev;
+
+    if (first->next == e) {
+	first->next = e->next;
+    }
+    if (last == e) {
+	last = e->prev;
+    }
+
+    e->prev = NULL;
+    e->next = NULL;
+
+    return 1;
+}
+
+/*!
+  リストの先頭を取得および削除する。リストが空の場合は NULL を返す。
+ */
+
+TaskQueue*
+TaskQueueInfo::poll()
+{
+    TaskQueue* e = first->next;
+    if (e == this) {
+	return NULL;
+    }
+    remove(e);
+    return e;
+}
+
+void
+TaskQueueInfo::moveToFirst(TaskQueue* e)
+{
+    remove(e);
+    addFirst(e);
+}
+
+/*!
+  リスト内の指定された位置にある要素を返す。
+  要素数を超えた位置を指定した場合 NULL を返す。
+ */
+
+TaskQueue*
+TaskQueueInfo::get(int index)
+{
+    TaskQueue* e = first->next;
+    for (int i = 0; i < index; i++) {
+	if (e == this) return NULL;
+	e = e->next;
+    }
+    return e;
+}
+
+TaskQueue*
+TaskQueueInfo::find(Task* task)
+{
+    TaskQueue* e = first->next;
+    for(;;) {
+	if (e == this) return NULL;
+	if (e->task == task) return e;
+	e = e->next;
+    }
+    return e;
+}
+
+int
+TaskQueueInfo::empty()
+{
+    return next == this;
+}
+
+
+/* end */

--- a/TaskManager/kernel/ppe/TaskQueueInfo.h	Mon Oct 05 08:56:56 2009 +0900
+++ b/TaskManager/kernel/ppe/TaskQueueInfo.h	Mon Oct 05 10:36:37 2009 +0900
@@ -1,9 +1,10 @@
 #ifndef INCLUDED_TASK_QUEUE_INFO
 #define INCLUDED_TASK_QUEUE_INFO
 
+#include "Task.h"
 #include "TaskQueue.h"
 
-class TaskQueueInfo {
+class TaskQueueInfo : public TaskQueue {
 public:
     /* constructor */
     TaskQueueInfo();
@@ -11,14 +12,29 @@
 
     /* functions */
     int init(int num);
-    TaskQueuePtr create(TaskPtr task);
+    TaskQueuePtr create(Task *task);
     void free(TaskQueuePtr queue);
-    
+
+    void addFirst(TaskQueue* e);
+    void addLast(TaskQueue* e);
+    TaskQueue* getFirst();
+    TaskQueue* getLast();
+    int remove(TaskQueue* e);
+    TaskQueue* poll();
+    void moveToFirst(TaskQueue* e); // or use();
+    TaskQueue* get(int index);
+    TaskQueue* find(Task *task);
+    int empty();
+ 
 private:
     /* variables */
     TaskQueuePtr taskQueuePool;
     TaskQueuePtr freeTaskQueue;
 
+    TaskQueue* first;
+    TaskQueue* last;
+
+
     /* functions */
     int extend_pool(int num);
     void destroy();  

--- a/TaskManager/kernel/schedule/TaskGroup.cc	Mon Oct 05 08:56:56 2009 +0900
+++ b/TaskManager/kernel/schedule/TaskGroup.cc	Mon Oct 05 10:36:37 2009 +0900
@@ -3,30 +3,15 @@
 void
 TaskGroup::add(TaskPtr add_task) {
     TaskQueuePtr q = new TaskQueue(add_task);
-    group = TaskQueue::append(group, q);
+    group->addLast(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;
-	}
-    }
+    // Task は TaskQueue を知らないので探し出す必要がある (HTask は知っている)
+    TaskQueue *p = group->find(delete_task);
+    group->remove(p);
+    group->free(p);
 }
 
 /**
@@ -36,20 +21,12 @@
  * command を返す。
  */
 unsigned int
-TaskGroup::status(void) {
+TaskGroup::status() {
     /**                                                                     
      * bool の                                                              
      *  true == 1;                                                          
      *  false == 0;                                                         
      * って保証されてるんだっけ？                                           
      */
-#if 1
-    return (group == NULL) * command;
-#else
-    if (group.empty()) {
-	return command;
-    } else {
-	return 0;
-    }
-#endif
+    return (group->empty()) * command;
 }

--- a/TaskManager/kernel/schedule/TaskGroup.h	Mon Oct 05 08:56:56 2009 +0900
+++ b/TaskManager/kernel/schedule/TaskGroup.h	Mon Oct 05 10:36:37 2009 +0900
@@ -2,7 +2,7 @@
 #define INCLUDED_TASK_GROUP
 
 #include "base.h"
-#include "TaskQueue.h"
+#include "TaskQueueInfo.h"
 
 class TaskGroup {
 public:
@@ -11,7 +11,7 @@
     BASE_NEW_DELETE(TaskGroup);
 
     unsigned int command;
-    TaskQueuePtr group;
+    TaskQueueInfo *group;
 
     /**
      * 待つ Task を追加