用户态线程在AI中的应用

最近这段时间在修改服务器AI，准备将AI分配到单独的服务器中做，但为了不至于对原有架构造成

太大的影响，攻击的判定，移动的判定仍然在gameserver上处理，AI服务器的角色就是根据状态

选择合适的决策并向gameserver发出决策命令。

例如:一个简单的AI函数可能像下面这样

void onAi()
{
  //从视野中选择一个目标
  target = findtarget();
  if(target && target.distence(this) <= 10)
  {
      attack(target);
  }
}

调用attack的时候，将向gameserver发送一条攻击命令，由gameserver做出判定并将结果返回

给Ai服务器。这时就出现了一个问题，如果Ai循环又一次执行到onAi,但前一次的攻击结果还没有返回。

这个时候ai就不能根据正确的状态做出合理的决策了。

正确的做法是执行attack的时候阻塞在attack上，直到攻击结果返回attack才返回。

显然，如果阻塞在attack上，那么将导致其它AI无法继续运行，这个时候，用户态线程的威力就发挥出来

了。

执行attack的时候，可以把路径切换回调度器，由调度器选择没有被阻塞的用户态线程序来执行，当攻击

结果返回后，把被阻塞的用户态线程重新置为可运行状态，调度器以后可以重新调度该线程继续执行。

当调度器重新调度被阻塞的线程时，那个线程将会从attack中返回，继续后续的处理。这样保证了AI

的串行处理。

用户态线程的实现有很多种方式，包括linux的ucontext和windows下的fiber,下面给出一个fiber实现的

简单的用户态线程调度框架.

uthread.h

#ifndef _UTHREAD_H
#define _UTHREAD_H

#include <Windows.h>

enum
{
    NONE,           //仅仅让出处理器
    WAIT4EVENT = 1, //等待某事件的来临
    WAIT4EVENTTIMEOUT,
    DEAD,           //纤程已死亡
    ACTIVED,        //可运行的
    SLEEP,
};

//纤程等待的事件
enum
{
    MOVE_RET = 1,   //移动的返回结果
    SKILL_RET,      //技能使用的返回结果
};

typedef int uthread_t;


class uthread; 
class runnable
{
public:
    virtual void main_routine() = 0;
    uthread *p_uthread;
};

//纤程
class uthread
{
public:

    static void WINAPI thread_routine(LPVOID pvParam);
    
    void OnEvent(unsigned short ev);
    
    uthread_t uthread_id;
    unsigned char status;
    PVOID p_uthreadContext;

    unsigned short waitevent;//一个纤程只能等待在一个事件上

};


#endif

Scheduler.h

#ifndef _SCHEDULER_H
#define _SCHEDULER_H
#include <Windows.h>

#include "uthread.h"
#include <map>
#include <list>
#include <time.h>

#define MAX_FIBER 8192

class Scheduler
{
friend class uthread;
public:
    //初始化纤程库
    static void scheduler_init()
    {
         m_pUthreadContext = ConvertThreadToFiber(NULL);
    }

    static void scheduler_destroy();

    static uthread_t spawn(runnable *param,int stacksize);

    //选择一个纤程以进行调度
    static void schedule();

    static void sleep(time_t timeout)
    {
        if(timeout > 0)
        {
            m_uthreads[m_curuid]->status = SLEEP;
            time_t t = timeout + time(NULL);
            m_sleepList.push_back(std::make_pair(t,m_uthreads[m_curuid]));
        }

        SwitchToFiber(m_pUthreadContext);

    }

    //将一个纤程添加到可运行队列中
    static void add2Active(uthread *ut)
    {
        ut->status = ACTIVED;
        m_pendingAdd.push_back(ut);
    }

    //将当运行权交给scheduler
    static void yield()
    {
        //将运行权交给调度器
        SwitchToFiber(m_pUthreadContext);
    }

    //阻塞在ev上,timeout==0将永远等待
    static int block(unsigned short ev,time_t timeout);

private:

    static std::map<PVOID,uthread*> m_activeList;//可运行列表

    static std::list<uthread*> m_pendingAdd;//等待添加进可运行列表中的纤程

    static std::list<std::pair<time_t,uthread*> > m_sleepList;//正在睡眠的纤程，将来改成用优先队列

    static PVOID m_pUthreadContext;//调度器所在纤程的上下文
    
    static uthread *m_uthreads[MAX_FIBER];

    static int m_count;

    static int m_curuid;           //当前正在运行的纤程的uid,==-1表示在scheduler中运行

    static volatile bool m_terminate;       

};




#endif

Scheduler.cpp

#include "stdafx.h"
#include "Scheduler.h"

std::map<PVOID,uthread*> Scheduler::m_activeList;//可运行列表

std::list<uthread*> Scheduler::m_pendingAdd;

std::list<std::pair<time_t,uthread*> > Scheduler::m_sleepList;


PVOID Scheduler::m_pUthreadContext;//调度器所在纤程的上下文

uthread *Scheduler::m_uthreads[MAX_FIBER];

int Scheduler::m_count = 0;

int Scheduler::m_curuid = -1;

volatile bool Scheduler::m_terminate = false;


void WINAPI uthread::thread_routine(LPVOID pvParam)
{
    ((runnable*)pvParam)->main_routine();
    ((runnable*)pvParam)->p_uthread->status = DEAD;
    /*这里不能直接退出纤程运行函数，否则会导致运行线程的退出，
    * 正确的做法是把运行权交回给scheduler，由scheduler来删除
    * 这个纤程
    */
    Scheduler::yield();
}

