首页 > 代码库 > 《python源码剖析》笔记 Python虚拟机框架

《python源码剖析》笔记 Python虚拟机框架

本文为senlie原创,转载请保留此地址:http://blog.csdn.net/zhengsenlie


1.
Python虚拟机会从编译得到的PyCodeObject对象中依次读入每一条字节码指令,
并在当前的上下文环境中执行这条字节码指令。
Python虚拟机实际上是在模拟操作中执行文件的过程
PyCodeObject对象中包含了字节码指令以及程序的所有静态信息,但没有包含
程序运行时的动态信息——执行环境(PyFrameObject)


2.Python源码中的PyFrameObject

typedef struct _frame{
	PyObject_VAR_HEAD //"运行时栈"的大小是不确定的
	struct _frame *f_back; //执行环境链上的前一个frame,很多个PyFrameObject连接起来形成执行环境链表
	PyCodeObject *f_code; //PyCodeObject 对象,这个frame就是这个PyCodeObject对象的上下文环境
	PyObject *f_builtins; //builtin名字空间
	PyObject *f_globals;  //global名字空间
	PyObject *f_locals;   //local名字空间
	PyObject **f_valuestack; //"运行时栈"的栈底位置
	PyObject **f_stacktop;   //"运行时栈"的栈顶位置
	//...
	int f_lasti;  //上一条字节码指令在f_code中的偏移位置
	int f_lineno; //当前字节码对应的源代码行
	//...
	
	//动态内存,维护(局部变量+cell对象集合+free对象集合+运行时栈)所需要的空间
	PyObject *f_localsplus[1];	
} PyFrameObject;


名字空间实际上是维护着变量名和变量值之间关系的PyDictObject对象。
f_builtins, f_globals, f_locals名字空间分别维护了builtin, global, local的name与对应值
之间的映射关系。

每一个 PyFrameObject对象都维护了一个 PyCodeObject对象,这表明每一个 PyFrameObject中的动态内存空间
对象都和源代码中的一段Code相对应。

Code Block,PyFrameObject,作用域,名字空间好像都与一段代码段一一对应?



PyFrameObject中的动态内存空间
PyFrameObject *PyFrame_New(PyThreadState *tstate, PyCodeObject *code, PyObject *globals, PyCodeObject *locals)
{
	PyFrameObject *f;
	Py_ssize_t extras, ncells, nfrees, i;
	ncells = PyTuple_GET_SIZE(code->co_cellvars);
	nfrees = PyTuple_GET_SIZE(code->co_freevars);
	//这四部分构成了 PyFrameObject维护的动态内存区,其大小由extras确定
	extras = code->co_stacksize + code->co_nlocals + ncells + nfrees;
	f = PyObject_GC_NewVar(PyFrameObject, &PyFrame_Type, extras);
	//计算初始化时运行时栈的栈顶
	extras = code->co_nlocals + ncells + nfrees;
	//f_valuestack维护运行时栈的栈底,f_stacktop维护运行时栈的栈顶
	f->f_valuestack = f->f_localsplus + extras;
	f->f_stacktop = f->f_valuestack;
	return f;
}
在创建 PyFrameObject对象时,额外申请的内存有一部分是给 PyCodeObject对象用的,
另一部分才是给运行时栈用的。


在Python中访问 PyFrameObject对象
8.1.3的caller.py我运行失败了,在f_globals.keys()处出错
看不懂frame_getter.py

3.名字、作用域和名字空间
对于python这类动态语言来说,名字的意义远比C这类的静态语言大,因为名字是python
在运行时能够找到其所对应的东西的唯一途径。

名字: 一个标识符就是一个名字,比如变量名、函数名、类名等
作用域:作用域是指约束起作用的程序正文区域。Python是具有静态作用域(词法作用域)的。
在Python中,一个约束在程序正文的某个位置是否起作用,是由该约束在文本中的位置唯一决定的,
而不是运行时动态决定的。
名字空间:由一个 PyDictObject对象实现,每一个名字空间都与一个作用域对应

module
1.将逻辑相关的代码放在一起,实现代码复用
2.为系统划分名字空间(一个module定义了一个独立的名字空间)

