开启辅助访问
 找回密码
 注册帐号

扫一扫,访问微社区

Unreal Engine4

关注:349

当前位置:游戏蛮牛 技术专区 Unreal Engine4

查看: 165|回复: 0

[UE4教程] 虚幻4蓝图虚拟机剖析

[复制链接]  [移动端链接]
6蛮牛粉丝
1062/1500
排名
2935
昨日变化
16

203

主题

239

帖子

1062

积分

Rank: 6Rank: 6Rank: 6

UID
128653
好友
0
蛮牛币
2453
威望
0
注册时间
2015-11-12
在线时间
149 小时
最后登录
2017-5-27
发表于 2017-1-12 15:21:55 | 显示全部楼层 |阅读模式

马上注册,结交更多好友,享用更多功能,让你轻松玩转社区。

您需要 登录 才可以下载或查看,没有帐号?注册帐号

x

前言

这里,我们打算对虚幻4 中蓝图虚拟机的实现做一个大概的讲解,如果对其它的脚本语言的实现有比较清楚的认识,理解起来会容易很多,我们先会对相关术语进行一个简单的介绍,然后会对蓝图虚拟机的实现做一个讲解。

术语

编程语言一般分为编译语言和解释型语言。

编译型语言

程序在执行之前需要一个专门的编译过程,把程序编译成 为机器语言的文件,运行时不需要重新翻译,直接使用编译的结果就行了。程序执行效率高,依赖编译器,跨平台性差些。如C、C++、Delphi等.

解释性语言

编写的程序不进行预先编译,以文本方式存储程序代码。在发布程序时,看起来省了道编译工序。但是,在运行程序的时候,解释性语言必须先解释再运行。

然而关于Java、C#等是否为解释型语言存在争议,因为它们主流的实现并不是直接解释执行的,而是也编译成字节码,然后再运行在jvm等虚拟机上的。



UE4中蓝图的实现更像是lua的实现方式,它并不能独立运行,而是作为一种嵌入宿主语言的一种扩展脚本,lua可以直接解释执行,也可以编译成字节码并保存到磁盘上,下次调用可以直接加载编译好的字节码执行。

什么是虚拟机

虚拟机最初由波佩克[a]与戈德堡定义为有效的、独立的真实机器的副本。当前包括跟任何真实机器无关的虚拟机。虚拟机根据它们的运用和与直接机器的相关性分为两大类。系统虚拟机(如VirtualBox)提供一个可以运行完整操作系统的完整系统平台。相反的,程序虚拟机(如Java JVM)为运行单个计算机程序设计,这意謂它支持单个进程。虚拟机的一个本质特点是运行在虚拟机上的软件被局限在虚拟机提供的资源里——它不能超出虚拟世界。



而这里我们主要关心的是程序虚拟机,VM既然被称为"机器",一般认为输入是满足某种指令集架构(instruction set architecture,ISA)的指令序列,中间转换为目标ISA的指令序列并加以执行,输出为程序的执行结果的,就是VM。源与目标ISA可以是同一种,这是所谓same-ISA VM。

分类

虚拟机实现分为基于寄存器的虚拟机和基于栈的虚拟机。

三地址指令

a = b + c;



如果把它变成这种形式:

add a, b, c

那看起来就更像机器指令了,对吧?这种就是所谓"三地址指令"(3-address instruction),一般形式为:

op dest, src1, src2

许多操作都是二元运算+赋值。三地址指令正好可以指定两个源和一个目标,能非常灵活的支持二元操作与赋值的组合。ARM处理器的主要指令集就是三地址形式的。

二地址指令

a += b;



变成:

add a, b

这就是所谓"二地址指令",一般形式为:

op dest, src

它要支持二元操作,就只能把其中一个源同时也作为目标。上面的add a, b在执行过后,就会破坏a原有的值,而b的值保持不变。x86系列的处理器就是二地址形式的。

一地址指令