//等待的事件到达了，将纤程重新插入到可运行队列中
void uthread::OnEvent(unsigned short ev)
{
    if(ev == waitevent)
    {
        status = ACTIVED;
        Scheduler::add2Active(this);
        waitevent = 0;

        //从sleeplist中删除
        std::list<std::pair<time_t,uthread*> >::iterator it = Scheduler::m_sleepList.begin();
        std::list<std::pair<time_t,uthread*> >::iterator end = Scheduler::m_sleepList.end();
        for( ; it != end; ++it )
        {

            if(it->second == this)
            {
                it = Scheduler::m_sleepList.erase(it);
                break;
            }
        }
    }
}

void Scheduler::schedule()
{
    printf("schedule/n");
    while(!m_terminate)
    {
        std::list<std::map<PVOID,uthread*>::iterator> deletes;

        std::map<PVOID,uthread*>::iterator it = m_activeList.begin();
        std::map<PVOID,uthread*>::iterator end = m_activeList.end();
        for( ; it != end; ++it)
        {
            m_curuid = it->second->uthread_id;
            SwitchToFiber(it->first);
            m_curuid = -1;
            if(it->second->status == DEAD || it->second->status == SLEEP || it->second->status == WAIT4EVENT
                || it->second->status == WAIT4EVENTTIMEOUT)
            {
                deletes.push_back(it);
            }
            printf("come back/n");
        }

        {
            std::list<std::map<PVOID,uthread*>::iterator>::iterator it = deletes.begin();
            std::list<std::map<PVOID,uthread*>::iterator>::iterator end = deletes.end();
            for( ; it != end; ++it)
            {
                if((*it)->second->status == DEAD)
                {
                    DeleteFiber((*it)->first);
                    m_uthreads[(*it)->second->uthread_id] = NULL;
                    delete (*it)->second;
                    --m_count;
                }
                m_activeList.erase(*it);
            }
        }
        //将所有等待添加到m_activeList中的纤程都添加进去
        {
            while(!m_pendingAdd.empty())
            {
                uthread *tmp = m_pendingAdd.back();
                m_pendingAdd.pop_back();
                m_activeList.insert(std::make_pair(tmp->p_uthreadContext,tmp));
            }
                
        }
            
        //看看有没有timeout的纤程
        {
            time_t now = time(NULL);
            std::list<std::pair<time_t,uthread*> >::iterator it = m_sleepList.begin();
            for( ; it != m_sleepList.end(); )
            {
                time_t t = it->first;
                if(it->first <= now)
                {
                    it->second->status = ACTIVED; 
                    m_activeList.insert(std::make_pair(it->second->p_uthreadContext,it->second));
                    it = m_sleepList.erase(it);
                }
                else
                    ++it;
            }
        }

    }

    scheduler_destroy();
    ConvertFiberToThread();
    printf("scheduler end/n");
}

void Scheduler::scheduler_destroy()
{
    for(int i = 0; i < MAX_FIBER; ++i)
    {
        if(m_uthreads[i])
        {
            DeleteFiber(m_uthreads[i]->p_uthreadContext);
            delete m_uthreads[i];
        }
    }
}

uthread_t Scheduler::spawn(runnable *param,int stacksize)//创建一个新的纤程 
{
    if(m_count >= MAX_FIBER)
        return -1;
    //刚创建的纤程不处于可运行状态
    PVOID uthreadcontext =  CreateFiber(stacksize,uthread::thread_routine,param);
    uthread *nthread = new uthread;
    nthread->p_uthreadContext = uthreadcontext;
    for(int i= 0; i < MAX_FIBER; ++i)
    {
        if(0 == m_uthreads[i])
        {
            nthread->uthread_id = i;
            m_uthreads[i] = nthread;
            break;
        }
    }
    add2Active(nthread);
    ++m_count;
    param->p_uthread = nthread;
    return nthread->uthread_id;
}

static int Scheduler::block(unsigned short ev,time_t timeout)
{
    m_uthreads[m_curuid]->waitevent = ev;
    if(timeout > 0)
    {
        m_uthreads[m_curuid]->status = WAIT4EVENTTIMEOUT;
        time_t t = timeout + time(NULL);
        m_sleepList.push_back(std::make_pair(t,m_uthreads[m_curuid]));
    }
    else
        m_uthreads[m_curuid]->status = WAIT4EVENT;

    SwitchToFiber(m_pUthreadContext);

    if(m_uthreads[m_curuid]->waitevent == 0)
    {
        //等待的事件到达
        return 0;
    }
    else
        return -1;//超时间

}

test.cpp

// AiScheduler.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include "Scheduler.h"


class test22 : public runnable
{

public:
    void main_routine()
    {
        for(int i = 0 ; i < 20; ++i)
        {
            printf("%d/n",i);
            printf("begin block/n");
            if(0 == Scheduler::block(MOVE_RET,1))
                printf("test wake me up/n");
            else
                printf("timeout/n");
            //Scheduler::sleep(1);
        }
        printf("die/n");
    }

    uthread_t uid;
};


class test : public runnable
{
public:
    void main_routine()
    {
        for(int i = 0 ; i < 10; ++i)
        {
            printf("%d/n",i);
            if(t22->p_uthread->waitevent == MOVE_RET)
                t22->p_uthread->OnEvent(MOVE_RET);
            Scheduler::yield();
        }
        printf("die/n");
    }
    test22 *t22;
    uthread_t uid;
};



int _tmain(int argc, _TCHAR* argv[])
{
    Scheduler::scheduler_init();
    
    test22 test2;
    test test1;
    test1.t22 = &test2;
    test2.uid = Scheduler::spawn(&test2,4096);
    test1.uid = Scheduler::spawn(&test1,4096);
    
    //test3.uid = Scheduler::spawn(&test3,4096);
    //test4.uid = Scheduler::spawn(&test4,4096);
    Scheduler::schedule();
    return 0;
}