通用编程能力训练 -- 设计心得：分步载入的改造(包含异步IO练习)

目标：将一个顺序载入的系统变成分步载入的系统。

 

动机：

也许你会说背景线程 可以达到更好的效果， 但是我想说的是在一些情况下是无法使用多线程的。

比如装载Shader程序，这些程序都需要使用CPU进行本地编译。

这时支持分步载入的系统就能根据情况来分散载入任务，平滑资源载入的过程，可以让系统充分利用时间来使前台功能看起来平滑。

另外一个理由是性能，基于多线程的系统总是会为各种锁支付额外的开销，对于Ogre而言，这2种工作模式的性能差异可以达到30%以上。

注意，这个改造方案和多线程工作模式不冲突。

 

步骤：

1、确保存在 isLoaded() 或类似方法,因为分步载入的结构和异步结构一致.

2、确保存在一个用于记录所有的加载任务的数据成员，如果没有就定义一个.

3、添加一个游标变量记录当前正在处理哪个子对象，可以是一个对象引用、上值、索引、迭代器等.

4、添加一个用于步进载入的函数 bool loadNext(), 在该函数中发起"当前正在处理的子对象"的加载, 并将游标指向下一个对象.

5、添加一个用于直接载入的函数 void loadDirectly(), 该函数使用 基于 while( loadNext()) 的结构来实现自己.

6、在创建母对象的接口上添加一个 bool manualLoad 变量,用于确定是否使用步进加载,或使用原有的直接加载方式.

 

范例：(注意下面的 + expand / sourceview / plaincopy to clipboard / print / ?)

 

 