显然,指令集可以是任意"n地址"的,n属于自然数。那么一地址形式的指令集是怎样的呢?

想像一下这样一组指令序列:

add 5

sub 3

这只指定了操作的源,那目标是什么?一般来说,这种运算的目标是被称为"累加器"(accumulator)的专用寄存器,所有运算都靠更新累加器的状态来完成。那么上面两条指令用C来写就类似:

C代码 收藏代码

acc += 5;

acc -= 3;



只不过acc是"隐藏"的目标。基于累加器的架构近来比较少见了,在很老的机器上繁荣过一段时间。

零地址指令

那"n地址"的n如果是0的话呢?

看这样一段Java字节码:

Java bytecode代码 收藏代码

iconst_1

iconst_2

iadd

istore_0



注意那个iadd(表示整型加法)指令并没有任何参数。连源都无法指定了,零地址指令有什么用??

零地址意味着源与目标都是隐含参数,其实现依赖于一种常见的数据结构——没错,就是栈。上面的iconst_1、iconst_2两条指令,分别向一个叫做"求值栈"(evaluation stack,也叫做operand stack"操作数栈"或者expression stack"表达式栈")的地方压入整型常量1、2。iadd指令则从求值栈顶弹出2个值,将值相加,然后把结果压回到栈顶。istore_0指令从求值栈顶弹出一个值,并将值保存到局部变量区的第一个位置(slot 0)。

零地址形式的指令集一般就是通过"基于栈的架构"来实现的。请一定要注意,这个栈是指"求值栈",而不是与系统调用栈(system call stack,或者就叫system stack)。千万别弄混了。有些虚拟机把求值栈实现在系统调用栈上,但两者概念上不是一个东西。



由于指令的源与目标都是隐含的,零地址指令的"密度"可以非常高——可以用更少空间放下更多条指令。因此在空间紧缺的环境中,零地址指令是种可取的设计。但零地址指令要完成一件事情,一般会比二地址或者三地址指令许多更多条指令。上面Java字节码做的加法,如果用x86指令两条就能完成了:

mov eax, 1

add eax, 2

基于栈与基于寄存器结构的区别

保存临时值的位置不同
基于栈:将临时值保存在求值栈上。
基于寄存器:将临时值保存在寄存器中。
代码所占体积不同
基于栈:代码紧凑,体积小,但所需要的代码条件多
基于寄存器:代码相对大些,但所需要的代码条件少
基于栈中的"栈"指的是"求值栈",JVM中"求值栈"被称为"操作数栈"。

1.png

栈帧

栈帧也叫过程活动记录,是编译器用来实现过程/函数调用的一种数据结构。从逻辑上讲,栈帧就是一个函数执行的环境:函数参数、函数的局部变量、函数执行完后返回到哪里等等。

蓝图虚拟机的实现

前面我们已经简单得介绍了虚拟机的相关术语,接下来我们来具体讲解下虚幻4中蓝图虚拟机的实现。

字节码

虚拟机的字节码在Script.h文件中,这里我们把它全部列出来,因为是专用的脚本语言,所以它里面会有一些特殊的字节码,如代理相关的代码(EX_BindDelegate、EX_AddMulticastDelegate),当然常用的语句也是有的,比如赋值、无条件跳转指令、条件跳转指令、switch等。

[C++] 纯文本查看 复制代码
//

// Evaluatable expression item types.

//

enum EExprToken

{

    // Variable references.

    EX_LocalVariable        = 0x00,    // A local variable.

    EX_InstanceVariable        = 0x01,    // An object variable.

    EX_DefaultVariable        = 0x02, // Default variable for a class context.

    //                        = 0x03,

    EX_Return                = 0x04,    // Return from function.

    //                        = 0x05,

    EX_Jump                    = 0x06,    // Goto a local address in code.

    EX_JumpIfNot            = 0x07,    // Goto if not expression.

    //                        = 0x08,

    EX_Assert                = 0x09,    // Assertion.

