核心子系統(tǒng)

核心庫(Core namespace)實(shí)現(xiàn)了這些特性:

• 一個實(shí)現(xiàn)了引用計數(shù)的RefCounted基類
• 一個運(yùn)行時類型信息系統(tǒng)(RTTI)
• 一個模板智能指針, 用于處理RefCounted對象的生命周期
• 一個由類名創(chuàng)建C++對象實(shí)例的工廠機(jī)制
• 一個中央Server對象用于建立基本的Nebula3運(yùn)行環(huán)境

對象模型

Nebula3在C++對象模型的基礎(chǔ)之上實(shí)現(xiàn)了下面這些新特性:

• 基于引用計數(shù)和智能指針的生命周期管理
• 基于類名或四字符編碼的對象創(chuàng)建
• 一個運(yùn)行時類型信息系統(tǒng)

實(shí)現(xiàn)一個新的Nebula3類

當(dāng)實(shí)現(xiàn)一個新的類時首先要考慮它是一個傳統(tǒng)的C++類還是要從Core::RefCounted繼承. 以下幾點(diǎn)可以幫你找到答案:

• 如果這個類需要使用Nebula3的擴(kuò)展對象特性, 如引用計數(shù), RTTI等, 則它必須從Core::RefCounted繼承.
• 如果這個類是一個典型的小工具類, 如動態(tài)數(shù)組, 數(shù)學(xué)向量, 或其它相似的東西, 那么它從Core::RefCounted 繼承也沒有什么意義.

從Core::RefCounted類繼承有一些限制:

• RefCounted派生類不應(yīng)該在棧上創(chuàng)建對象, 因?yàn)闂ο蟮纳芷谑怯蒀++來管理的(他們會在離開當(dāng)前上下文時被銷毀, 從而繞過了Nebula3的引用計數(shù)生命周期 管理)
• RefCounted的派生類只有一個默認(rèn)的構(gòu)造函數(shù).
• RefCounted的派生類必須有一個虛析構(gòu)函數(shù).
• RefCounted的派生類不能進(jìn)行拷貝, 因?yàn)檫@樣會造成引用計數(shù)機(jī)制混亂.

要使用Nebula3的對象模型特性, 除了需要從Core::RefCounted繼承外, 還需要在頭文件新類的聲明中進(jìn)行額外的標(biāo)注:

一個標(biāo)準(zhǔn)的RefCounted派生類一般這樣聲明:

1: namespace MyNamespace

2: {

3: class MyClass : public Core::RefCounted

4: {

5: DeclareClass(MyClass);

6: public:

7: /// constructor

8:     MyClass();

9: /// destructor

10: virtual ~MyClass();

11: ...

12: };

13: RegisterClass(MyClass);

注意DeclareClass()宏, 構(gòu)造函數(shù), 析構(gòu)函數(shù)還有類外面的RegisterClass()宏. DeclareClass()宏加入了RTTI和工廠機(jī)制所需的最小代價的信息, 它隱藏了Nebula3的對象模型, 希望可以在不影響已有類的基礎(chǔ)進(jìn)上進(jìn)行內(nèi)部機(jī)制的變更. RegisterClass()宏是可選的, 它把當(dāng)前類在中央工廠進(jìn)行注冊. 如果你知道這個類永遠(yuǎn)不會由類名或四字符編碼進(jìn)行創(chuàng)建, 這個宏可以省略.

在這個類的.cpp文件里需要包含Nebula3特有的信息:

1: namespace MyNamespace

2: {

3: ImplementClass(MyNamespace::MyClass, 'MYCL', Core::RefCounted);

4:

5: }

ImplementClass()宏注冊類的RTTI機(jī)制, 第一個參數(shù)描述了類的名字(注意命名空間必須包含). 第二個參數(shù)是類的四字符編碼, 它必須是所有類中唯一的(如果有重復(fù), 你會在啟動程序時得到一個錯誤提示). 第三個參數(shù)是父類的名字, 用于RTTI系統(tǒng)去構(gòu)造類的關(guān)系樹.

引用計數(shù)和智能指針

Nebula3使用傳統(tǒng)的引用計數(shù)來管理對象的生命周期. 一個模板智能指針類Ptr<>對程序員隱藏了引用計數(shù)的實(shí)現(xiàn)細(xì)節(jié). 一般來說, 應(yīng)該一直使用智能指針指向RefCounted的派生對象, 除非你能肯定在給出的代碼塊中這個對象的引用計數(shù)不會發(fā)生變化.

智能指針相對于一般指針有很多好處:

• 訪問一個空指針會給你一個斷言警告而不是一個內(nèi)存錯誤
• 你不需要對引用計數(shù)的對象調(diào)用AddRef()或Release() (事實(shí)上如果你調(diào)了, 會了發(fā)生嚴(yán)重的錯誤)
• 智能指針可以在容器類里良好地工作, 一個智能指針的數(shù)組會消除所有的一般指針需要的生命周期管理, 你永遠(yuǎn)不需要考慮去釋放指針?biāo)羔樀膶ο? 數(shù)組包含的像是真正的C++對象一樣
• 用智能指針不需要考慮指針的所屬, 不需要為誰delete對象而煩惱

