读懂IL代码就这么简单(三)完结篇
一 前言
写了两篇关于IL指令相关的文章,分别把值类型与引用类型在 堆与栈上的操作区别详细的写了一遍
这第三篇也是最后一篇,之所以到第三篇就结束了,是因为以我现在的层次,能理解到的都写完了,而且个人认为,重要的地方都差不多
写到了,
最后一篇决定把之前的内容全部整合起做一个综合的例子,然后简单的解释下IL指令的含义,及在内存中的变化
如果你没有看前两篇请狂点这里
IL指令大全 :IL指令详解
IL反编译工具: ILDasm
注:因本人水平有限,难免有理解错误之处,如有发现,望及时指出,我会立马更正。
二 IL指令详解 (基本介绍)
这次把 类 委托 方法 字段都集合起来,这样的环境就与实际的项目比较接近了,也算接地气了
先看C#代码
1 public delegate void MyDele(string name); 2 class Program 3 { 4 static void Main(string[] args) 5 { 6 7 UserInfo userInfo = new UserInfo(); 8 9 PeopleStruct peopleStruct = new PeopleStruct(); 10 11 //定义委托 12 MyDele myDele = userInfo.PrintName; 13 //调用委托 14 myDele("Delegate"); 15 16 userInfo.PrintName("PrintName"); 17 userInfo.PrintField(); 18 //静态方法 19 UserInfo.ContactStr("UserInfo", "ContactStr"); 20 //结构的方法 21 peopleStruct.PrintInfo("Color is Yellow"); 22 23 //静态类中的静态方法 24 StaticUserInfo.PrintName("Static Class Static Method"); 25 26 Console.Read(); 27 } 28 } 29 30 internal class UserInfo 31 { 32 public string Name = "UserInfo Field"; 33 34 public void PrintName(string name) 35 { 36 Console.WriteLine(name); 37 } 38 39 public void PrintField() 40 { 41 Console.WriteLine(Name); 42 } 43 44 public static void ContactStr(string Str, string Str2) 45 { 46 Console.WriteLine(Str + Str2); 47 } 48 49 } 50 51 struct PeopleStruct 52 { 53 54 public void PrintInfo(string color) 55 { 56 Console.WriteLine(color); 57 } 58 59 } 60 61 static class StaticUserInfo 62 { 63 public static void PrintName(string name) 64 { 65 Console.WriteLine(name); 66 } 67 }
IL 代码
call可以调用静态方法,实例方法和虚方法
callvirt只能调用实例方法和虚方法,不能调用静态方法
1 .method private hidebysig static void Main(string[] args) cil managed 2 { 3 .entrypoint 4 // Code size 106 (0x6a) 5 .maxstack 2 6 .locals init (class ILDeom3.UserInfo V_0, //只定义变量并不做任何初始化操作 7 valuetype ILDeom3.PeopleStruct V_1, 8 class ILDeom3.MyDele V_2) 9 IL_0000: nop 10 //创建一个值类型的新对象或新实例,并将对象引用推送到计算堆栈上 11 IL_0001: newobj instance void ILDeom3.UserInfo::.ctor() 12 //把栈中顶部的元素弹出(UserInfo 的实例)并赋值给局部变量表中第0个位置的元素(V_0) 13 IL_0006: stloc.0 14 //将位于特定索引处的局部变量的 "地址" 加载到计算堆栈上(将指向结构的地址压入栈中) 15 IL_0007: ldloca.s V_1 16 //初始化结构中的属性 17 IL_0009: initobj ILDeom3.PeopleStruct 18 //将局部变量列表中第0个位置(V_0 UerInfo的实例地址)的值压入栈中 19 IL_000f: ldloc.0 20 //将指向实现特定方法的本机代码的非托管指针(native int 类型)推送到计算堆栈上。 21 //也就是指的将方法指针压入栈中 22 IL_0010: ldftn instance void ILDeom3.UserInfo::PrintName(string) 23 //创建委托的实例并压入栈中 24 //这一步会调用委托的构造器,这个构造器需要两个参数,一个对象引用,就是IL_000f: ldloc.0压入的UserInfo的实例,一个方法的地址。 25 IL_0016: newobj instance void ILDeom3.MyDele::.ctor(object,native int) 26 //弹出栈中值(委托的实例)保存到局部变量表第2个位置(V_2) 27 IL_001b: stloc.2 28 //获取局部变量列表中第2个位置上的值上一步保存的值(委托实例),并压入栈中 29 IL_001c: ldloc.2 30 //加载字符串 31 IL_001d: ldstr "Delegate" 32 //调用绑定给委托的PrintName方法 33 IL_0022: callvirt instance void ILDeom3.MyDele::Invoke(string) 34 IL_0027: nop 35 //获取局部变量列表中第0个位置上的值(UserInfo的实例) 36 IL_0028: ldloc.0 37 IL_0029: ldstr "PrintName" 38 //调用PrintName方法 39 IL_002e: callvirt instance void ILDeom3.UserInfo::PrintName(string) 40 IL_0033: nop 41 //获取局部变量列表中第0个位置上的值(UserInfo的实例) 42 IL_0034: ldloc.0 43 //调用PrintField方法 44 IL_0035: callvirt instance void ILDeom3.UserInfo::PrintField() 45 IL_003a: nop 46 IL_003b: ldstr "UserInfo" 47 IL_0040: ldstr "ContactStr" 48 //因为ContactStr是静态方法所以不需要先加载实例可以直接调用 49 IL_0045: call void ILDeom3.UserInfo::ContactStr(string, 50 string) 51 IL_004a: nop 52 //将位于特定索引处的局部变量的 "地址" 加载到计算堆栈上 (将指向结构的地址压入栈中) 53 IL_004b: ldloca.s V_1 54 IL_004d: ldstr "Color is Yellow" 55 //调用结构中的PrintInfo方法 56 IL_0052: call instance void ILDeom3.PeopleStruct::PrintInfo(string) 57 IL_0057: nop 58 IL_0058: ldstr "Static Class Static Method" 59 IL_005d: call void ILDeom3.StaticUserInfo::PrintName(string) 60 IL_0062: nop 61 IL_0063: call int32 [mscorlib]System.Console::Read() 62 IL_0068: pop 63 IL_0069: ret 64 } // end of method Program::Main
相信有注释,大家应该都是能够看懂的,IL其实并不难,也并不算底层,只是把C#编译成了中间语言,并非机器语言,CPU照样还是读不懂,
三 IL指令详解 (深入了解)
因这次IL指令,有点长,要画图确实有点扛不住,所以只画重要的地方,还望见谅.
另外 跟园子里的 @冰麟轻武 探讨了跟IL相关的三个内存块 Managed Heap ,Evaluation Stack,Call Stack 了解到了很多之前不明白的知识点,
也纠正了自己以前的一些误区,最后一致认可我们自己的讨论结果,讨论结果如下,
1 Managed Heap(托管堆) 程序运行时会动态的在其中开辟空间来存储变量的值,如new class 时,回收由GC 根据 代龄,和可达对象,来回收相应的内存资源。整个程序共用一个ManagedHeap
2 Evaluation Stack(计算栈):每个线程都有一个独立的 评估栈,用于程序相关的运算,
3 Call Stack(调用栈):讨论的重点就在这里,之前认为Call Stack并不是一个栈,而是一个局部变量列表,用于存放方法的参数,可是我一直有疑问就是值类型应该是存在栈中的,如果Call Stack是个栈,那取值时Call Stack并没有按FILO的原则来,那如果 Call Stack不是个栈那值类型的值 是存在哪里的,然后我与@冰麟轻武就这一问题,讨论起来了
先看官方对Call Stack的解释: 这是由.NET CLR在执行时自动管理的存储单元,每个Thread都有自己专门的Call Stack。每呼叫一次method,就会使得Call Stack上多一个Record Frame;方法执行完毕之后,此Record Frame会被丢弃。重点就在红色这一句中的 Record Frame又是个什么东西他里边有什么东西?然后开始各种假设,最终我们认为这一种理论是比较靠谱一点的如下:
Call Stack本身就是一个栈,每调用一个方法时就会在栈顶部加载一个Record Frame,这个Record Frame里包含了方法所需要的参数(Params),返回地址(Return Address)和区域变量(Local Variable),当调用的方法结束时,就自动会把这个Record Frame从栈顶弹出。如此一来,我之前的疑问就可以得到相应的解释了
值类型是存在栈中的,当调用方法里会把方法需要的值重栈中取出,然后在栈中创建一个Record Frame并把赋值给Record Frame中的参数,在这个Record Frame中取数据并不是按FILO原则来的,而可以按索引,也可以按地址 对应IL指令 Ldloc stLoc 等取值与赋值都是针对的Record Frame 。而且我们认为Call Stack是对线程栈的一个统称。
上图
下面图解一下实例化一个类,并调用类中的方法在内存中是如何变化的
.locals init (class ILDeom3.UserInfo V_0,valuetype ILDeom3.PeopleStruct V_1,class ILDeom3.MyDele V_2)
IL_0001: newobj instance void ILDeom3.UserInfo::.ctor()
IL_0006: stloc.0
IL_0028: ldloc.0
IL_0029: ldstr "PrintName"
IL_002e: callvirt instance void ILDeom3.UserInfo::PrintName(string)
四 总结
IL系列终于写完了,也算给自己一个交代了,写文章真的很花时间,就以我这三篇为例,光只是写和画图都有花十几个小时,而且如果是晚上写一般都会超过12点才能完成,更不用说前期的自己学习所用的时间,
但是我觉得真的很值得,充分的把自己的业余时间利用起来了,对于IL也有了一个相对深入的了解,
在此要感谢 园子里朋友的支持,也感谢 @冰麟轻武对我的指点,更要感谢dudu能建立博客园这么好的一个环境。
内存池的原理及实现
在软件开发中,有些对象使用非常频繁,那么我们可以预先在堆中实例化一些对象,我们把维护这些对象的结构叫“内存池”。在需要用的时候,直接从内存池中拿,而不用从新实例化,在要销毁的时候,不是直接free/delete,而是返还给内存池。
把那些常用的对象存在内存池中,就不用频繁的分配/回收内存,可以相对减少内存碎片,更重要的是实例化这样的对象更快,回收也更快。当内存池中的对象不够用的时候就扩容。
我的内存池实现如下:
#pragma once #include <assert.h> template<typename T> struct ProxyT { ProxyT():next(NULL){} T data; ProxyT* next; }; template<typename T> class MemoryPool { public: static void* New() { if(next==NULL) { Alloc(); } assert(next!=NULL); ProxyT<T>* cur=next; next=next->next; return cur; } static void Delete(void* ptr) { ProxyT<T>* cur=static_cast<ProxyT<T>*>(ptr); cur->next=next; next=cur; } #ifdef CanFree static void Clear() { ProxyT<T>* proxy=NULL; while(next!=NULL) { proxy=next->next; delete next; next=proxy->next; } next=NULL; } #endif private: static void Alloc(size_t size=16) { if(next==NULL) { #ifdef CanFree ProxyT<T>* tmpProxy=new ProxyT<T>(); next=tmpProxy; for(int i=1;i<size;i++) { tmpProxy->next=new ProxyT<T>(); tmpProxy=tmpProxy->next; } #else ProxyT<T>* memory=(ProxyT<T>*)malloc(size*sizeof(ProxyT<T>)); ProxyT<T>* tmpProxy=new (memory) ProxyT<T>(); next=tmpProxy; for (size_t i=1;i<size;i++) { tmpProxy->next=new (memory+i) ProxyT<T>(); tmpProxy=tmpProxy->next; } #endif } } static ProxyT<T>* next; MemoryPool<T>(); MemoryPool<T>(const MemoryPool<T>&); }; template<typename T> ProxyT<T>* MemoryPool<T>::next=NULL; #define NewAndDelete(className) \ static void* operator new(size_t size) \ { \ return MemoryPool<className>::New(); \ } \ static void operator delete(void* ptr) \ { \ MemoryPool<className>::Delete(ptr); \ }
测试代码如下:
#include "stdafx.h" #define CanFree #include "MemoryPool.h" struct A { int i; NewAndDelete(A) }; int _tmain(int argc, _TCHAR* argv[]) { { vector<A*> vect; for(int i=0;i<16;i++) { A* a=new A(); a->i=i; vect.push_back(a); } for(int i=0;i<vect.size();i++) { cout<<vect[i]->i<<endl; } for(int i=vect.size()-1;i>=0;i--) { delete vect[i]; } vect.clear(); MemoryPool<A>::Clear(); } system("pause"); return 0; }
运行结果如下图:
不到100行代码,有两个public方法New和Delete;还有一个Clear方法,这个方法的存在取决于是否定义了宏CanFree,如果定义了这个宏,那么对象是一个个的实例化,在调用Clear的时候可以一个个的回收,如果没有定义,那么是一次分配一块较大的内存,然后在这块内存上实例化多个对象,但没有实现回收这块内存的方法,如果要回收这样的大块内存块,就必须将这些内存块的首地址存起来,我这里没有存起来,而且还要标记对象是否使用,那么Proxy<T>还要加一个字段表示是否使用,在回收的时候还要判断所有对象是否没有使用,只有都没使用才能回收,妹的,为了回收弄得这么麻烦,话说你为什么要回收内存池呢,于是就没有实现回收的方法。整个内存池其实就是一个单链表,表头指向第一个没有使用节点,我们可以把这个单链表想象成一段链条,调用方法New就是从链条的一端(单链表表头)取走一节点,调用方法Delete就是在链条的一端(单链表表头)前面插入一个节点,新插入的节点就是链表的表头,这样New和Delete的时间复杂度都是O(1),那叫一个快。
所有要使用内存池的对象,只需要在这个对象中引入宏NewAndDelete,这个宏其实就是重写对象的new和delete方法,让对象的创建和回收都通过内存池来实现,所有用内存池实现的对象使用起来和别的对象基本上是一样,唯一的一个问题就是内存池对象对象不是线程安全的,在多线程编程中,创建一个对象时必须枷锁。如果在New和Delete的实现中都加个锁,我又觉得他太影响性能,毕竟很多时候是不需要枷锁,有些对象可能有不用于多线程,对于这个问题,求高手指点!