    //                        = 0x0A,

    EX_Nothing                = 0x0B,    // No operation.

    //                        = 0x0C,

    //                        = 0x0D,

    //                        = 0x0E,

    EX_Let                    = 0x0F,    // Assign an arbitrary size value to a variable.

    //                        = 0x10,

    //                        = 0x11,

    EX_ClassContext            = 0x12,    // Class default object context.

    EX_MetaCast = 0x13, // Metaclass cast.

    EX_LetBool                = 0x14, // Let boolean variable.

    EX_EndParmValue            = 0x15,    // end of default value for optional function parameter

    EX_EndFunctionParms        = 0x16,    // End of function call parameters.

    EX_Self                    = 0x17,    // Self object.

    EX_Skip                    = 0x18,    // Skippable expression.

    EX_Context                = 0x19,    // Call a function through an object context.

    EX_Context_FailSilent    = 0x1A, // Call a function through an object context (can fail silently if the context is NULL; only generated for functions that don't have output or return values).

    EX_VirtualFunction        = 0x1B,    // A function call with parameters.

    EX_FinalFunction        = 0x1C,    // A prebound function call with parameters.

    EX_IntConst                = 0x1D,    // Int constant.

    EX_FloatConst            = 0x1E,    // Floating point constant.

    EX_StringConst            = 0x1F,    // String constant.

    EX_ObjectConst         = 0x20,    // An object constant.

    EX_NameConst            = 0x21,    // A name constant.

    EX_RotationConst        = 0x22,    // A rotation constant.

    EX_VectorConst            = 0x23,    // A vector constant.

    EX_ByteConst            = 0x24,    // A byte constant.

    EX_IntZero                = 0x25,    // Zero.

    EX_IntOne                = 0x26,    // One.

    EX_True                    = 0x27,    // Bool True.

    EX_False                = 0x28,    // Bool False.

    EX_TextConst            = 0x29, // FText constant

    EX_NoObject                = 0x2A,    // NoObject.

    EX_TransformConst        = 0x2B, // A transform constant

    EX_IntConstByte            = 0x2C,    // Int constant that requires 1 byte.

    EX_NoInterface            = 0x2D, // A null interface (similar to EX_NoObject, but for interfaces)

    EX_DynamicCast            = 0x2E,    // Safe dynamic class casting.

    EX_StructConst            = 0x2F, // An arbitrary UStruct constant

    EX_EndStructConst        = 0x30, // End of UStruct constant

    EX_SetArray                = 0x31, // Set the value of arbitrary array

    EX_EndArray                = 0x32,

    //                        = 0x33,

    EX_UnicodeStringConst = 0x34, // Unicode string constant.

    EX_Int64Const            = 0x35,    // 64-bit integer constant.

    EX_UInt64Const            = 0x36,    // 64-bit unsigned integer constant.

    //                        = 0x37,

    EX_PrimitiveCast        = 0x38,    // A casting operator for primitives which reads the type as the subsequent byte

    //                        = 0x39,

    //                        = 0x3A,

    //                        = 0x3B,

    //                        = 0x3C,

    //                        = 0x3D,

    //                        = 0x3E,

    //                        = 0x3F,

    //                        = 0x40,

    //                        = 0x41,

    EX_StructMemberContext    = 0x42, // Context expression to address a property within a struct

    EX_LetMulticastDelegate    = 0x43, // Assignment to a multi-cast delegate

    EX_LetDelegate            = 0x44, // Assignment to a delegate

    //                        = 0x45,

    //                        = 0x46, // CST_ObjectToInterface

    //                        = 0x47, // CST_ObjectToBool

    EX_LocalOutVariable        = 0x48, // local out (pass by reference) function parameter

    //                        = 0x49, // CST_InterfaceToBool

    EX_DeprecatedOp4A        = 0x4A,

    EX_InstanceDelegate        = 0x4B,    // const reference to a delegate or normal function object