智能指針也有一些缺點(diǎn):

• 性能: 拷貝和賦值會引起對象的引用計數(shù)的變化, 解除引用會引起指針的斷言檢查. 這導(dǎo)致的性能消耗一般是可以忽略的, 但是你最好保證它不在內(nèi)部循環(huán)中發(fā)生.
• 應(yīng)該銷毀的對象還存在: 因?yàn)橹悄苤羔樄芾淼膶ο笾挥性谧詈笠粋€引用放棄時才會銷毀, 這樣會使對象存在超過預(yù)訂的時間. 這經(jīng)常會導(dǎo)致一個BUG的產(chǎn)生. 不過引用計數(shù)泄露(程序退出時還仍然存在的對象)時Nebula3會提醒你.

創(chuàng)建Nebula3對象

從Core::RefCounted繼承的類可以通過3種不同的方式進(jìn)行創(chuàng)建:

直接通過靜態(tài)的Create方法:

1: Ptr<MyClass> myObj = MyClass::Create();

靜態(tài)的Create()方法是之前提到的DeclareClass()宏加入的, 相對于new操作符來說, 它并沒有多做什么. 注意正確使用智能指針來保存新建的對象.

另一種創(chuàng)建方式是通過類名:

1: using namespace Core;

2: Ptr<MyClass> myObj = (MyClass*)Factory::Instance()->Create("MyNamespace::MyClass");

當(dāng)你在運(yùn)行時通過類名來創(chuàng)建十分有用, 特別是對象的反序列化和腳本接口的使用. 注意類型轉(zhuǎn)換是必須的, 因?yàn)楣S的Creat()方法返回的是RefCounted指針.

由類名創(chuàng)建的變種是根據(jù)四字符編碼進(jìn)行創(chuàng)建:

1: using namespace Core;

2: using namespace Util;

3: Ptr<MyClass> myObj = (MyClass*) Factory::Instance()->Create(FourCC('MYCL'));

這個方法看上去沒有那個直觀, 但是它比類名創(chuàng)建快得多. 并且四字符編碼比類名占用的空間更少, 這更利于對象寫入二進(jìn)制流或從中讀取.

運(yùn)行時類型信息系統(tǒng)

Nebula3的RTTI系統(tǒng)可以讓你在運(yùn)行時訪問對象的類型, 檢查一個對象是不是某個類的實(shí)例, 或者某個派生類的實(shí)例. 你也可以直接獲得一個對象的類名和四字符編碼. 所有這些功能是由DeclareClass() 和 ImplementClass() 宏在背后實(shí)現(xiàn)的.

這時有示例程序:

1:     using namespace Util;

2:     using namespace Core;

3:

4: // check whether an object is instance of a specific class

5: if (myObj->IsInstanceOf(MyClass::RTTI))

6: {

7: // it's a MyClass object

8: }

9:

10: // check whether an object is instance of a derived class

11: if (myObj->IsA(RefCounted::RTTI))

12: {

13: // it's a RefCounted instance or some RefCounted-derived instance

14: }

15:

16: // get the class name of my object, this yields "MyNamespace::MyClass"

17: const String& className = myObj->GetClassName();

18:

19: // get the fourcc class identifier of my object, this yields 'MYCL'

20: const FourCC& fourcc = myObj->GetClassFourCC();

你也可以向中央工廠查詢一個類是否已經(jīng)注冊:

1:     using namespace Core;

2:

3: // check if a class has been registered by class name

4: if (Factory::Instance()->ClassExists("MyNamespace::MyClass"))

5: {

6: // yep, the class exists

7: }

8:

9: // check if a class has been registered by class fourcc code

10: if (Factory::Instance()->ClassExists(FourCC('MYCL')))

