#define DEBUG
#include "error.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "CellTaskManagerImpl.h"
#include "CellTaskListInfo.h"
#include "HTaskInfo.h"
#include "SchedTask.h"
#include "MainScheduler.h"
#include "types.h"
#include "SysFunc.h"

static void send_alloc_reply(CellTaskManagerImpl *tm, int id,  SpeThreads *speThreads);

CellTaskManagerImpl::~CellTaskManagerImpl()
{
    delete speThreads;
    delete [] speTaskList;
    delete [] speTaskList_bg;
    /**
     * bufferManager は
     * ppeManager のなかで delete してもらう
     */
    // delete bufferManager;
    delete [] flag_sendTaskList;

    delete ppeManager;
}

void
CellTaskManagerImpl::init()
{
    spe_running = 0;
    taskListImpl = new CellTaskListInfo;
    taskListImpl->init(16);

    activeTaskQueue = new HTaskInfo();

    htaskImpl = activeTaskQueue ; // any HTaskInfo

    speThreads = new SpeThreads(machineNum);
    speThreads->init();

    speTaskList  = new TaskListPtr[machineNum];
    speTaskList_bg  = new TaskListPtr[machineNum];

    for (int i = 0; i < machineNum; i++) {
	speTaskList[i] = taskListImpl->create();
	speTaskList_bg[i] = taskListImpl->create();
    }

    flag_sendTaskList = new int[machineNum];
    for (int i = 0; i < machineNum; i++) {
	flag_sendTaskList[i] = 1;
    } 
    // PPE 側の管理をする Manager
    ppeManager = new FifoTaskManagerImpl(machineNum);
    // 大半のTaskQueueInfoは、共有される
    MainScheduler *mscheduler = new MainScheduler;
    ppeManager->init(mscheduler, this);
    
    ppeManager->get_scheduler()->set_manager(this);

    schedTaskManager = new SchedTask();
    schedTaskManager->init(0,0,0,ppeManager->get_scheduler());
}

void
CellTaskManagerImpl::append_activeTask(HTaskPtr task)
{
    if (task->cpu_type == CPU_PPE) {
        ppeManager->append_activeTask(task);
    } else {
        activeTaskQueue->addLast(task);
    }
}

// SPE_ANY が指定されていた時に
// これをインクリメントしつつ呼ぶことにする。
// 乱数使ってもいいけどさ。
int cur_anySpeid = 0;

/**
 * ActiveTaskQueue から Task を
 * 各 SPE に渡す TaskList に入れる
 *
 * ここの activeTaskQueue は FifoTaskManagerImpl のと意味が違い、
 * spe に渡される Task だけ入っている
 */
void
CellTaskManagerImpl::set_runTaskList()
{
    TaskListPtr list;
    SimpleTaskPtr task;
    int speid;

    while (HTaskPtr htask = activeTaskQueue->poll()) {

	if (htask->cpu_type == SPE_ANY) {
	    speid = cur_anySpeid++;
	    cur_anySpeid = (cur_anySpeid < machineNum)
		? cur_anySpeid : 0;
	} else {
	    // -1 してるのは
	    // htask->cpu_type - CPU_SPE で
	    // SPE0 = 1, SPE1 = 2, ... SPE5 = 6 ってなってるので
	    // 配列的 (SPE0 = arr[0], SPE1 = arr[1]) にするため
	    speid = htask->cpu_type - CPU_SPE - 1;

	    // SPU の数以上が指定されていれば
	    // とりあえず MAX_USE_SPE_NUM (実際に動く SPE の最大数) で
	    // あまり求めてそれを使うことにする。
	    // ここで判定するもんでもないか？
	    if (speid >= machineNum) {
		speid %= machineNum;
	    }
	}

	list = speTaskList_bg[speid];

	if (list->length >= TASK_MAX_SIZE) {
	    TaskListPtr newList = taskListImpl->create();
	    newList = TaskListInfo::append(newList, speTaskList_bg[speid]);
	    speTaskList_bg[speid] = newList;
	    list = newList;
	}

	task = &list->tasks[list->length++];

        if (htask->command==TaskArray1) {
            // compatibility
	    // Task with ListData is stored in the ListData
            int next = (htask->r_size+sizeof(SimpleTask))/sizeof(SimpleTask);
            if (list->length+next>=TASK_MAX_SIZE) {
                list->length--;
                TaskListPtr newList = taskListImpl->create();
		newList = TaskListInfo::append(newList, speTaskList_bg[speid]);
		speTaskList_bg[speid] = newList;
                list = newList; 
                task = &list->tasks[list->length++];
            }
            Task *array = (Task*)&list->tasks[list->length];
            list->length += next;
            memcpy(array, htask->rbuf, htask->r_size);
            free(htask->rbuf);
            htask->rbuf = 0; htask->r_size = 0;
            *task = *(SimpleTask*)htask;
        } else {
	    *task = *(SimpleTask*)htask;
        }

    }
}