    EX_PushExecutionFlow    = 0x4C, // push an address on to the execution flow stack for future execution when a EX_PopExecutionFlow is executed. Execution continues on normally and doesn't change to the pushed address.

    EX_PopExecutionFlow        = 0x4D, // continue execution at the last address previously pushed onto the execution flow stack.

    EX_ComputedJump            = 0x4E,    // Goto a local address in code, specified by an integer value.

    EX_PopExecutionFlowIfNot = 0x4F, // continue execution at the last address previously pushed onto the execution flow stack, if the condition is not true.

    EX_Breakpoint            = 0x50, // Breakpoint. Only observed in the editor, otherwise it behaves like EX_Nothing.

    EX_InterfaceContext        = 0x51,    // Call a function through a native interface variable

    EX_ObjToInterfaceCast = 0x52,    // Converting an object reference to native interface variable

    EX_EndOfScript            = 0x53, // Last byte in script code

    EX_CrossInterfaceCast    = 0x54, // Converting an interface variable reference to native interface variable

    EX_InterfaceToObjCast = 0x55, // Converting an interface variable reference to an object

    //                        = 0x56,

    //                        = 0x57,

    //                        = 0x58,

    //                        = 0x59,

    EX_WireTracepoint        = 0x5A, // Trace point. Only observed in the editor, otherwise it behaves like EX_Nothing.

    EX_SkipOffsetConst        = 0x5B, // A CodeSizeSkipOffset constant

    EX_AddMulticastDelegate = 0x5C, // Adds a delegate to a multicast delegate's targets

    EX_ClearMulticastDelegate = 0x5D, // Clears all delegates in a multicast target

    EX_Tracepoint            = 0x5E, // Trace point. Only observed in the editor, otherwise it behaves like EX_Nothing.

    EX_LetObj                = 0x5F,    // assign to any object ref pointer

    EX_LetWeakObjPtr        = 0x60, // assign to a weak object pointer

    EX_BindDelegate            = 0x61, // bind object and name to delegate

    EX_RemoveMulticastDelegate = 0x62, // Remove a delegate from a multicast delegate's targets

    EX_CallMulticastDelegate = 0x63, // Call multicast delegate

    EX_LetValueOnPersistentFrame = 0x64,

    EX_ArrayConst            = 0x65,

    EX_EndArrayConst        = 0x66,

    EX_AssetConst            = 0x67,

    EX_CallMath                = 0x68, // static pure function from on local call space

    EX_SwitchValue            = 0x69,

    EX_InstrumentationEvent    = 0x6A, // Instrumentation event

    EX_ArrayGetByRef        = 0x6B,

    EX_Max                    = 0x100,

};


栈帧

在Stack.h中我们可以找到FFrame的定义,虽然它定义的是一个结构体,但是执行当前代码的逻辑是封装在这里面的。下面让我们看一下它的数据成员:

[C++] 纯文本查看 复制代码
// Variables.

    UFunction* Node;

    UObject* Object;

    uint8* Code;

    uint8* Locals;

 

    UProperty* MostRecentProperty;

    uint8* MostRecentPropertyAddress;

 

    /** The execution flow stack for compiled Kismet code */

    FlowStackType FlowStack;

 

    /** Previous frame on the stack */

    FFrame* PreviousFrame;

 

    /** contains information on any out parameters */

    FOutParmRec* OutParms;

 

    /** If a class is compiled in then this is set to the property chain for compiled-in functions. In that case, we follow the links to setup the args instead of executing by code. */

    UField* PropertyChainForCompiledIn;

 

    /** Currently executed native function */

    UFunction* CurrentNativeFunction;

 

    bool bArrayContextFailed;


我们可以看到,它里面保存了当前执行的脚本函数,执行该脚本的UObject,当前代码的执行位置,局部变量,上一个栈帧,调用返回的参数(不是返回值),当前执行的原生函数等。而调用函数的返回值是放在了函数调用之前保存,调用结束后再恢复。大致如下所示:

