|
|
|
EFI Protocol VS C++ + g% ]+ Z% [+ E& t# w/ M7 {
1.Introduction
" s# A9 _5 p2 L& p( W! A1 ?8 L
Protocol是EFI引出的新概念,翻翻EDK就会发现与protocol相关的code散落在EFI的各个角落,大到host bus driver,小到Hello Word App都和protocol 脱不了关系,因此毫不夸张的说protocol应该是EFI的精髓所在,DXE阶段模块之间的通信都经由protocol完成(我觉得PEI阶段的ppi应该和protocol一个概念,只不过是限于PEI的特殊性而稍有差异而已).EFI Driver基本上就是使用一堆protocol的实现的一个可执行的文件.一个protocol就是一堆函数指针和数据成员的集合,官方称呼为protocol interface structure;这个protocol必须要定义一个GUID作为它的唯一标识,DXE driver使用Boot Service table中的类似InstallProtocolInterface等函数将porotocol安装到device handle上这就叫做produce protocol, InstallProtocolInterface成功的话该protocol就是published,后续其它driver使用该protocol就只要用Boot Service table中的LocateProtocol等相关函数从handle database中索引出该protocol就可以了.protocol为DXE阶段模块之间的通信提供了非常有效的手段.
% H$ C! k$ A1 ?& J3 v6 t `! G _ Q- W9 n! |
2.Protocol Implement OO
% P& {! i% `8 @) S, L! c7 M% t) }( m/ J, d
EFI是一个使用C实现的OO的Framework,它的OO特性主要经由protocl实现.EFI可以说是一个优秀的4 \4 z& K- Z/ L9 `' o
Framework, 对它的扩展可以优雅的实现.使用过C++这类面向对象语言的朋友都会知道OO有三大基本特性:1.Encapsulation,2.Inheritance,3.Polymorphism. 那么既然EFI是使用protocol实现的OO,那么protocol是如何实现这三大特性的呢?1 a, n. n' `! z; B
- }) B" Q1 p5 D: ]) ]; K) ^( r
1.Encapsulation的实现其实比较简单,它所表达的信息隐藏的概念,这个部分在protocol中可以方便的实现,protocol通常是函数指针和属性的集合,我们导出函数的接口,而将数据属性放在函数接口内部处理.如下述EDK中的code所示:' T, o6 g0 S6 S4 r4 O) u2 O; w
typedef struct _EFI_CPU_ARCH_PROTOCOL {
# ~& w7 e8 Q: O" p+ O s0 b
7 X9 g/ g: Q; d' s7 Y d+ X) @EFI_CPU_FLUSH_DATA_CACHE
# O( X" ?. ?: b8 FFlushDataCache;
2 E* F2 W6 Z& R$ K% B& {0 k r% k; ?6 G# F r2 X
EFI_CPU_ENABLE_INTERRUPT$ s) v2 p: w+ k. B3 X, t. w
EnableInterrupt;
% ^. I0 B6 M/ u# i& b. a2 D7 `; n9 i: q
EFI_CPU_DISABLE_INTERRUPT
: H% d: h3 A4 T4 q- sDisableInterrupt;' a9 g4 K" h$ u. U" i0 \+ Q' _& z
9 H+ k+ u7 ]( [% mEFI_CPU_GET_INTERRUPT_STATE) D% z3 @3 L" f# C# w X% W
GetInterruptState;
( B4 R8 p- F. {7 A/ \, x& |
" q9 S2 s8 ]& N% D* k. ZEFI_CPU_INIT7 `+ w4 |; Y" L
Init;
- O% T- J: c/ W1 I4 r, K# G2 y6 T+ T
EFI_CPU_REGISTER_INTERRUPT_HANDLER: s" l) G. t& r( ?# ]
: a/ k' X, I4 M7 m$ J. z. g7 s
RegisterInterruptHandler;
$ K& b/ T4 \/ J% M" S( M4 Z: t% W x; G. L/ P; V2 [ q" h! g) s7 @7 `* j
EFI_CPU_GET_TIMER_VALUE
) Y3 Z( P7 z; W" h9 bGetTimerValue;) n$ }. v$ j1 v% J
6 Q) L/ T% ~( u; h0 d; JEFI_CPU_SET_MEMORY_ATTRIBUTES/ U X c/ W- }, _7 ?
SetMemoryAttributes;9 T# P4 w# @; ~, }; G. c) V, O
# h* J$ Q0 k. O3 i5 rUINT32; m- ^4 o1 I2 u- v
0 R1 z! ~1 q7 E) \) q
NumberOfTimers;
6 I, F1 V3 V" q: t1 `! H8 W6 S5 P$ ]+ W u0 W5 S! `" Y) H
UINT32
' S0 d5 [: p3 {% X% W& [DmaBufferAlignment;
( e' G) W8 g6 B} EFI_CPU_ARCH_PROTOCOL;; c9 C7 ?" I0 T0 z; V$ G! `) a
像NumberOfTimers, DmaBufferAlignment就是数据属性了.
" Q1 k+ e3 p9 T3 Y9 A! V- }: h5 j; v U+ _+ b- D- f" |; @( f* j6 o
2.Inheritance子类继承了父类的所有的方法和属性,在C的级别上表示就是内
6 |1 {7 n+ g6 b6 Q存的叠加.同时它还代表的是IS-A的概念.如下面的sample所示B_PROTOCOL- }( H5 F6 ?! m% N4 S" x
继承自A_PROTOCOL.# d' \6 |7 o( `* [" _
typedef struct _ A_PROTOCOL {
4 J! @' y$ N* R3 t* [UINT32
) q8 v+ T! c' g! H. e1 H0 ^( M: _' S2 E$ [! h& f- T
A; A, e' _3 }+ T' J- e
3 N# C: t3 o+ X% p& u9 m0 T}A_PROTOCOL;
( w) d& G) r1 f, X& r2 Y' y# @$ F; ttypedef struct _ B_PROTOCOL {+ D* L" `1 M" B# B5 G* j$ C6 B
A_ PROTOCOL" n: r) Z6 e6 i" w$ T l
; i6 ^$ M: F0 n' n* T" R
AP;- t2 |9 ~ [$ X" B$ }' I
UINT32
i o7 _- y6 M& H6 u7 iB;
; ~- A5 B t5 _7 |( P" M}B_PROTOCOL;
, y' v# O- P/ M m它们的类图如下图1所示,内存布局如下图2所示:) J+ M; r/ }0 ?$ z
- m' p# F* O! j/ G4 j% V, Y8 a) J% r/ U+ y0 D' L( v
' L1 @" |2 K. e8 `
6 d# t$ N* u4 h4 K% E' |
3. Polymorphism是面向对象的精髓所在了,如果没有了多态,则只能称之为基于对象了.多态是指基于相同的接口实现的不同的class(EFI之中应该是指实现protocol的driver),具有不同的行为.如两个EFI Driver A&B 它们都实现了ComponentName protocol,A在它的GetDriverName interface回复的Driver Name是”A”而Driver B则回复的是”B”,所以同样的接口具有不同的行为.protocol相当于一个共同的接口,因此我们可以以统一的方式去管理和配置这些实现了该protocol的这些Driver.如shell app dirver.efi它就是通过枚举Handle database找到挂在这些device handle上的ComponentName protocol,然后call它们的GetDriverName interface获悉driver的名字信息.
) r" h" X. C$ F" f/ S, |+ D3 w7 U* g8 s. h$ t2 X
3.Who Win(Protocol vs C++)?
. R2 \- B( V; i8 q, D. v; k
& b& v- u) `5 W- w8 \1 B( g 看上去貌似用protocol实现OO特性还是比较费事的,那么为什么不直接使用C++实现呢?我不知道真正/ ` P9 R2 R- A* N+ k$ p
原因L!呵呵,可是我猜有可能的几种原因如下:. O6 s* t2 V7 G! f' O! C6 k1 N
6 v+ |7 e/ U, O) H- h$ d. t
1. C++无法做到二进制级别上的复用,C++是一个非常复杂的语言,它有非常多的特性,C++标准委员会制定出了编译器厂商所需要实现的一堆特性,比如构造函数,析构函数,继承,重载,多态等等一堆的规则,但是标准委员会并没有规定编译器厂商如何实现这些特性于是问题就来了,我们使用A厂商编译器build driver da和B厂商编译器build同一只driver da它们的内存布局就不相同,于是二进制级别上的互操作就不可能了,设备厂商都要把source code拿出来放在一个编译器上build 才OK，不同的编译器实现不同的一个地方就体现在实现多态时，vptr存放的位置上，有一些编译器会把该指针放在对象内存布局的头部，有些厂商则喜欢放在尾部，这个差异非常大；如果存在多重继承那么就可能出现多个vptr那么vptr摆放的顺序又会有不同等等不胜其扰的问题。而protocol使用标准的c实现，它就没有二进制文件不一致的问题。
$ W. X8 `0 s( t# |# h2 B
4 D7 N2 K4 u; E6 a+ q, x2．C++实现多态，虚继承以及name mangling等会带来空间以及编译时间上的开销。C++中的多态是通过在基类的函数声明中加上virtual实现的，这一个关键字里面大有文章，我们使用一个class VI演示该过程：3 E/ }+ T5 M' \9 |/ K
class VI. u4 D( b @+ H8 w/ m9 u
{7 M2 z: |1 f& N) p! g" b
1 {/ S7 _+ _$ z- iint a;/ d- A) f2 g" I+ B/ U! z! [( v4 \
8 u* y/ g6 P" h
int b;
8 e; ^: o3 J+ _' D+ ?! q1 n; O4 m, @0 i- l
void test0(void) virtual;
. G6 N8 v P# q# y4 I};
4 i4 {% H# E) B' \: w+ g没有virtual这个关键字的时候它的内存布局如下图3所示，加上之后就如图4所示：/ E5 k/ G: j9 }/ k6 [1 d
n& Z+ r* O- |, O7 c' W7 G! d
* {5 T/ ]( L( t
2 d# }' U" M4 @: G: a! r6 b4 }( b A7 O7 v
% E% f! f# X* a& y' ~编译器通过增加一个vptr虚函数指针，和vtbl虚函数表实现多态的功能，一旦子类改写了test0那么子类就会修改掉vtbl中的test0的地址。如此一来开销就来了J,一旦涉及到虚继承多重继承，那个开销就更大了。相比较来看protocol的实现就完全没有这个问题。% I' J; S ~ t/ ^
" C: v8 s. m+ n3 r- ]: d6 a
3．C++使用字符命名对象会有命名冲突的可能而protocol使用64位GUID是不可能出现命名冲突的。当project大到一定程度就会感受到变量命名冲突的讨厌了，你定义的变量可能在别的你不知道的模块里已经被用过了，然后编译器报上一大堆另人恐慌的错误出来。当然C++也有解决命名冲突的方法，那就是namespace可是这样又会造成性能上的影响。, J% e, W" g. R
' [8 p8 U S2 J6 ]; a; y
所以综上所述，protocol应该较C++稍有优势一点哦J,它完整的实现了OO的所有特性，而无性能上的损耗只是感官上有些差异，如intel的spec所说的那样Look/fell very different.- A' l( ~% V1 v2 N9 Q! B
4 S9 a+ ?8 B1 J( nThat’s all!
/ w+ G# K1 ^" ^( Z, b
1 y4 e% Z9 G: r7 e8 Q X& qEnjoy it!
' s' _& ?2 g& z8 b" o
; m7 t- h+ Q8 [, s" vPeter _) @& L$ X8 E- Z
5 B& b' Y6 M' ^5 m$ d' |
3 W- c6 l. n9 {. q( W
8 X! b( p1 m5 U[ 本帖最后由 peterhu 于 2009-7-13 17:05 编辑 ] |
本帖子中包含更多资源
您需要 登录 才可以下载或查看，没有账号？加入计匠网
×
|
IP卡
狗仔卡
发表于 2009-7-13 17:02:50
提升卡
置顶卡
沉默卡
喧嚣卡
变色卡
显身卡
发表于 2010-5-18 10:36:06