JIT and AOT
The platform may be provided ILRUNTIME, if the JIT Andrews to use, if the IOS executed by an interpreter to interpret
Why not pass on IOS DLL heat more
reason: UNITY in IOS are AOT compiled before the program that is already running the IL code is compiled into native machine code,
https://blog.csdn.net/yy405145590/article/details / 41282669? locationNum = 14
Compiling the source code that implements MONO [more] heat
MONO source has an interface mono_image_open_from_data_with_name, the function is used to load Assembly-CSharp.dll,
this interface is the same in the IOS and Andrews, Andrews in more heat can be achieved by modifying it in IOS is not, speculate on the reasons:
1, Andrews support JIT, mono_image_open_from_data_with_name return the IL code can be side explained the program is running simultaneous implementation
2, IOS, U3D executed in the IOS platform is FULL AOT, namely call mono_image_open_from_data_with_name in the IPA installation to load Assembly-CSharp.dll and compiled machine code is generated and stored locally on the phone, after installation are generated when executing machine code each time you run, it can not achieve more heat
References: https:? //Blog.csdn.net/yy405145590/article/details/41282669 locationNum = 14
This interface
Reference:
. 1, HTTPS: //www.iteye.com/blog/wanzhanzhuce-2265055
2, we know that C # script will first be compiled into IL code, and then reads the IL code from memory and converts it to a CLR native code, which is the operational mechanism of .NET, and Mono is an implementation of the open source community of .NET, Mono C # compiler code is divided into two kinds, namely time compilation JIT (dynamic) and compiled ahead of AOT (static ), which are two ways to compile Mono can provide for us. And objectively speaking, iOS prohibited by JIT compiled in this way, so you can not bypass the AppStore directly on the program update, because even if you update a C # script because these scripts are not compiled, it is not directly apply the actual environment, and the use Lua heat update, actually changing the logic of the application layer, core logic is still in the game was released on application packaging and together, because without compiling Lua, so it can be as plain text Like to update the resource, and not as Lua during runtime C # generate new code, it is always calling code that already exists. In summary therefore, the key to Unity engine on iOS is not hot update iOS system in the immediate ban JIT compiler that permission, the pot Unity and Mono are not back, thank you!
Mono restrictions in Full AOT mode
https://www.cnblogs.com/tekkaman/p/3973452.html?utm_source=tuicool&utm_medium=referral
AOT compilation is executed at the time of installation, such as when the UNITY of APK-based installation, IL native code will be compiled to native code that is stored in the phone's storage,
and therefore AOT would increase the installation time.
Benefits are: program start fast, small memory footprint, small enclaves
JIT is run to open a thread, while compiling side execution, generally function as a unit, compiled machine code will be cached, direct access when used at once.
IOS disables the JIT principle is: Disable the code execution privileges on the heap.
参考资料：
1，https://www.zhihu.com/question/23874627
2，https://www.jianshu.com/p/a07bd632337a
3，https://www.cnblogs.com/murongxiaopifu/p/4278947.html
Use heat more domain principle:
https://www.cnblogs.com/Leo_wl/p/4255533.html
unity is more heat - 2 large version of the game updates and hot update
https://blog.csdn.net/u014748818/article/details/78812728?depth_1-utm_source=distribute.pc_relevant.none-task&utm_source=distribute.pc_relevant.none-task
Unity Android updated dynamically-CSharp.dll Assembly
http://blog.sina.com.cn/s/blog_9e5d42ee0102vvtg.html