[C++] 纯文本查看 复制代码
uint8 * SaveCode = Stack.Code;

// Call function

….

Stack.Code = SaveCode


下面我们列出FFrame中跟执行相关的重要函数:

[C++] 纯文本查看 复制代码
// Functions.

    COREUOBJECT_API void Step( UObject* Context, RESULT_DECL );

 

    /** Replacement for Step that uses an explicitly specified property to unpack arguments **/

    COREUOBJECT_API void StepExplicitProperty(void*const Result, UProperty* Property);

 

    /** Replacement for Step that checks the for byte code, and if none exists, then PropertyChainForCompiledIn is used. Also, makes an effort to verify that the params are in the correct order and the types are compatible. **/

    template<class TProperty>

    FORCEINLINE_DEBUGGABLE void StepCompiledIn(void*const Result);

 

    /** Replacement for Step that checks the for byte code, and if none exists, then PropertyChainForCompiledIn is used. Also, makes an effort to verify that the params are in the correct order and the types are compatible. **/

    template<class TProperty, typename TNativeType>

    FORCEINLINE_DEBUGGABLE TNativeType& StepCompiledInRef(void*const TemporaryBuffer);

 

    COREUOBJECT_API virtual void Serialize( const TCHAR* V, ELogVerbosity::Type Verbosity, const class FName& Category ) override;

    

    COREUOBJECT_API static void KismetExecutionMessage(const TCHAR* Message, ELogVerbosity::Type Verbosity, FName WarningId = FName());

 

    /** Returns the current script op code */

    const uint8 PeekCode() const { return *Code; }

 

    /** Skips over the number of op codes specified by NumOps */

    void SkipCode(const int32 NumOps) { Code += NumOps; }

 

    template<typename TNumericType>

    TNumericType ReadInt();

    float ReadFloat();

    FName ReadName();

    UObject* ReadObject();

    int32 ReadWord();

    UProperty* ReadProperty();

 

    /** May return null */

    UProperty* ReadPropertyUnchecked();

 

    /**

     * Reads a value from the bytestream, which represents the number of bytes to advance

     * the code pointer for certain expressions.

     *

     * @param    ExpressionField        receives a pointer to the field representing the expression; used by various execs

     *                                to drive VM logic

     */

    CodeSkipSizeType ReadCodeSkipCount();

 

    /**

     * Reads a value from the bytestream which represents the number of bytes that should be zero'd out if a NULL context

     * is encountered

     *

     * @param    ExpressionField        receives a pointer to the field representing the expression; used by various execs

     *                                to drive VM logic

     */

    VariableSizeType ReadVariableSize(UProperty** ExpressionField);


像ReadInt()、ReadFloat()、ReadObject()等这些函数,我们看到它的名字就知道它是做什么的,就是从代码中读取相应的int、float、UObject等。这里我们主要说下Step()函数,它的代码如下所示:

[C++] 纯文本查看 复制代码
void FFrame::Step(UObject *Context, RESULT_DECL)

{

    int32 B = *Code++;

    (Context->*GNatives[B])(*this,RESULT_PARAM);

}


可以看到,它的主要作用就是取出指令,然后在原生函数数组中找到对应的函数去执行。

字节码对应函数

前面我们列出了所有的虚拟机的所有字节码,那么对应每个字节码具体执行部分的代码在哪里呢,具体可以到ScriptCore.cpp中查找定义,我们可以看到每个字节码对应的原生函数都在GNatives和GCasts里面:

它们的声明如下:

[C++] 纯文本查看 复制代码
/** The type of a native function callable by script */

typedef void (UObject::*Native)( FFrame& TheStack, RESULT_DECL );

Native GCasts[];

Native GNatives[EX_Max];


这样它都会对每一个原生函数调用一下注册方法,通过IMPLEMENT_VM_FUNCTION和IMPLEMENT_CAST_FUNCTION宏实现。