11: {

12: // yep, the class exists

13: }

Nebula3單件

很多Nebula3的核心對象都是單件, 就是只存在一個實(shí)例, 并且所有其它對象都知道它.

你可以通過靜態(tài)方法Instance()來訪問單件, 它返回唯一實(shí)例的一個指針. 返回的指針保證是合法的. 如果在調(diào)用Instance()方法時對象實(shí)例不存在, 一個斷點(diǎn)會被拋出:

1: // obtain a pointer to the Core::Server singleton

2:     Ptr<Core::Server> coreServer = Core::Server::Instance();

你也可以檢查單件是否存在:

1: // does the Core::Server object exist?

2: if (Core::Server::HasInstance())

3: {

4: // yep, the core server exists

5: }

Nebula3提供了一些輔助的宏來實(shí)現(xiàn)單件:

1: // declare a singleton class

2: class MySingletonClass : public Core::RefCounted

3: {

4: DeclareClass(MySingletonClass);

5: DeclareSingleton(MySingletonClass);

6: public:

7: /// constructor

8:     MySingletonClass();

9: /// destructor

10: virtual ~MySingletonClass();

11: ...

12: };

13:

14: // implement the singleton class

15: ImplementClass(MyNamespace::MySingletonClass, 'MYSC', Core::RefCounted);

16: ImplementSingleton(MyNamespace::MySingletonClass);

17:

18: //------------------------------------------------------------------------------

19: /**

20:     Implements the Singleton constructor.

21: */

22: MySingletonClass::MySingletonClass()

23: {

24: ConstructSingleton;

25: }

26:

27: //------------------------------------------------------------------------------

28: /**

29:     Implements the Singleton destructor.

30: */

31: MySingletonClass:~MySingletonClass()

32: {

33: DestructSingleton;

34: }

DeclareSingleton()和ImplementSingleton()宏跟DeclareClass()和ImplementClass()宏差不多.它們在類中添加了一些靜態(tài)方法(也就是Instance()和HasInstance()). 類的構(gòu)造函數(shù)和析構(gòu)函數(shù)必須包含ConstructSingleton和DestructSingleton宏. ContructSingleton初始化了一個私有的單件指針并保證沒有其它的類實(shí)例存在(如果不是, 會拋出斷言). DestructSingleton讓私有的單件指針無效化.

單件的訪問默認(rèn)是只有本地線程. 這意味著在一個線程中創(chuàng)建的單件無法被其他線程訪問. 這使得”并行Nebula”大大簡化了多線程編程. “并行Nebula”的基本思想是, 一個典型的Nebula3應(yīng)用程序包含一些”Fat線程”, 每一個Fat線程都是運(yùn)行在一個單獨(dú)的CPU核心上. Fat線程可以用于實(shí)現(xiàn)異步IO, 渲染, 物理等等. 每一個Fat線程都初始化了它們自己的Nebula3運(yùn)行環(huán)境, 它們執(zhí)行特性任務(wù)所需的最少依賴. 這基本上消除了大部分Nebula3代碼的同步問題, 并且把線程相關(guān)的代碼集中到一個明確定義的代碼區(qū)域中. “并行Nebula”的另一個好處就是, 程序員在多線程環(huán)境中編程時不需要關(guān)心太多. 大多數(shù)Nebula3代碼看起來就像單線程代碼一樣, 但是它們卻運(yùn)行在各自的Fat線程中.

性能與內(nèi)存占用的考慮

Nebula3核心層的一個設(shè)計目標(biāo)就是減少底層代碼的內(nèi)存占用, 來更好的適應(yīng)微型平臺, 像手持設(shè)備. 這里有一些已經(jīng)完成的目標(biāo):

• RefCounted 類在每個實(shí)例中只增加了4byte用于引用計數(shù).
• RTTI機(jī)制在開頭增加了30 到 60 byte, 但是這是對于每個類來說的, 而是不是每個實(shí)例.
• 一個智能指針僅僅4 byte, 就像普通指針一樣.
• 一些監(jiān)控結(jié)構(gòu)只會在debug模型下創(chuàng)建，　特別是用來檢測引擎計數(shù)泄露的RefCountedList.

這里一些用三種不種的創(chuàng)建方法創(chuàng)建一百萬個RefCounted 對象所需的時間信息. 這些時間信息是在臺Intel Pentium 800 MHz的筆記本上得出的.  

• Create(): 0.29 seconds
• FourCC: 0.65 seconds
• 類名: 1.45 seconds