// MultiThreadTest_Console2.cpp : 定义控制台应用程序的入口点。
//
#include "stdafx.h"
#include "windows.h"
#include <string>
#include <vector>
#include <algorithm>
// 模拟资源加载
// time: 186min;
unsigned int gFrameIndex;
// 子对象
class SubObject
{
public:
SubObject(const std::string& name, unsigned int size)
:mName(name)
,mSize(size)
{
}
std::string mName;
unsigned int mSize;
};
// 子对象加载器
class SubObjectManager/* : public Singleton<SubObjectManager>*/
{
public:
typedef std::vector<SubObject*> SubObjects;
public:
SubObjectManager(){}
~SubObjectManager(){}

public:
SubObject* load(const std::string& name)
{
unsigned int size = rand()%100;
std::string _name = name;
Sleep(size);
SubObject* so = new SubObject(_name, size);
mSubObjects.push_back(so);
return so;
}
SubObject* getSubObject(const std::string& name)
{
for( SubObjects::iterator it = mSubObjects.begin();
it != mSubObjects.end(); ++it)
{
if((*it)->mName == name)
return *it;
}
return NULL;
}
private:
SubObjects mSubObjects;
};
struct Task;
class AnSyncResourceLoaderListener
{
public:
virtual void processCompleted(const Task* task){};
};
struct Task
{
typedef std::vector<AnSyncResourceLoaderListener*> Lisnters;
unsigned int mID;
std::string mName;
Lisnters mLisnters;

void megry( const Task& other)
{
if( !isSameTask(other))
return;
for( Lisnters::const_iterator other_it = other.mLisnters.begin();
other_it != other.mLisnters.end(); ++other_it)
{
Lisnters::iterator this_it = std::find(mLisnters.begin(), mLisnters.end(), *other_it);
if( this_it == mLisnters.end())
{
mLisnters.push_back(*other_it);
}
}
}
bool isSameTask( const Task& other)
{
return other.mName == mName;
}
void notifyCompleted()
{
for( Lisnters::iterator it = mLisnters.begin();
it != mLisnters.end(); ++it)
{
(*it)->processCompleted(this);
}
}
bool operator ==(const Task& other)
{
return mID == other.mID && mName == other.mName;
}
};
class AnSyncResourceLoader/* : public Singleton<AnSyncResourceLoader>*/
{
public:
typedef std::vector<Task> TaskQuene;
public:
AnSyncResourceLoader(SubObjectManager* pSubObjectManager)
:mNextTaskID(0)
,mSubObjectManager(pSubObjectManager)
{
InitializeCriticalSection (&mRawTaskQueneCS);
InitializeCriticalSection (&mCompletedTaskQueneCS);
}
~AnSyncResourceLoader()
{
DeleteCriticalSection (&mRawTaskQueneCS);
DeleteCriticalSection (&mCompletedTaskQueneCS);
}
public:
void pushRawTask( Task& task)
{
EnterCriticalSection (&mRawTaskQueneCS) ;
// 策略
// 1、已经加载了--》直接添加到完成队列
// 2、已经提交该任务了(不管是否正在处理)--》合并 Listener
// 3、不存在--》直接添加
// 情况1
TaskQuene::iterator raw_it = std::find(mRawTaskQuene.begin(),mRawTaskQuene.end(),task);
if( raw_it != mRawTaskQuene.end())
{
raw_it->megry(task);
}
// 情况2
else
{
TaskQuene::iterator completed_it = std::find(mCompletedTaskQuene.begin(),mCompletedTaskQuene.end(),task);
if( completed_it != mCompletedTaskQuene.end())
{
completed_it->megry(task);
}
// 情况3
else
{
task.mID = mNextTaskID++;
mRawTaskQuene.push_back(task);
}
}
LeaveCriticalSection (&mRawTaskQueneCS) ;
}
Task popRawTask(const Task& task)
{
EnterCriticalSection (&mRawTaskQueneCS) ;
Task out;
TaskQuene::iterator raw_it = std::find(mRawTaskQuene.begin(),mRawTaskQuene.end(),task);
if( raw_it != mRawTaskQuene.end())
{
out = *raw_it;
mRawTaskQuene.erase(raw_it);
}
return out;
LeaveCriticalSection (&mRawTaskQueneCS) ;
}
void pushCompletedTask( const Task& task)
{
EnterCriticalSection (&mCompletedTaskQueneCS);
// 策略
// 1、已经存在，还没通知主线程将回调发送出去--》合并Listener
// 2、不存在--》直接添加
// 情况1
TaskQuene::iterator completed_it = std::find(mCompletedTaskQuene.begin(),mCompletedTaskQuene.end(),task);
if( completed_it != mCompletedTaskQuene.end())
{
completed_it->megry(task);
}
// 情况2
else
{
mCompletedTaskQuene.push_back(task);
}
LeaveCriticalSection (&mCompletedTaskQueneCS);
}
Task popCompletedTask(const Task& task)
{
Task out;
EnterCriticalSection (&mCompletedTaskQueneCS) ;
TaskQuene::iterator completed_it = std::find(mCompletedTaskQuene.begin(),mCompletedTaskQuene.end(),task);
if( completed_it != mCompletedTaskQuene.end())
{
out = *completed_it;
mCompletedTaskQuene.erase(completed_it);
}
LeaveCriticalSection (&mCompletedTaskQueneCS) ;
return out;
}
public:
// 多线程函数
DWORD WINAPI doLoad( LPVOID lpThreadParameters)
{
while(true)
{
if(	mRawTaskQuene.empty())
continue;
Task task = mRawTaskQuene.front();
mSubObjectManager->load(task.mName);
popRawTask(task);
pushCompletedTask(task);
}
return 0;
}
// 主线程函数
public:
void notifyCompleted()
{
EnterCriticalSection (&mCompletedTaskQueneCS);
for( TaskQuene::iterator it = mCompletedTaskQuene.begin();
it != mCompletedTaskQuene.end(); ++it)
{
it->notifyCompleted();
}
mCompletedTaskQuene.clear();
LeaveCriticalSection (&mCompletedTaskQueneCS);
}

private:
CRITICAL_SECTION mRawTaskQueneCS;
CRITICAL_SECTION mCompletedTaskQueneCS;
TaskQuene mRawTaskQuene;
TaskQuene mCompletedTaskQuene;
unsigned int mNextTaskID;
SubObjectManager* mSubObjectManager;
};
class BaseObject : public AnSyncResourceLoaderListener
{
public:
typedef std::vector<std::string> RawResourceList;
typedef std::vector<SubObject*> SubObjects;
public:
BaseObject(const RawResourceList& resources,AnSyncResourceLoader* pLoader)
:mNextLoadIndex(0)
,mCompletedCount(0)
,mLoaded(false)
,mAllRawResourceLoading(false)
,mLoader(pLoader)
{
mResources = resources;
}
~BaseObject(){}
public:
virtual void processCompleted(const Task* task)
{
printf("加载完成[%s],frame[%u]/n", task->mName.c_str(), gFrameIndex);
if(++mCompletedCount == mResources.size())
mLoaded = true;
};
public:
bool loadNext()
{
if( mAllRawResourceLoading)
return false;
std::string taskName = mResources[mNextLoadIndex];
Task task;
task.mLisnters.push_back(this);
task.mName = taskName;
mLoader->pushRawTask(task);
printf("发起加载[%s],frame[%u]/n", taskName.c_str(), gFrameIndex);
mNextLoadIndex++;
if( mNextLoadIndex >= mResources.size())
mAllRawResourceLoading = true;
return true;
}
bool isLoaded()
{
return mLoaded;
}
private:
RawResourceList mResources;
SubObjects mSubObjects;
bool mLoaded;
bool mAllRawResourceLoading;
unsigned int mNextLoadIndex;
unsigned int mCompletedCount;
AnSyncResourceLoader* mLoader;
};
DWORD WINAPI doLoad( LPVOID lpThreadParameters)
{
AnSyncResourceLoader* pAnSyncResourceLoader = (AnSyncResourceLoader*)(lpThreadParameters);
return pAnSyncResourceLoader->doLoad(lpThreadParameters);
}
int _tmain(int argc, _TCHAR* argv[])
{
SubObjectManager subObjectManager;
AnSyncResourceLoader anSyncResourceLoader(&subObjectManager);
HANDLE hThread = CreateThread( NULL, 0, doLoad, &anSyncResourceLoader, 0, NULL);

BaseObject::RawResourceList r;
r.push_back("dasdasda");
r.push_back("21212");
r.push_back("xxxxxsda");
r.push_back("5555555sda");
BaseObject* bo = new BaseObject(r,&anSyncResourceLoader);
gFrameIndex = 0;
while(true)
{
gFrameIndex++;
// 更新
anSyncResourceLoader.notifyCompleted();
if(!bo->isLoaded())
bo->loadNext();
else
break;
}
getchar();
return 0;
}