具体代码如下图所示:

[C++] 纯文本查看 复制代码
#define IMPLEMENT_FUNCTION(cls,func) \

    static FNativeFunctionRegistrar cls##func##Registar(cls::StaticClass(),#func,(Native)&cls::func);

 

#define IMPLEMENT_CAST_FUNCTION(cls, CastIndex, func) \

    IMPLEMENT_FUNCTION(cls, func); \

    static uint8 cls##func##CastTemp = GRegisterCast( CastIndex, (Native)&cls::func );

 

#define IMPLEMENT_VM_FUNCTION(BytecodeIndex, func) \

    IMPLEMENT_FUNCTION(UObject, func) \

    static uint8 UObject##func##BytecodeTemp = GRegisterNative( BytecodeIndex, (Native)&UObject::func );


可以看到,它是定义了一个全局静态对象,这样就会在程序的main函数执行前就已经把函数放在数组中对应的位置了,这样在虚拟机执行时就可以直接调用到对应的原生函数了。

执行流程

我们前面讲蓝图的时候讲过蓝图如何跟C++交互,包括蓝图调用C++代码,以及从C++代码调用到蓝图里面去。

C++调用蓝图函数

[C++] 纯文本查看 复制代码
UFUNCTION(BlueprintImplementableEvent, Category = "AReflectionStudyGameMode")

void ImplementableFuncTest();

 

void AReflectionStudyGameMode::ImplementableFuncTest()

{

ProcessEvent(FindFunctionChecked(REFLECTIONSTUDY_ImplementableFuncTest),NULL);

}


因为我们这个函数没有参数,所有ProcessEvent中传了一个NULL,如果是有参数和返回值等,那么UHT会自动生成一个结构体用于存储参数和返回值等,这样当在C++里面调用函数时,就会去找REFLECTIONSTUDY_ImplementableFuncTest这个名字对应的蓝图UFunction,如果找到那么就会调用ProcessEvent来做进一步的处理。

ProcessEvent流程

2.png

3.png

蓝图调用C++函数

[C++] 纯文本查看 复制代码
UFUNCTION(BlueprintCallable, Category = "AReflectionStudyGameMode")

void CallableFuncTest();

 

DECLARE_FUNCTION(execCallableFuncTest) \

{ \

P_FINISH; \

P_NATIVE_BEGIN; \

this->CallableFuncTest(); \

P_NATIVE_END; \

}


如果是通过蓝图调用的C++函数,那么UHT会生成如上的代码,并且如果有参数的话,会调用P_GET_UBOOL等来获取对应的参数,如果有返回值的话也会将返回值赋值。

总结

至此,加上前面我们对蓝图编译的剖析,加上蓝图虚拟机的讲解,我们已经对蓝图的实现原理有一个比较深入的了解,本文并没有对蓝图的前身unrealscript进行详细的讲解。有了这个比较深入的认识后(如果想要有深刻的认识,必须自己去看代码),相信大家在设计蓝图时会更游刃有余。当然如果有错误的地方也请大家指正,欢迎大家踊跃讨论。接下来可能会把重心放到虚幻4渲染相关的模块上,包括渲染API跨平台相关,多线程渲染,渲染流程,以及渲染算法上面,可能中间也会穿插一些其他的模块(比如动画、AI等),欢迎大家持续关注,如果你有想提前了解的章节,也欢迎在下面留言,我可能会根据大家的留言来做优先级调整。

参考文章

https://www.usenix.org/legacy/ev ... pers/p153-yunhe.pdf
http://rednaxelafx.iteye.com/blog/492667
http://www.zhihu.com/question/19608553
https://zh.wikipedia.org/wiki/%E ... C%E6%A9%9F%E5%99%A8
Java Program in Action 莫枢


回复

使用道具 举报

您需要登录后才可以回帖 登录 | 注册帐号

本版积分规则

快速回复 返回顶部 返回列表