对象模型 -- (转)

2023-10-20 18:45:16

面向对象的纯粹性

在很久很久以前，C++还被称为面向对象语言（现在一般称为多范式通用语言），人们就对C++的面向对象的纯粹性提出了质疑，主要有以下几点：

并非所有的对象都是对象（很拗口？），比如指针本身不是对象，函数不是对象，基本数据类型不是对象。
C++对于面向对象中“消息传递”的设计采用的是方法调用的形式，这种方式不能完整的表达“消息传递”的语义。

对于第一点，我们最直观的感受就是，我们无法写如下的代码：

1
    
int a = 10;

2
    string b = a.toString();

我们能做的只是：

1
    
int a = 10;

2
    
char buffer[MAX_STRING];

3
    itoa(a, buffer, MAX_STRING];

4
    string b(buffer);

所以这里a是一个值，而非一个对象，它只是数据，而没有与之相关的操作。
我们看看Lua和Python的设计，就可以更加明了的理解值类型的设计的差异个中差异。

Lua和Python的差异

在Python中，所有的对象都继承自PyObject类（Python本身是使用C语言编写的，Python在C语言中模拟了一套类似C++的OO机制，支持继承、多态等面向对象特性），在所有需要操作变量的地方，都统一使用PyObject*来访问，例如，在函数调用时，为函数分配堆栈空间的时候，代码就类似这个样子：

1
    
PyObject** stack = (PyObject**)malloc(sizeof(PyObject*)*maxStack);

所以，本质上来说，所有的对象都是在堆上分配的，我们访问的都是对象的指针。
再来看看Lua的设计，在Lua中，使用一个结构体来保存对象：

01
    
typedef struct {

02
    
  int t;

03
    
  Value v;

04
    } TObject;

05
    
typedef union {

06
    
  GCObject* gc;

07
    
  void* p;

08
    
  lua_Number n;

09
    
  int b;

10
    } Value;

所以，保存一个变量，在32bit的机器上，Lua使用12个字节。对于值类型（lua_Number）之类的变量，并不会从堆中分配，而是直接在栈上分配（事实上也是从堆上分配，但是是一次性分配的），例如在函数调用的时候，要分配寄存器的空间的时候，相当于这样的代码：

1
    
TObject* locals = (TObject*)malloc(sizeof(TObject)*localCount);

这样看起来似乎都是一条malloc调用，那么性能差异在哪里呢？

分配空间时的性能差异

假设我们在两个虚拟机里面都需要分配一个4个数值类型的栈上变量或者寄存器的空间，那么在Python中，等效代码是：

1
    
PyObject** stack = (PyObject**)malloc(sizeof(PyObject*)*4);

2
    
for (int i = 0; i < 4; i++)

3
    
  stack[i] = (PyObject*)malloc(sizeof(PyIntObject));

这里的代码只包含分配空间，不包括初始化变量的部分。对应在lua虚拟机中的相对代码就是：

1
    
TObject* locals = (TObject*)malloc(sizeof(TObject)*4);

可以看到，Lua的模式在处理数值变量的时候，将会少4次内存分配操作，这对于每秒执行数以万级的函数调用的时候，对性能的影响非常明显。

执行运算时的性能差异

现在我们再看看执行数值运算的时候性能会有怎样的差异，我们还是以上一篇文章中说到的，1+2的数学运算为例，将相应的bytecode翻译成实际执行的C代码来做：
Python ByteCode

1
    push 1

2
    push 2

3
    add

对应的C代码

01
    // 为堆栈分配内存

02
    
PyObject** stack = (PyObject**)malloc(sizeof(PyObject*)*2); // 一次内存分配

03
     
04
    // push 1

05
    STACK_ADJ(1);

06
    
STACK_TOP = PyInt_FromLong(1);  // 一次内存分配

07
     
08
    // push 2

09
    STACK_ADJ(1);

10
    
STACK_TOP = PyInt_FromLong(2);  // 一次内存分配

11
     
12
    // add

13
    
PyObject* result = PyNumber_Add(STACK_SECOND, STACK_TOP); // 一次内存分类

14
    STACK_ADJ(-1);

15
    STACK_TOP = result;

我们可以看到，这样一次简单的计算，进行了4次内存分配操作（其实还有2次内存释放操作）。
我们再来看看Lua的ByteCode:

1
    loadk 0 1

2
    loadk 1 2

3
    add 2 0 1

对应的C代码是：

01
    
TObject* locals = (TObject*)malloc(sizeof(TObject)*3); // 一次内存分配

02
     
03
    // loadk 0 1

04
    
locals[0] = lua_Number(1); // 没有内存分配

05
     
06
    // loadk 1 2

07
    locals[1] = lua_Number(2);

08
     
09
    // add 2 0 1

10
    locals[2] = lua_Number(locals[0].v.n + locals[1].v.n);

只有1次内存分配操作，没有内存释放操作，这样，速度的差异就非常明显了。

文章来源：http://zoomq.qiniudn.com/ZQScrapBook/ZqFLOSS/data/20111002195204/

对象模型 -- (转)

码农公寓

面向对象的纯粹性

Lua和Python的差异

分配空间时的性能差异

执行运算时的性能差异

相关文章