赋值语句会影响名字空间(“拥有赋值行为、拥有设置对象属性的行为”)
1.创建一个对象obj
2.将obj"赋给"一个名字name

a = 1
def f()
class A(object)
import abc

嵌套作用域最内嵌套作用域规则:1.闭包实现  2.编译器实现LEGB规则:名字引用动作沿着local作用域、嵌套作用域、global作用域、builtin作用域的顺序查找函数对应local作用域,module源文件对应global作用域,Python自身定义了最顶层的作用域——builtin作用域几个有助理解LEGB规则的代码段
<span style="font-family: Arial, Helvetica, sans-serif; font-size: 12px;"></span><pre name="code" class="cpp">#----------------------
a = 1 #[1]
def f():
	a = 2 #[2]
	print a #[3] 輸出2
print a #[4] 輸出1
#----------------------
#闭包。在执行func = f()的时候,会执行函数f中的def g():语句,这时Python会将约束a = 2与函数g对应的函数对象捆绑在一起
#将捆绑后的结果返回
a = 1
def f():
	a = 2
	def g():
		print a #[1]:输出结果为2
	return g
func = f()
func() #[2]
#----------------------
<pre name="code" class="cpp">#由一个赋值语句引进的名字在这个赋值语句所在的作用域是可见的。在 第9章 Python虚拟机中的一般表达式 这章有说明实现原理
#[1]pint a语句处,a已经存在了这个Code Block对应的PyFrameObject对应的co_names符号表里了,但由于还没执行[2]的赋值语句,
#在PyFrameObject的f_locals里并没有这个键值对,所以在[1]处会出现“local variable 'a' referenced before assignment”的错误
a = 1def g():print adef f():print a #[1] error: local variable ‘a‘ referenced before assignment a = 2 #[2]print ag()f()#----------------------a = 1def f():global aprint a #输出结果:1a = 2f()print a #输出结果:2#----------------------a = 1def f():a = 2def g():global aprint a #输出结果:1a += 1return gg = f()g()print a #输出结果:2


4.Python虚拟机的运行框架——字节码执行引擎
PyEval_EvalFrameEx 
虚拟机的具体实现-->switch/case结构
Python虚拟机执行字节码指令序列的过程就是从头到尾遍历整个co_code、依次执行字节码指令(字符数组)的过程。


/* Interpreter main loop */ 
PyObject* PyEval_EvalFrame(PyFrameObject *f) 
{
	//…… 
	why = WHY_NOT;//指示了在退出for循环时Python执行引擎的状态
	for (;;) {
	//…… 
	fast_next_opcode: 
		f->f_lasti = INSTR_OFFSET();
		/* 获得字节码指令和参数*/
		opcode = NEXTOP();
		oparg = 0;  
		/* 如果指令需要参数,获得指令参数*/
		if (HAS_ARG(opcode))
			oparg = NEXTARG();
	dispatch_opcode: 
		switch (opcode) {
		case NOP:
		goto fast_next_opcode;
		case LOAD_FAST:
		//…… 
		} 
}

5.Python运行时环境初探
PyInterpreterState --> 进程的抽象
PyThreadState --> 线程状态信息的抽象
在Win32下,线程是还能独立存活的,它需要存活在进程的环境中,多个线程可以共享进程的一些资源
进程中会有线程集合,线程中会有函数调用堆栈。
当Python虚拟机开始执行时,会将当前线程状态对象中的frame设置为当前的执行环境(frame),而
在建立新的PyFrameObject对象时,则从当前线程的状态对象中取出旧的frame,建立PyFrameObject链表
线程之间的同步靠的是全局解释锁(GIL)
//进程
typedef struct _is{
	struct _is *next;
	struct _ts *tstate_head; //模拟进程环境中的线程集合
	
	PyObject *modules;
	PyObject *sysdict;
	PyObject *builtins;
	
	//...
} PyInterpreterState
//线程
typedef struct _ts{
	struct _ts *next
	PyInterpreterState *interp;
	struct _frame *frame; //模拟线程中的函数调用堆栈
	int recursion_depth;
	//...
	PyObject *dict;
	//...
	long thread_id;
} PyThreadState;