void
CellTaskManagerImpl::sendTaskList()
{
    for (int i = 0; i < machineNum; i++)  {
	if (flag_sendTaskList[i] == 1 && speTaskList_bg[i]->length >= 1 ) {
	    send_taskList(i);
	    spe_running++;
	}
    }
}

void
CellTaskManagerImpl::run()
{
    TaskListPtr ppeTaskList = NULL;

    do {
        // PPE side
	ppeTaskList =  ppeManager->get_runTaskList();
	if (ppeTaskList)
	    ppeManager->sendTaskList(ppeTaskList);
	ppeManager->mail_check();
        // SPE side
	do {
	    mail_check();
	    // SPE に送る TaskList の準備
	    set_runTaskList();
	    // TaskList 待ちの SPE に TaskList を送る
	    sendTaskList();
	} while (ppeManager->activeTaskQueue->empty() && spe_running >0 );
    } while (ppeTaskList || spe_running >0); 
    if (!waitTaskQueue->empty()) {
	fprintf(stderr,"Dead lock detected\n");
    }
}

/**
 * SPE からのメールをチェックする
 */

void
CellTaskManagerImpl::mail_check()
{
    memaddr data;

    // SPE Scheduler からの mail check
    for (int id = 0; id < machineNum; id++) {	    
	while (speThreads->has_mail(id, 1, &data)) {				
	    if (data == (memaddr)MY_SPE_STATUS_READY) {
		//  MY_SPE_STATUS_READY: SPE が持ってた Task 全て終了
		flag_sendTaskList[id] = 1;
		spe_running--;
	    } else if (data == (memaddr)MY_SPE_COMMAND_MALLOC) {
	        // MY_SPE_COMMAND_MALLOC   SPE からのmain memory request
		send_alloc_reply(this, id, speThreads);
	    } else if (data > (memaddr)MY_SPE_NOP) {
	        // 終了したタスク(PPEにあるのでアドレス)
		HTaskPtr task = (HTaskPtr)data;
		task->post_func(schedTaskManager, task->post_arg1, task->post_arg2);
		check_task_finish(task,waitTaskQueue);
	    }
	    // MY_SPE_NOP: 特に意味のないコマンド
	}
    }
}

static void
send_alloc_reply(CellTaskManagerImpl *tm, int id, SpeThreads *speThreads)
{

    /**
     * info[0] = alloc_id; (CellScheduler::mainMem_alloc 参照)
     * info[1] = alloc_addr;
     */
    memaddr alloc_info[2];
    long alloc_size;
    long command;
    
    speThreads->get_mail(id, 2, alloc_info);
    command = (long)alloc_info[0];
    alloc_size = (long)alloc_info[1];

    
    alloc_info[1] = (memaddr)tm->allocate(alloc_size);
    //__debug_ppe("[PPE] MALLOCED 0x%lx from [SPE %d]\n", alloc_info[1],id);
    // 今のところ何もしてない。どうも、この allocate を free 
    // するのは、SPE task が返した値を見て行うらしい。それは、
    // 忘れやすいのではないか?
    speThreads->add_output_tasklist(command, alloc_info[1], alloc_size);

    speThreads->send_mail(id, 2, alloc_info);
}

/**
 * 条件を満たしたら SPE に TaskList を送信する
 * 条件1. SPE が持ってた TaskList を終了して、次の TaskList を待ってる
 * 条件2. SPE に送る TaskList に Task がある
 *
 * SPE で実行終了した TaskList [speTaskList] と
 * これから実行する TaskList [speTaskList_bg] のバッファを入れ替える
 * ついでに実行終了したやつは clear しておく。
 */
void
CellTaskManagerImpl::send_taskList(int id)
{
    TaskListPtr tmp;

    tmp = speTaskList[id];
    speTaskList[id]  = speTaskList_bg[id];
    speTaskList_bg[id] = tmp;

    taskListImpl->clear_taskList(speTaskList_bg[id]);

    speThreads->send_mail(id, 1, (memaddr *)&speTaskList[id]);
    flag_sendTaskList[id] = 0;
}

void CellTaskManagerImpl::show_profile() {
    for (int id = 0; id < machineNum; id++) {	    
	HTaskPtr t = create_task(ShowTime);
	t->set_cpu((CPU_TYPE)(id+2));
	t->spawn();
    }
}

void CellTaskManagerImpl::start_profile() {
    for (int id = 0; id < machineNum; id++) {	    
	HTaskPtr t = create_task(StartProfile);
	t->set_cpu((CPU_TYPE)(id+2));
	t->spawn();
    }
}


#ifdef __CERIUM_CELL__
TaskManagerImpl*
create_impl(int num)
{
    return new CellTaskManagerImpl(num);
}
#endif // __CERIUM_CELL