Nếu bạn muốn xem mã byte của một số mã [cho dù mã nguồn, đối tượng hàm trực tiếp hoặc đối tượng mã, v.v.], mô -đun
// typedef struct _frame PyFrameObject; in other place
struct _frame {
PyObject_VAR_HEAD
struct _frame *f_back; /* previous frame, or NULL */
PyCodeObject *f_code; /* code segment */
PyObject *f_builtins; /* builtin symbol table [PyDictObject] */
PyObject *f_globals; /* global symbol table [PyDictObject] */
PyObject *f_locals; /* local symbol table [any mapping] */
PyObject **f_valuestack; /* points after the last local */
/* Next free slot in f_valuestack. Frame creation sets to f_valuestack.
Frame evaluation usually NULLs it, but a frame that yields sets it
to the current stack top. */
PyObject **f_stacktop;
PyObject *f_trace; /* Trace function */
char f_trace_lines; /* Emit per-line trace events? */
char f_trace_opcodes; /* Emit per-opcode trace events? */
/* Borrowed reference to a generator, or NULL */
PyObject *f_gen;
int f_lasti; /* Last instruction if called */
int f_lineno; /* Current line number */
int f_iblock; /* index in f_blockstack */
char f_executing; /* whether the frame is still executing */
PyTryBlock f_blockstack[CO_MAXBLOCKS]; /* for try and loop blocks */
PyObject *f_localsplus[1]; /* locals+stack, dynamically sized */
};
>>> dis.dis['i/3']
1 0 LOAD_NAME 0 [i]
3 LOAD_CONST 0 [3]
6 BINARY_TRUE_DIVIDE
7 RETURN_VALUE
Các tài liệu
// typedef struct _frame PyFrameObject; in other place
struct _frame {
PyObject_VAR_HEAD
struct _frame *f_back; /* previous frame, or NULL */
PyCodeObject *f_code; /* code segment */
PyObject *f_builtins; /* builtin symbol table [PyDictObject] */
PyObject *f_globals; /* global symbol table [PyDictObject] */
PyObject *f_locals; /* local symbol table [any mapping] */
PyObject **f_valuestack; /* points after the last local */
/* Next free slot in f_valuestack. Frame creation sets to f_valuestack.
Frame evaluation usually NULLs it, but a frame that yields sets it
to the current stack top. */
PyObject **f_stacktop;
PyObject *f_trace; /* Trace function */
char f_trace_lines; /* Emit per-line trace events? */
char f_trace_opcodes; /* Emit per-opcode trace events? */
/* Borrowed reference to a generator, or NULL */
PyObject *f_gen;
int f_lasti; /* Last instruction if called */
int f_lineno; /* Current line number */
int f_iblock; /* index in f_blockstack */
char f_executing; /* whether the frame is still executing */
PyTryBlock f_blockstack[CO_MAXBLOCKS]; /* for try and loop blocks */
PyObject *f_localsplus[1]; /* locals+stack, dynamically sized */
};
// typedef struct _frame PyFrameObject; in other place
struct _frame {
PyObject_VAR_HEAD
struct _frame *f_back; /* previous frame, or NULL */
PyCodeObject *f_code; /* code segment */
PyObject *f_builtins; /* builtin symbol table [PyDictObject] */
PyObject *f_globals; /* global symbol table [PyDictObject] */
PyObject *f_locals; /* local symbol table [any mapping] */
PyObject **f_valuestack; /* points after the last local */
/* Next free slot in f_valuestack. Frame creation sets to f_valuestack.
Frame evaluation usually NULLs it, but a frame that yields sets it
to the current stack top. */
PyObject **f_stacktop;
PyObject *f_trace; /* Trace function */
char f_trace_lines; /* Emit per-line trace events? */
char f_trace_opcodes; /* Emit per-opcode trace events? */
/* Borrowed reference to a generator, or NULL */
PyObject *f_gen;
int f_lasti; /* Last instruction if called */
int f_lineno; /* Current line number */
int f_iblock; /* index in f_blockstack */
char f_executing; /* whether the frame is still executing */
PyTryBlock f_blockstack[CO_MAXBLOCKS]; /* for try and loop blocks */
PyObject *f_localsplus[1]; /* locals+stack, dynamically sized */
};
Đẩy giá trị liên quan đến
8 lên ngăn xếp.// typedef struct _frame PyFrameObject; in other place struct _frame { PyObject_VAR_HEAD struct _frame *f_back; /* previous frame, or NULL */ PyCodeObject *f_code; /* code segment */ PyObject *f_builtins; /* builtin symbol table [PyDictObject] */ PyObject *f_globals; /* global symbol table [PyDictObject] */ PyObject *f_locals; /* local symbol table [any mapping] */ PyObject **f_valuestack; /* points after the last local */ /* Next free slot in f_valuestack. Frame creation sets to f_valuestack. Frame evaluation usually NULLs it, but a frame that yields sets it to the current stack top. */ PyObject **f_stacktop; PyObject *f_trace; /* Trace function */ char f_trace_lines; /* Emit per-line trace events? */ char f_trace_opcodes; /* Emit per-opcode trace events? */ /* Borrowed reference to a generator, or NULL */ PyObject *f_gen; int f_lasti; /* Last instruction if called */ int f_lineno; /* Current line number */ int f_iblock; /* index in f_blockstack */ char f_executing; /* whether the frame is still executing */ PyTryBlock f_blockstack[CO_MAXBLOCKS]; /* for try and loop blocks */ PyObject *f_localsplus[1]; /* locals+stack, dynamically sized */ };
Để hiểu điều này, bạn phải biết rằng trình thông dịch bytecode là một máy ngăn xếp ảo và
// typedef struct _frame PyFrameObject; in other place
struct _frame {
PyObject_VAR_HEAD
struct _frame *f_back; /* previous frame, or NULL */
PyCodeObject *f_code; /* code segment */
PyObject *f_builtins; /* builtin symbol table [PyDictObject] */
PyObject *f_globals; /* global symbol table [PyDictObject] */
PyObject *f_locals; /* local symbol table [any mapping] */
PyObject **f_valuestack; /* points after the last local */
/* Next free slot in f_valuestack. Frame creation sets to f_valuestack.
Frame evaluation usually NULLs it, but a frame that yields sets it
to the current stack top. */
PyObject **f_stacktop;
PyObject *f_trace; /* Trace function */
char f_trace_lines; /* Emit per-line trace events? */
char f_trace_opcodes; /* Emit per-opcode trace events? */
/* Borrowed reference to a generator, or NULL */
PyObject *f_gen;
int f_lasti; /* Last instruction if called */
int f_lineno; /* Current line number */
int f_iblock; /* index in f_blockstack */
char f_executing; /* whether the frame is still executing */
PyTryBlock f_blockstack[CO_MAXBLOCKS]; /* for try and loop blocks */
PyObject *f_localsplus[1]; /* locals+stack, dynamically sized */
};
struct PyCodeObject {
PyObject_HEAD
int co_argcount; /* #arguments, except *args */
int co_posonlyargcount; /* #positional only arguments */
int co_kwonlyargcount; /* #keyword only arguments */
int co_nlocals; /* #local variables */
int co_stacksize; /* #entries needed for evaluation stack */
int co_flags; /* CO_..., see below */
int co_firstlineno; /* first source line number */
PyObject *co_code; /* instruction opcodes */
PyObject *co_consts; /* list [constants used] */
PyObject *co_names; /* list of strings [names used] */
PyObject *co_varnames; /* tuple of strings [local variable names] */
PyObject *co_freevars; /* tuple of strings [free variable names] */
PyObject *co_cellvars; /* tuple of strings [cell variable names] */
/* The rest aren't used in either hash or comparisons, except for co_name,
used in both. This is done to preserve the name and line number
for tracebacks and debuggers; otherwise, constant de-duplication
would collapse identical functions/lambdas defined on different lines.
*/
Py_ssize_t *co_cell2arg; /* Maps cell vars which are arguments. */
PyObject *co_filename; /* unicode [where it was loaded from] */
PyObject *co_name; /* unicode [name, for reference] */
PyObject *co_lnotab; /* string [encoding addrlineno mapping] See
Objects/lnotab_notes.txt for details. */
void *co_zombieframe; /* for optimization only [see frameobject.c] */
PyObject *co_weakreflist; /* to support weakrefs to code objects */
/* Scratch space for extra data relating to the code object.
Type is a void* to keep the format private in codeobject.c to force
people to go through the proper APIs. */
void *co_extra;
/* Per opcodes just-in-time cache
*
* To reduce cache size, we use indirect mapping from opcode index to
* cache object:
* cache = co_opcache[co_opcache_map[next_instr - first_instr] - 1]
*/
// co_opcache_map is indexed by [next_instr - first_instr].
// * 0 means there is no cache for this opcode.
// * n > 0 means there is cache in co_opcache[n-1].
unsigned char *co_opcache_map;
_PyOpcache *co_opcache;
int co_opcache_flag; // used to determine when create a cache.
unsigned char co_opcache_size; // length of co_opcache.
};
// typedef struct _frame PyFrameObject; in other place
struct _frame {
PyObject_VAR_HEAD
struct _frame *f_back; /* previous frame, or NULL */
PyCodeObject *f_code; /* code segment */
PyObject *f_builtins; /* builtin symbol table [PyDictObject] */
PyObject *f_globals; /* global symbol table [PyDictObject] */
PyObject *f_locals; /* local symbol table [any mapping] */
PyObject **f_valuestack; /* points after the last local */
/* Next free slot in f_valuestack. Frame creation sets to f_valuestack.
Frame evaluation usually NULLs it, but a frame that yields sets it
to the current stack top. */
PyObject **f_stacktop;
PyObject *f_trace; /* Trace function */
char f_trace_lines; /* Emit per-line trace events? */
char f_trace_opcodes; /* Emit per-opcode trace events? */
/* Borrowed reference to a generator, or NULL */
PyObject *f_gen;
int f_lasti; /* Last instruction if called */
int f_lineno; /* Current line number */
int f_iblock; /* index in f_blockstack */
char f_executing; /* whether the frame is still executing */
PyTryBlock f_blockstack[CO_MAXBLOCKS]; /* for try and loop blocks */
PyObject *f_localsplus[1]; /* locals+stack, dynamically sized */
};
struct PyCodeObject {
PyObject_HEAD
int co_argcount; /* #arguments, except *args */
int co_posonlyargcount; /* #positional only arguments */
int co_kwonlyargcount; /* #keyword only arguments */
int co_nlocals; /* #local variables */
int co_stacksize; /* #entries needed for evaluation stack */
int co_flags; /* CO_..., see below */
int co_firstlineno; /* first source line number */
PyObject *co_code; /* instruction opcodes */
PyObject *co_consts; /* list [constants used] */
PyObject *co_names; /* list of strings [names used] */
PyObject *co_varnames; /* tuple of strings [local variable names] */
PyObject *co_freevars; /* tuple of strings [free variable names] */
PyObject *co_cellvars; /* tuple of strings [cell variable names] */
/* The rest aren't used in either hash or comparisons, except for co_name,
used in both. This is done to preserve the name and line number
for tracebacks and debuggers; otherwise, constant de-duplication
would collapse identical functions/lambdas defined on different lines.
*/
Py_ssize_t *co_cell2arg; /* Maps cell vars which are arguments. */
PyObject *co_filename; /* unicode [where it was loaded from] */
PyObject *co_name; /* unicode [name, for reference] */
PyObject *co_lnotab; /* string [encoding addrlineno mapping] See
Objects/lnotab_notes.txt for details. */
void *co_zombieframe; /* for optimization only [see frameobject.c] */
PyObject *co_weakreflist; /* to support weakrefs to code objects */
/* Scratch space for extra data relating to the code object.
Type is a void* to keep the format private in codeobject.c to force
people to go through the proper APIs. */
void *co_extra;
/* Per opcodes just-in-time cache
*
* To reduce cache size, we use indirect mapping from opcode index to
* cache object:
* cache = co_opcache[co_opcache_map[next_instr - first_instr] - 1]
*/
// co_opcache_map is indexed by [next_instr - first_instr].
// * 0 means there is no cache for this opcode.
// * n > 0 means there is cache in co_opcache[n-1].
unsigned char *co_opcache_map;
_PyOpcache *co_opcache;
int co_opcache_flag; // used to determine when create a cache.
unsigned char co_opcache_size; // length of co_opcache.
};
// typedef struct _frame PyFrameObject; in other place
struct _frame {
PyObject_VAR_HEAD
struct _frame *f_back; /* previous frame, or NULL */
PyCodeObject *f_code; /* code segment */
PyObject *f_builtins; /* builtin symbol table [PyDictObject] */
PyObject *f_globals; /* global symbol table [PyDictObject] */
PyObject *f_locals; /* local symbol table [any mapping] */
PyObject **f_valuestack; /* points after the last local */
/* Next free slot in f_valuestack. Frame creation sets to f_valuestack.
Frame evaluation usually NULLs it, but a frame that yields sets it
to the current stack top. */
PyObject **f_stacktop;
PyObject *f_trace; /* Trace function */
char f_trace_lines; /* Emit per-line trace events? */
char f_trace_opcodes; /* Emit per-opcode trace events? */
/* Borrowed reference to a generator, or NULL */
PyObject *f_gen;
int f_lasti; /* Last instruction if called */
int f_lineno; /* Current line number */
int f_iblock; /* index in f_blockstack */
char f_executing; /* whether the frame is still executing */
PyTryBlock f_blockstack[CO_MAXBLOCKS]; /* for try and loop blocks */
PyObject *f_localsplus[1]; /* locals+stack, dynamically sized */
};
struct PyCodeObject {
PyObject_HEAD
int co_argcount; /* #arguments, except *args */
int co_posonlyargcount; /* #positional only arguments */
int co_kwonlyargcount; /* #keyword only arguments */
int co_nlocals; /* #local variables */
int co_stacksize; /* #entries needed for evaluation stack */
int co_flags; /* CO_..., see below */
int co_firstlineno; /* first source line number */
PyObject *co_code; /* instruction opcodes */
PyObject *co_consts; /* list [constants used] */
PyObject *co_names; /* list of strings [names used] */
PyObject *co_varnames; /* tuple of strings [local variable names] */
PyObject *co_freevars; /* tuple of strings [free variable names] */
PyObject *co_cellvars; /* tuple of strings [cell variable names] */
/* The rest aren't used in either hash or comparisons, except for co_name,
used in both. This is done to preserve the name and line number
for tracebacks and debuggers; otherwise, constant de-duplication
would collapse identical functions/lambdas defined on different lines.
*/
Py_ssize_t *co_cell2arg; /* Maps cell vars which are arguments. */
PyObject *co_filename; /* unicode [where it was loaded from] */
PyObject *co_name; /* unicode [name, for reference] */
PyObject *co_lnotab; /* string [encoding addrlineno mapping] See
Objects/lnotab_notes.txt for details. */
void *co_zombieframe; /* for optimization only [see frameobject.c] */
PyObject *co_weakreflist; /* to support weakrefs to code objects */
/* Scratch space for extra data relating to the code object.
Type is a void* to keep the format private in codeobject.c to force
people to go through the proper APIs. */
void *co_extra;
/* Per opcodes just-in-time cache
*
* To reduce cache size, we use indirect mapping from opcode index to
* cache object:
* cache = co_opcache[co_opcache_map[next_instr - first_instr] - 1]
*/
// co_opcache_map is indexed by [next_instr - first_instr].
// * 0 means there is no cache for this opcode.
// * n > 0 means there is cache in co_opcache[n-1].
unsigned char *co_opcache_map;
_PyOpcache *co_opcache;
int co_opcache_flag; // used to determine when create a cache.
unsigned char co_opcache_size; // length of co_opcache.
};
Và điều đó là đủ để thấy rằng một chuỗi các byte không đủ; Trình thông dịch cũng cần các thuộc tính khác của đối tượng mã và trong một số trường hợp, các thuộc tính của đối tượng hàm [cũng là nơi môi trường địa phương và toàn cầu đến từ].
Mô -đun
struct PyCodeObject {
PyObject_HEAD
int co_argcount; /* #arguments, except *args */
int co_posonlyargcount; /* #positional only arguments */
int co_kwonlyargcount; /* #keyword only arguments */
int co_nlocals; /* #local variables */
int co_stacksize; /* #entries needed for evaluation stack */
int co_flags; /* CO_..., see below */
int co_firstlineno; /* first source line number */
PyObject *co_code; /* instruction opcodes */
PyObject *co_consts; /* list [constants used] */
PyObject *co_names; /* list of strings [names used] */
PyObject *co_varnames; /* tuple of strings [local variable names] */
PyObject *co_freevars; /* tuple of strings [free variable names] */
PyObject *co_cellvars; /* tuple of strings [cell variable names] */
/* The rest aren't used in either hash or comparisons, except for co_name,
used in both. This is done to preserve the name and line number
for tracebacks and debuggers; otherwise, constant de-duplication
would collapse identical functions/lambdas defined on different lines.
*/
Py_ssize_t *co_cell2arg; /* Maps cell vars which are arguments. */
PyObject *co_filename; /* unicode [where it was loaded from] */
PyObject *co_name; /* unicode [name, for reference] */
PyObject *co_lnotab; /* string [encoding addrlineno mapping] See
Objects/lnotab_notes.txt for details. */
void *co_zombieframe; /* for optimization only [see frameobject.c] */
PyObject *co_weakreflist; /* to support weakrefs to code objects */
/* Scratch space for extra data relating to the code object.
Type is a void* to keep the format private in codeobject.c to force
people to go through the proper APIs. */
void *co_extra;
/* Per opcodes just-in-time cache
*
* To reduce cache size, we use indirect mapping from opcode index to
* cache object:
* cache = co_opcache[co_opcache_map[next_instr - first_instr] - 1]
*/
// co_opcache_map is indexed by [next_instr - first_instr].
// * 0 means there is no cache for this opcode.
// * n > 0 means there is cache in co_opcache[n-1].
unsigned char *co_opcache_map;
_PyOpcache *co_opcache;
int co_opcache_flag; // used to determine when create a cache.
unsigned char co_opcache_size; // length of co_opcache.
};
Điều này là đủ để tìm ra rất nhiều thứ thú vị. Ví dụ: bạn có thể biết rằng Python tìm ra tại thời điểm biên dịch cho dù một biến trong một hàm là cục bộ, đóng hoặc toàn cầu, dựa trên việc bạn có gán cho nó ở bất cứ đâu trong cơ thể chức năng [và trên bất kỳ câu lệnh
struct PyCodeObject {
PyObject_HEAD
int co_argcount; /* #arguments, except *args */
int co_posonlyargcount; /* #positional only arguments */
int co_kwonlyargcount; /* #keyword only arguments */
int co_nlocals; /* #local variables */
int co_stacksize; /* #entries needed for evaluation stack */
int co_flags; /* CO_..., see below */
int co_firstlineno; /* first source line number */
PyObject *co_code; /* instruction opcodes */
PyObject *co_consts; /* list [constants used] */
PyObject *co_names; /* list of strings [names used] */
PyObject *co_varnames; /* tuple of strings [local variable names] */
PyObject *co_freevars; /* tuple of strings [free variable names] */
PyObject *co_cellvars; /* tuple of strings [cell variable names] */
/* The rest aren't used in either hash or comparisons, except for co_name,
used in both. This is done to preserve the name and line number
for tracebacks and debuggers; otherwise, constant de-duplication
would collapse identical functions/lambdas defined on different lines.
*/
Py_ssize_t *co_cell2arg; /* Maps cell vars which are arguments. */
PyObject *co_filename; /* unicode [where it was loaded from] */
PyObject *co_name; /* unicode [name, for reference] */
PyObject *co_lnotab; /* string [encoding addrlineno mapping] See
Objects/lnotab_notes.txt for details. */
void *co_zombieframe; /* for optimization only [see frameobject.c] */
PyObject *co_weakreflist; /* to support weakrefs to code objects */
/* Scratch space for extra data relating to the code object.
Type is a void* to keep the format private in codeobject.c to force
people to go through the proper APIs. */
void *co_extra;
/* Per opcodes just-in-time cache
*
* To reduce cache size, we use indirect mapping from opcode index to
* cache object:
* cache = co_opcache[co_opcache_map[next_instr - first_instr] - 1]
*/
// co_opcache_map is indexed by [next_instr - first_instr].
// * 0 means there is no cache for this opcode.
// * n > 0 means there is cache in co_opcache[n-1].
unsigned char *co_opcache_map;
_PyOpcache *co_opcache;
int co_opcache_flag; // used to determine when create a cache.
unsigned char co_opcache_size; // length of co_opcache.
};
struct PyCodeObject {
PyObject_HEAD
int co_argcount; /* #arguments, except *args */
int co_posonlyargcount; /* #positional only arguments */
int co_kwonlyargcount; /* #keyword only arguments */
int co_nlocals; /* #local variables */
int co_stacksize; /* #entries needed for evaluation stack */
int co_flags; /* CO_..., see below */
int co_firstlineno; /* first source line number */
PyObject *co_code; /* instruction opcodes */
PyObject *co_consts; /* list [constants used] */
PyObject *co_names; /* list of strings [names used] */
PyObject *co_varnames; /* tuple of strings [local variable names] */
PyObject *co_freevars; /* tuple of strings [free variable names] */
PyObject *co_cellvars; /* tuple of strings [cell variable names] */
/* The rest aren't used in either hash or comparisons, except for co_name,
used in both. This is done to preserve the name and line number
for tracebacks and debuggers; otherwise, constant de-duplication
would collapse identical functions/lambdas defined on different lines.
*/
Py_ssize_t *co_cell2arg; /* Maps cell vars which are arguments. */
PyObject *co_filename; /* unicode [where it was loaded from] */
PyObject *co_name; /* unicode [name, for reference] */
PyObject *co_lnotab; /* string [encoding addrlineno mapping] See
Objects/lnotab_notes.txt for details. */
void *co_zombieframe; /* for optimization only [see frameobject.c] */
PyObject *co_weakreflist; /* to support weakrefs to code objects */
/* Scratch space for extra data relating to the code object.
Type is a void* to keep the format private in codeobject.c to force
people to go through the proper APIs. */
void *co_extra;
/* Per opcodes just-in-time cache
*
* To reduce cache size, we use indirect mapping from opcode index to
* cache object:
* cache = co_opcache[co_opcache_map[next_instr - first_instr] - 1]
*/
// co_opcache_map is indexed by [next_instr - first_instr].
// * 0 means there is no cache for this opcode.
// * n > 0 means there is cache in co_opcache[n-1].
unsigned char *co_opcache_map;
_PyOpcache *co_opcache;
int co_opcache_flag; // used to determine when create a cache.
unsigned char co_opcache_size; // length of co_opcache.
};
.
Để hiểu cách giải thích mã byte và cách thức hoạt động của máy Stack [trong CPython], bạn cần xem mã nguồn
struct PyCodeObject {
PyObject_HEAD
int co_argcount; /* #arguments, except *args */
int co_posonlyargcount; /* #positional only arguments */
int co_kwonlyargcount; /* #keyword only arguments */
int co_nlocals; /* #local variables */
int co_stacksize; /* #entries needed for evaluation stack */
int co_flags; /* CO_..., see below */
int co_firstlineno; /* first source line number */
PyObject *co_code; /* instruction opcodes */
PyObject *co_consts; /* list [constants used] */
PyObject *co_names; /* list of strings [names used] */
PyObject *co_varnames; /* tuple of strings [local variable names] */
PyObject *co_freevars; /* tuple of strings [free variable names] */
PyObject *co_cellvars; /* tuple of strings [cell variable names] */
/* The rest aren't used in either hash or comparisons, except for co_name,
used in both. This is done to preserve the name and line number
for tracebacks and debuggers; otherwise, constant de-duplication
would collapse identical functions/lambdas defined on different lines.
*/
Py_ssize_t *co_cell2arg; /* Maps cell vars which are arguments. */
PyObject *co_filename; /* unicode [where it was loaded from] */
PyObject *co_name; /* unicode [name, for reference] */
PyObject *co_lnotab; /* string [encoding addrlineno mapping] See
Objects/lnotab_notes.txt for details. */
void *co_zombieframe; /* for optimization only [see frameobject.c] */
PyObject *co_weakreflist; /* to support weakrefs to code objects */
/* Scratch space for extra data relating to the code object.
Type is a void* to keep the format private in codeobject.c to force
people to go through the proper APIs. */
void *co_extra;
/* Per opcodes just-in-time cache
*
* To reduce cache size, we use indirect mapping from opcode index to
* cache object:
* cache = co_opcache[co_opcache_map[next_instr - first_instr] - 1]
*/
// co_opcache_map is indexed by [next_instr - first_instr].
// * 0 means there is no cache for this opcode.
// * n > 0 means there is cache in co_opcache[n-1].
unsigned char *co_opcache_map;
_PyOpcache *co_opcache;
int co_opcache_flag; // used to determine when create a cache.
unsigned char co_opcache_size; // length of co_opcache.
};
Hiểu cách các tệp
PyObject*
_PyEval_EvalFrameDefault[PyThreadState *tstate, PyFrameObject *f, int throwflag]
{
// ... declarations and initialization of local variables
// ... macros definitions
// ... call depth handling
// ... code for tracing and profiling
for [;;] {
// ... check if the bytecode execution must be suspended,
// e.g. other thread requested the GIL
// NEXTOPARG[] macro
_Py_CODEUNIT word = *next_instr; // _Py_CODEUNIT is a typedef for uint16_t
opcode = _Py_OPCODE[word];
oparg = _Py_OPARG[word];
next_instr++;
switch [opcode] {
case TARGET[NOP] {
FAST_DISPATCH[]; // more on this later
}
case TARGET[LOAD_FAST] {
// ... code for loading local variable
}
// ... 117 more cases for every possible opcode
}
// ... error handling
}
// ... termination
}
Để hiểu làm thế nào nguồn được biên dịch cho mã byte, đó là phần thú vị.
Thiết kế trình biên dịch của Cpython giải thích cách mọi thứ hoạt động. [Một số phần khác của hướng dẫn nhà phát triển Python cũng hữu ích.]
Đối với những thứ ban đầu, việc nói và phân tích cú pháp, bạn chỉ có thể sử dụng mô -đun
PyObject*
_PyEval_EvalFrameDefault[PyThreadState *tstate, PyFrameObject *f, int throwflag]
{
// ... declarations and initialization of local variables
// ... macros definitions
// ... call depth handling
// ... code for tracing and profiling
for [;;] {
// ... check if the bytecode execution must be suspended,
// e.g. other thread requested the GIL
// NEXTOPARG[] macro
_Py_CODEUNIT word = *next_instr; // _Py_CODEUNIT is a typedef for uint16_t
opcode = _Py_OPCODE[word];
oparg = _Py_OPARG[word];
next_instr++;
switch [opcode] {
case TARGET[NOP] {
FAST_DISPATCH[]; // more on this later
}
case TARGET[LOAD_FAST] {
// ... code for loading local variable
}
// ... 117 more cases for every possible opcode
}
// ... error handling
}
// ... termination
}
PyObject*
_PyEval_EvalFrameDefault[PyThreadState *tstate, PyFrameObject *f, int throwflag]
{
// ... declarations and initialization of local variables
// ... macros definitions
// ... call depth handling
// ... code for tracing and profiling
for [;;] {
// ... check if the bytecode execution must be suspended,
// e.g. other thread requested the GIL
// NEXTOPARG[] macro
_Py_CODEUNIT word = *next_instr; // _Py_CODEUNIT is a typedef for uint16_t
opcode = _Py_OPCODE[word];
oparg = _Py_OPARG[word];
next_instr++;
switch [opcode] {
case TARGET[NOP] {
FAST_DISPATCH[]; // more on this later
}
case TARGET[LOAD_FAST] {
// ... code for loading local variable
}
// ... 117 more cases for every possible opcode
}
// ... error handling
}
// ... termination
}
Các macro có thể hơi khó khăn để làm việc, nhưng một khi bạn nắm bắt được ý tưởng về cách trình biên dịch sử dụng một ngăn xếp để hạ xuống các khối, và cách nó sử dụng các
PyObject*
_PyEval_EvalFrameDefault[PyThreadState *tstate, PyFrameObject *f, int throwflag]
{
// ... declarations and initialization of local variables
// ... macros definitions
// ... call depth handling
// ... code for tracing and profiling
for [;;] {
// ... check if the bytecode execution must be suspended,
// e.g. other thread requested the GIL
// NEXTOPARG[] macro
_Py_CODEUNIT word = *next_instr; // _Py_CODEUNIT is a typedef for uint16_t
opcode = _Py_OPCODE[word];
oparg = _Py_OPARG[word];
next_instr++;
switch [opcode] {
case TARGET[NOP] {
FAST_DISPATCH[]; // more on this later
}
case TARGET[LOAD_FAST] {
// ... code for loading local variable
}
// ... 117 more cases for every possible opcode
}
// ... error handling
}
// ... termination
}
Một điều khiến hầu hết mọi người ngạc nhiên là cách hoạt động của chức năng. Cơ thể của định nghĩa chức năng được biên dịch thành một đối tượng mã. Sau đó, định nghĩa hàm được biên dịch thành mã [bên trong phần thân hàm, mô -đun, v.v.], khi được thực thi, xây dựng một đối tượng hàm từ đối tượng mã đó. .
Và bây giờ bạn đã sẵn sàng để bắt đầu vá Cpython để thêm các câu lệnh của riêng bạn, phải không? Chà, khi thay đổi các chương trình ngữ pháp của Cpython, có rất nhiều thứ để hiểu đúng [và thậm chí còn nhiều hơn nếu bạn cần tạo mã hóa mới]. Bạn có thể thấy dễ dàng hơn khi học Pypy cũng như CPython và bắt đầu hack trên Pypy trước và chỉ quay lại CPython một khi bạn biết rằng những gì bạn đang làm là hợp lý và có thể thực hiện được.
Chúng tôi đã bắt đầu loạt bài này với một cái nhìn tổng quan về VM Cpython. Chúng tôi đã học được rằng để chạy một chương trình Python, Cpython trước tiên biên dịch nó thành mã byte và chúng tôi đã nghiên cứu cách trình biên dịch hoạt động trong phần hai. Lần trước chúng tôi đã bước qua mã nguồn cpython bắt đầu với hàm
PyObject*
_PyEval_EvalFrameDefault[PyThreadState *tstate, PyFrameObject *f, int throwflag]
{
// ... declarations and initialization of local variables
// ... macros definitions
// ... call depth handling
// ... code for tracing and profiling
for [;;] {
// ... check if the bytecode execution must be suspended,
// e.g. other thread requested the GIL
// NEXTOPARG[] macro
_Py_CODEUNIT word = *next_instr; // _Py_CODEUNIT is a typedef for uint16_t
opcode = _Py_OPCODE[word];
oparg = _Py_OPARG[word];
next_instr++;
switch [opcode] {
case TARGET[NOP] {
FAST_DISPATCH[]; // more on this later
}
case TARGET[LOAD_FAST] {
// ... code for loading local variable
}
// ... 117 more cases for every possible opcode
}
// ... error handling
}
// ... termination
}
Lưu ý: Trong bài đăng này, tôi đang đề cập đến CPython 3.9. Một số chi tiết thực hiện chắc chắn sẽ thay đổi khi CPython phát triển. Tôi sẽ cố gắng theo dõi các thay đổi quan trọng và thêm ghi chú cập nhật.: In this post I'm referring to CPython 3.9. Some implementation details will certainly change as CPython evolves. I'll try to keep track of important changes and add update notes.
Điểm khởi đầu
Hãy nhớ lại ngắn gọn những gì chúng ta đã học được trong các phần trước. Chúng tôi nói với Cpython phải làm gì bằng cách viết mã Python. Tuy nhiên, VM Cpython chỉ hiểu mã Python byte. Đây là công việc của trình biên dịch để dịch mã python sang mã byte. Trình biên dịch lưu trữ mã byte trong một đối tượng mã, là một cấu trúc mô tả đầy đủ những gì một khối mã, như một mô -đun hoặc một hàm, làm. Để thực thi một đối tượng mã, trước tiên, CPython tạo ra trạng thái thực thi cho nó được gọi là đối tượng khung. Sau đó, nó chuyển một đối tượng khung cho chức năng đánh giá khung để thực hiện tính toán thực tế. Hàm đánh giá khung mặc định là
PyObject*
_PyEval_EvalFrameDefault[PyThreadState *tstate, PyFrameObject *f, int throwflag]
{
// ... declarations and initialization of local variables
// ... macros definitions
// ... call depth handling
// ... code for tracing and profiling
for [;;] {
// ... check if the bytecode execution must be suspended,
// e.g. other thread requested the GIL
// NEXTOPARG[] macro
_Py_CODEUNIT word = *next_instr; // _Py_CODEUNIT is a typedef for uint16_t
opcode = _Py_OPCODE[word];
oparg = _Py_OPARG[word];
next_instr++;
switch [opcode] {
case TARGET[NOP] {
FAST_DISPATCH[]; // more on this later
}
case TARGET[LOAD_FAST] {
// ... code for loading local variable
}
// ... 117 more cases for every possible opcode
}
// ... error handling
}
// ... termination
}
Để hiểu cách
PyObject*
_PyEval_EvalFrameDefault[PyThreadState *tstate, PyFrameObject *f, int throwflag]
{
// ... declarations and initialization of local variables
// ... macros definitions
// ... call depth handling
// ... code for tracing and profiling
for [;;] {
// ... check if the bytecode execution must be suspended,
// e.g. other thread requested the GIL
// NEXTOPARG[] macro
_Py_CODEUNIT word = *next_instr; // _Py_CODEUNIT is a typedef for uint16_t
opcode = _Py_OPCODE[word];
oparg = _Py_OPARG[word];
next_instr++;
switch [opcode] {
case TARGET[NOP] {
FAST_DISPATCH[]; // more on this later
}
case TARGET[LOAD_FAST] {
// ... code for loading local variable
}
// ... 117 more cases for every possible opcode
}
// ... error handling
}
// ... termination
}
// typedef struct _frame PyFrameObject; in other place
struct _frame {
PyObject_VAR_HEAD
struct _frame *f_back; /* previous frame, or NULL */
PyCodeObject *f_code; /* code segment */
PyObject *f_builtins; /* builtin symbol table [PyDictObject] */
PyObject *f_globals; /* global symbol table [PyDictObject] */
PyObject *f_locals; /* local symbol table [any mapping] */
PyObject **f_valuestack; /* points after the last local */
/* Next free slot in f_valuestack. Frame creation sets to f_valuestack.
Frame evaluation usually NULLs it, but a frame that yields sets it
to the current stack top. */
PyObject **f_stacktop;
PyObject *f_trace; /* Trace function */
char f_trace_lines; /* Emit per-line trace events? */
char f_trace_opcodes; /* Emit per-opcode trace events? */
/* Borrowed reference to a generator, or NULL */
PyObject *f_gen;
int f_lasti; /* Last instruction if called */
int f_lineno; /* Current line number */
int f_iblock; /* index in f_blockstack */
char f_executing; /* whether the frame is still executing */
PyTryBlock f_blockstack[CO_MAXBLOCKS]; /* for try and loop blocks */
PyObject *f_localsplus[1]; /* locals+stack, dynamically sized */
};
Trường
PyObject*
_PyEval_EvalFrameDefault[PyThreadState *tstate, PyFrameObject *f, int throwflag]
{
// ... declarations and initialization of local variables
// ... macros definitions
// ... call depth handling
// ... code for tracing and profiling
for [;;] {
// ... check if the bytecode execution must be suspended,
// e.g. other thread requested the GIL
// NEXTOPARG[] macro
_Py_CODEUNIT word = *next_instr; // _Py_CODEUNIT is a typedef for uint16_t
opcode = _Py_OPCODE[word];
oparg = _Py_OPARG[word];
next_instr++;
switch [opcode] {
case TARGET[NOP] {
FAST_DISPATCH[]; // more on this later
}
case TARGET[LOAD_FAST] {
// ... code for loading local variable
}
// ... 117 more cases for every possible opcode
}
// ... error handling
}
// ... termination
}
struct PyCodeObject {
PyObject_HEAD
int co_argcount; /* #arguments, except *args */
int co_posonlyargcount; /* #positional only arguments */
int co_kwonlyargcount; /* #keyword only arguments */
int co_nlocals; /* #local variables */
int co_stacksize; /* #entries needed for evaluation stack */
int co_flags; /* CO_..., see below */
int co_firstlineno; /* first source line number */
PyObject *co_code; /* instruction opcodes */
PyObject *co_consts; /* list [constants used] */
PyObject *co_names; /* list of strings [names used] */
PyObject *co_varnames; /* tuple of strings [local variable names] */
PyObject *co_freevars; /* tuple of strings [free variable names] */
PyObject *co_cellvars; /* tuple of strings [cell variable names] */
/* The rest aren't used in either hash or comparisons, except for co_name,
used in both. This is done to preserve the name and line number
for tracebacks and debuggers; otherwise, constant de-duplication
would collapse identical functions/lambdas defined on different lines.
*/
Py_ssize_t *co_cell2arg; /* Maps cell vars which are arguments. */
PyObject *co_filename; /* unicode [where it was loaded from] */
PyObject *co_name; /* unicode [name, for reference] */
PyObject *co_lnotab; /* string [encoding addrlineno mapping] See
Objects/lnotab_notes.txt for details. */
void *co_zombieframe; /* for optimization only [see frameobject.c] */
PyObject *co_weakreflist; /* to support weakrefs to code objects */
/* Scratch space for extra data relating to the code object.
Type is a void* to keep the format private in codeobject.c to force
people to go through the proper APIs. */
void *co_extra;
/* Per opcodes just-in-time cache
*
* To reduce cache size, we use indirect mapping from opcode index to
* cache object:
* cache = co_opcache[co_opcache_map[next_instr - first_instr] - 1]
*/
// co_opcache_map is indexed by [next_instr - first_instr].
// * 0 means there is no cache for this opcode.
// * n > 0 means there is cache in co_opcache[n-1].
unsigned char *co_opcache_map;
_PyOpcache *co_opcache;
int co_opcache_flag; // used to determine when create a cache.
unsigned char co_opcache_size; // length of co_opcache.
};
Trường quan trọng nhất của đối tượng mã là
struct _ceval_runtime_state {
/* Request for checking signals. It is shared by all interpreters [see
bpo-40513]. Any thread of any interpreter can receive a signal, but only
the main thread of the main interpreter can handle signals: see
_Py_ThreadCanHandleSignals[]. */
_Py_atomic_int signals_pending;
struct _gil_runtime_state gil;
};
Đừng lo lắng nếu một số thành viên của các cấu trúc trên vẫn là một bí ẩn đối với bạn. Chúng ta sẽ thấy những gì chúng được sử dụng khi chúng ta tiến lên trong nỗ lực của chúng ta để hiểu cách thức VM CPython thực thi mã byte.
Tổng quan về vòng lặp đánh giá
Vấn đề thực hiện mã Bytepy Python có vẻ không có trí tuệ đối với bạn. Thật vậy, tất cả các VM phải làm là lặp lại các hướng dẫn và hành động theo chúng. Và đây là những gì về cơ bản
PyObject*
_PyEval_EvalFrameDefault[PyThreadState *tstate, PyFrameObject *f, int throwflag]
{
// ... declarations and initialization of local variables
// ... macros definitions
// ... call depth handling
// ... code for tracing and profiling
for [;;] {
// ... check if the bytecode execution must be suspended,
// e.g. other thread requested the GIL
// NEXTOPARG[] macro
_Py_CODEUNIT word = *next_instr; // _Py_CODEUNIT is a typedef for uint16_t
opcode = _Py_OPCODE[word];
oparg = _Py_OPARG[word];
next_instr++;
switch [opcode] {
case TARGET[NOP] {
FAST_DISPATCH[]; // more on this later
}
case TARGET[LOAD_FAST] {
// ... code for loading local variable
}
// ... 117 more cases for every possible opcode
}
// ... error handling
}
// ... termination
}
struct _ceval_runtime_state {
/* Request for checking signals. It is shared by all interpreters [see
bpo-40513]. Any thread of any interpreter can receive a signal, but only
the main thread of the main interpreter can handle signals: see
_Py_ThreadCanHandleSignals[]. */
_Py_atomic_int signals_pending;
struct _gil_runtime_state gil;
};
struct _ceval_runtime_state {
/* Request for checking signals. It is shared by all interpreters [see
bpo-40513]. Any thread of any interpreter can receive a signal, but only
the main thread of the main interpreter can handle signals: see
_Py_ThreadCanHandleSignals[]. */
_Py_atomic_int signals_pending;
struct _gil_runtime_state gil;
};
struct _ceval_runtime_state {
/* Request for checking signals. It is shared by all interpreters [see
bpo-40513]. Any thread of any interpreter can receive a signal, but only
the main thread of the main interpreter can handle signals: see
_Py_ThreadCanHandleSignals[]. */
_Py_atomic_int signals_pending;
struct _gil_runtime_state gil;
};
struct _ceval_runtime_state {
/* Request for checking signals. It is shared by all interpreters [see
bpo-40513]. Any thread of any interpreter can receive a signal, but only
the main thread of the main interpreter can handle signals: see
_Py_ThreadCanHandleSignals[]. */
_Py_atomic_int signals_pending;
struct _gil_runtime_state gil;
};
struct _ceval_runtime_state {
/* Request for checking signals. It is shared by all interpreters [see
bpo-40513]. Any thread of any interpreter can receive a signal, but only
the main thread of the main interpreter can handle signals: see
_Py_ThreadCanHandleSignals[]. */
_Py_atomic_int signals_pending;
struct _gil_runtime_state gil;
};
PyObject*
_PyEval_EvalFrameDefault[PyThreadState *tstate, PyFrameObject *f, int throwflag]
{
// ... declarations and initialization of local variables
// ... macros definitions
// ... call depth handling
// ... code for tracing and profiling
for [;;] {
// ... check if the bytecode execution must be suspended,
// e.g. other thread requested the GIL
// NEXTOPARG[] macro
_Py_CODEUNIT word = *next_instr; // _Py_CODEUNIT is a typedef for uint16_t
opcode = _Py_OPCODE[word];
oparg = _Py_OPARG[word];
next_instr++;
switch [opcode] {
case TARGET[NOP] {
FAST_DISPATCH[]; // more on this later
}
case TARGET[LOAD_FAST] {
// ... code for loading local variable
}
// ... 117 more cases for every possible opcode
}
// ... error handling
}
// ... termination
}
PyObject*
_PyEval_EvalFrameDefault[PyThreadState *tstate, PyFrameObject *f, int throwflag]
{
// ... declarations and initialization of local variables
// ... macros definitions
// ... call depth handling
// ... code for tracing and profiling
for [;;] {
// ... check if the bytecode execution must be suspended,
// e.g. other thread requested the GIL
// NEXTOPARG[] macro
_Py_CODEUNIT word = *next_instr; // _Py_CODEUNIT is a typedef for uint16_t
opcode = _Py_OPCODE[word];
oparg = _Py_OPARG[word];
next_instr++;
switch [opcode] {
case TARGET[NOP] {
FAST_DISPATCH[]; // more on this later
}
case TARGET[LOAD_FAST] {
// ... code for loading local variable
}
// ... 117 more cases for every possible opcode
}
// ... error handling
}
// ... termination
}
Để có được một bức tranh thực tế hơn, hãy thảo luận về một số tác phẩm bị bỏ qua chi tiết hơn.
lý do để đình chỉ vòng lặp
Thỉnh thoảng, luồng hiện đang chạy dừng thực thi mã byte để làm việc khác hoặc không làm gì cả. Điều này có thể xảy ra do một trong bốn lý do:
- Có tín hiệu để xử lý. Khi bạn đăng ký một chức năng làm trình xử lý tín hiệu bằng cách sử dụng
8, CPython sẽ lưu trữ chức năng này trong mảng trình xử lý. Hàm thực sự sẽ được gọi khi một luồng nhận được tín hiệu làstruct _ceval_runtime_state { /* Request for checking signals. It is shared by all interpreters [see bpo-40513]. Any thread of any interpreter can receive a signal, but only the main thread of the main interpreter can handle signals: see _Py_ThreadCanHandleSignals[]. */ _Py_atomic_int signals_pending; struct _gil_runtime_state gil; };
9 [nó được chuyển đến chức năng thư việnstruct _ceval_runtime_state { /* Request for checking signals. It is shared by all interpreters [see bpo-40513]. Any thread of any interpreter can receive a signal, but only the main thread of the main interpreter can handle signals: see _Py_ThreadCanHandleSignals[]. */ _Py_atomic_int signals_pending; struct _gil_runtime_state gil; };
0 trên các hệ thống giống UNIX]. Khi được gọi,struct _ceval_state { int recursion_limit; /* Records whether tracing is on for any thread. Counts the number of threads for which tstate->c_tracefunc is non-NULL, so if the value is 0, we know we don't have to check this thread's c_tracefunc. This speeds up the if statement in _PyEval_EvalFrameDefault[] after fast_next_opcode. */ int tracing_possible; /* This single variable consolidates all requests to break out of the fast path in the eval loop. */ _Py_atomic_int eval_breaker; /* Request for dropping the GIL */ _Py_atomic_int gil_drop_request; struct _pending_calls pending; };
9 đặt một biến Boolean nói rằng hàm trong mảng trình xử lý tương ứng với tín hiệu nhận được phải được gọi. Theo định kỳ, luồng chính của trình thông dịch chính gọi trình xử lý vấp.struct _ceval_runtime_state { /* Request for checking signals. It is shared by all interpreters [see bpo-40513]. Any thread of any interpreter can receive a signal, but only the main thread of the main interpreter can handle signals: see _Py_ThreadCanHandleSignals[]. */ _Py_atomic_int signals_pending; struct _gil_runtime_state gil; }; - Có những cuộc gọi đang chờ xử lý để gọi. Các cuộc gọi đang chờ xử lý là một cơ chế cho phép lên lịch một chức năng được thực thi từ luồng chính. Cơ chế này được phơi bày bởi API Python/C thông qua hàm
2.struct _ceval_state { int recursion_limit; /* Records whether tracing is on for any thread. Counts the number of threads for which tstate->c_tracefunc is non-NULL, so if the value is 0, we know we don't have to check this thread's c_tracefunc. This speeds up the if statement in _PyEval_EvalFrameDefault[] after fast_next_opcode. */ int tracing_possible; /* This single variable consolidates all requests to break out of the fast path in the eval loop. */ _Py_atomic_int eval_breaker; /* Request for dropping the GIL */ _Py_atomic_int gil_drop_request; struct _pending_calls pending; }; - Ngoại lệ không đồng bộ được nâng lên. Ngoại lệ không đồng bộ là một ngoại lệ được đặt trong một luồng từ một luồng khác. Điều này có thể được thực hiện bằng cách sử dụng hàm
3 được cung cấp bởi API Python/C.struct _ceval_state { int recursion_limit; /* Records whether tracing is on for any thread. Counts the number of threads for which tstate->c_tracefunc is non-NULL, so if the value is 0, we know we don't have to check this thread's c_tracefunc. This speeds up the if statement in _PyEval_EvalFrameDefault[] after fast_next_opcode. */ int tracing_possible; /* This single variable consolidates all requests to break out of the fast path in the eval loop. */ _Py_atomic_int eval_breaker; /* Request for dropping the GIL */ _Py_atomic_int gil_drop_request; struct _pending_calls pending; }; - Chủ đề hiện đang chạy được yêu cầu thả GIL. Khi nó nhìn thấy một yêu cầu như vậy, nó sẽ giảm GIL và đợi cho đến khi nó có được Gil một lần nữa.
CPython có các chỉ số cho mỗi sự kiện này. Biến chỉ ra rằng có những người xử lý để gọi là thành viên của
struct _ceval_state {
int recursion_limit;
/* Records whether tracing is on for any thread. Counts the number
of threads for which tstate->c_tracefunc is non-NULL, so if the
value is 0, we know we don't have to check this thread's
c_tracefunc. This speeds up the if statement in
_PyEval_EvalFrameDefault[] after fast_next_opcode. */
int tracing_possible;
/* This single variable consolidates all requests to break out of
the fast path in the eval loop. */
_Py_atomic_int eval_breaker;
/* Request for dropping the GIL */
_Py_atomic_int gil_drop_request;
struct _pending_calls pending;
};
struct _ceval_state {
int recursion_limit;
/* Records whether tracing is on for any thread. Counts the number
of threads for which tstate->c_tracefunc is non-NULL, so if the
value is 0, we know we don't have to check this thread's
c_tracefunc. This speeds up the if statement in
_PyEval_EvalFrameDefault[] after fast_next_opcode. */
int tracing_possible;
/* This single variable consolidates all requests to break out of
the fast path in the eval loop. */
_Py_atomic_int eval_breaker;
/* Request for dropping the GIL */
_Py_atomic_int gil_drop_request;
struct _pending_calls pending;
};
struct _ceval_runtime_state {
/* Request for checking signals. It is shared by all interpreters [see
bpo-40513]. Any thread of any interpreter can receive a signal, but only
the main thread of the main interpreter can handle signals: see
_Py_ThreadCanHandleSignals[]. */
_Py_atomic_int signals_pending;
struct _gil_runtime_state gil;
};
Các chỉ số khác là thành viên của
struct _ceval_state {
int recursion_limit;
/* Records whether tracing is on for any thread. Counts the number
of threads for which tstate->c_tracefunc is non-NULL, so if the
value is 0, we know we don't have to check this thread's
c_tracefunc. This speeds up the if statement in
_PyEval_EvalFrameDefault[] after fast_next_opcode. */
int tracing_possible;
/* This single variable consolidates all requests to break out of
the fast path in the eval loop. */
_Py_atomic_int eval_breaker;
/* Request for dropping the GIL */
_Py_atomic_int gil_drop_request;
struct _pending_calls pending;
};
struct _ceval_state {
int recursion_limit;
/* Records whether tracing is on for any thread. Counts the number
of threads for which tstate->c_tracefunc is non-NULL, so if the
value is 0, we know we don't have to check this thread's
c_tracefunc. This speeds up the if statement in
_PyEval_EvalFrameDefault[] after fast_next_opcode. */
int tracing_possible;
/* This single variable consolidates all requests to break out of
the fast path in the eval loop. */
_Py_atomic_int eval_breaker;
/* Request for dropping the GIL */
_Py_atomic_int gil_drop_request;
struct _pending_calls pending;
};
struct _ceval_state {
int recursion_limit;
/* Records whether tracing is on for any thread. Counts the number
of threads for which tstate->c_tracefunc is non-NULL, so if the
value is 0, we know we don't have to check this thread's
c_tracefunc. This speeds up the if statement in
_PyEval_EvalFrameDefault[] after fast_next_opcode. */
int tracing_possible;
/* This single variable consolidates all requests to break out of
the fast path in the eval loop. */
_Py_atomic_int eval_breaker;
/* Request for dropping the GIL */
_Py_atomic_int gil_drop_request;
struct _pending_calls pending;
};
Kết quả của việc cung cấp tất cả các chỉ số cùng nhau được lưu trữ trong biến
struct _ceval_state {
int recursion_limit;
/* Records whether tracing is on for any thread. Counts the number
of threads for which tstate->c_tracefunc is non-NULL, so if the
value is 0, we know we don't have to check this thread's
c_tracefunc. This speeds up the if statement in
_PyEval_EvalFrameDefault[] after fast_next_opcode. */
int tracing_possible;
/* This single variable consolidates all requests to break out of
the fast path in the eval loop. */
_Py_atomic_int eval_breaker;
/* Request for dropping the GIL */
_Py_atomic_int gil_drop_request;
struct _pending_calls pending;
};
struct _ceval_state {
int recursion_limit;
/* Records whether tracing is on for any thread. Counts the number
of threads for which tstate->c_tracefunc is non-NULL, so if the
value is 0, we know we don't have to check this thread's
c_tracefunc. This speeds up the if statement in
_PyEval_EvalFrameDefault[] after fast_next_opcode. */
int tracing_possible;
/* This single variable consolidates all requests to break out of
the fast path in the eval loop. */
_Py_atomic_int eval_breaker;
/* Request for dropping the GIL */
_Py_atomic_int gil_drop_request;
struct _pending_calls pending;
};
tính toán gotos
Mã cho vòng đánh giá có đầy đủ các macro như
for [;;] {
// ... check if the bytecode execution must be suspended
fast_next_opcode:
// NEXTOPARG[] macro
_Py_CODEUNIT word = *next_instr;
opcode = _Py_OPCODE[word];
oparg = _Py_OPARG[word];
next_instr++;
switch [opcode] {
// TARGET[NOP] expands to NOP
case NOP: {
goto fast_next_opcode; // FAST_DISPATCH[] macro
}
// ...
case BINARY_MULTIPLY: {
// ... code for binary multiplication
continue; // DISPATCH[] macro
}
// ...
}
// ... error handling
}
for [;;] {
// ... check if the bytecode execution must be suspended
fast_next_opcode:
// NEXTOPARG[] macro
_Py_CODEUNIT word = *next_instr;
opcode = _Py_OPCODE[word];
oparg = _Py_OPARG[word];
next_instr++;
switch [opcode] {
// TARGET[NOP] expands to NOP
case NOP: {
goto fast_next_opcode; // FAST_DISPATCH[] macro
}
// ...
case BINARY_MULTIPLY: {
// ... code for binary multiplication
continue; // DISPATCH[] macro
}
// ...
}
// ... error handling
}
Sau khi thực hiện bất kỳ lệnh nào đã cho, VM thực hiện một trong ba điều:
- Nó trở về từ chức năng đánh giá. Điều này xảy ra khi VM thực thi hướng dẫn
2,for [;;] { // ... check if the bytecode execution must be suspended fast_next_opcode: // NEXTOPARG[] macro _Py_CODEUNIT word = *next_instr; opcode = _Py_OPCODE[word]; oparg = _Py_OPARG[word]; next_instr++; switch [opcode] { // TARGET[NOP] expands to NOP case NOP: { goto fast_next_opcode; // FAST_DISPATCH[] macro } // ... case BINARY_MULTIPLY: { // ... code for binary multiplication continue; // DISPATCH[] macro } // ... } // ... error handling }
3 hoặcfor [;;] { // ... check if the bytecode execution must be suspended fast_next_opcode: // NEXTOPARG[] macro _Py_CODEUNIT word = *next_instr; opcode = _Py_OPCODE[word]; oparg = _Py_OPARG[word]; next_instr++; switch [opcode] { // TARGET[NOP] expands to NOP case NOP: { goto fast_next_opcode; // FAST_DISPATCH[] macro } // ... case BINARY_MULTIPLY: { // ... code for binary multiplication continue; // DISPATCH[] macro } // ... } // ... error handling }
4.for [;;] { // ... check if the bytecode execution must be suspended fast_next_opcode: // NEXTOPARG[] macro _Py_CODEUNIT word = *next_instr; opcode = _Py_OPCODE[word]; oparg = _Py_OPARG[word]; next_instr++; switch [opcode] { // TARGET[NOP] expands to NOP case NOP: { goto fast_next_opcode; // FAST_DISPATCH[] macro } // ... case BINARY_MULTIPLY: { // ... code for binary multiplication continue; // DISPATCH[] macro } // ... } // ... error handling } - Nó xử lý lỗi và tiếp tục thực thi hoặc trả về từ chức năng đánh giá với bộ ngoại lệ. Lỗi có thể xảy ra khi, ví dụ, VM thực hiện lệnh
5 và các đối tượng được thêm vào không thực hiện các phương thứcfor [;;] { // ... check if the bytecode execution must be suspended fast_next_opcode: // NEXTOPARG[] macro _Py_CODEUNIT word = *next_instr; opcode = _Py_OPCODE[word]; oparg = _Py_OPARG[word]; next_instr++; switch [opcode] { // TARGET[NOP] expands to NOP case NOP: { goto fast_next_opcode; // FAST_DISPATCH[] macro } // ... case BINARY_MULTIPLY: { // ... code for binary multiplication continue; // DISPATCH[] macro } // ... } // ... error handling }
6 vàfor [;;] { // ... check if the bytecode execution must be suspended fast_next_opcode: // NEXTOPARG[] macro _Py_CODEUNIT word = *next_instr; opcode = _Py_OPCODE[word]; oparg = _Py_OPARG[word]; next_instr++; switch [opcode] { // TARGET[NOP] expands to NOP case NOP: { goto fast_next_opcode; // FAST_DISPATCH[] macro } // ... case BINARY_MULTIPLY: { // ... code for binary multiplication continue; // DISPATCH[] macro } // ... } // ... error handling }
7.for [;;] { // ... check if the bytecode execution must be suspended fast_next_opcode: // NEXTOPARG[] macro _Py_CODEUNIT word = *next_instr; opcode = _Py_OPCODE[word]; oparg = _Py_OPARG[word]; next_instr++; switch [opcode] { // TARGET[NOP] expands to NOP case NOP: { goto fast_next_opcode; // FAST_DISPATCH[] macro } // ... case BINARY_MULTIPLY: { // ... code for binary multiplication continue; // DISPATCH[] macro } // ... } // ... error handling } - Nó tiếp tục thực hiện. Làm thế nào để thực hiện VM thực hiện lệnh tiếp theo? Giải pháp đơn giản nhất sẽ là kết thúc mỗi khối
4 không hoàn nguyên với câu lệnhstruct _ceval_runtime_state { /* Request for checking signals. It is shared by all interpreters [see bpo-40513]. Any thread of any interpreter can receive a signal, but only the main thread of the main interpreter can handle signals: see _Py_ThreadCanHandleSignals[]. */ _Py_atomic_int signals_pending; struct _gil_runtime_state gil; };
9. Giải pháp thực sự, mặc dù, phức tạp hơn một chút.for [;;] { // ... check if the bytecode execution must be suspended fast_next_opcode: // NEXTOPARG[] macro _Py_CODEUNIT word = *next_instr; opcode = _Py_OPCODE[word]; oparg = _Py_OPARG[word]; next_instr++; switch [opcode] { // TARGET[NOP] expands to NOP case NOP: { goto fast_next_opcode; // FAST_DISPATCH[] macro } // ... case BINARY_MULTIPLY: { // ... code for binary multiplication continue; // DISPATCH[] macro } // ... } // ... error handling }
Để xem vấn đề với câu lệnh
for [;;] {
// ... check if the bytecode execution must be suspended
fast_next_opcode:
// NEXTOPARG[] macro
_Py_CODEUNIT word = *next_instr;
opcode = _Py_OPCODE[word];
oparg = _Py_OPARG[word];
next_instr++;
switch [opcode] {
// TARGET[NOP] expands to NOP
case NOP: {
goto fast_next_opcode; // FAST_DISPATCH[] macro
}
// ...
case BINARY_MULTIPLY: {
// ... code for binary multiplication
continue; // DISPATCH[] macro
}
// ...
}
// ... error handling
}
struct _ceval_runtime_state {
/* Request for checking signals. It is shared by all interpreters [see
bpo-40513]. Any thread of any interpreter can receive a signal, but only
the main thread of the main interpreter can handle signals: see
_Py_ThreadCanHandleSignals[]. */
_Py_atomic_int signals_pending;
struct _gil_runtime_state gil;
};
struct _ceval_runtime_state {
/* Request for checking signals. It is shared by all interpreters [see
bpo-40513]. Any thread of any interpreter can receive a signal, but only
the main thread of the main interpreter can handle signals: see
_Py_ThreadCanHandleSignals[]. */
_Py_atomic_int signals_pending;
struct _gil_runtime_state gil;
};
struct _ceval_runtime_state {
/* Request for checking signals. It is shared by all interpreters [see
bpo-40513]. Any thread of any interpreter can receive a signal, but only
the main thread of the main interpreter can handle signals: see
_Py_ThreadCanHandleSignals[]. */
_Py_atomic_int signals_pending;
struct _gil_runtime_state gil;
};
struct _ceval_runtime_state {
/* Request for checking signals. It is shared by all interpreters [see
bpo-40513]. Any thread of any interpreter can receive a signal, but only
the main thread of the main interpreter can handle signals: see
_Py_ThreadCanHandleSignals[]. */
_Py_atomic_int signals_pending;
struct _gil_runtime_state gil;
};
for [;;] {
// ... check if the bytecode execution must be suspended
fast_next_opcode:
// NEXTOPARG[] macro
_Py_CODEUNIT word = *next_instr;
opcode = _Py_OPCODE[word];
oparg = _Py_OPARG[word];
next_instr++;
switch [opcode] {
// TARGET[NOP] expands to NOP
case NOP: {
goto fast_next_opcode; // FAST_DISPATCH[] macro
}
// ...
case BINARY_MULTIPLY: {
// ... code for binary multiplication
continue; // DISPATCH[] macro
}
// ...
}
// ... error handling
}
Câu lệnh
9 vào cuối khốifor [;;] { // ... check if the bytecode execution must be suspended fast_next_opcode: // NEXTOPARG[] macro _Py_CODEUNIT word = *next_instr; opcode = _Py_OPCODE[word]; oparg = _Py_OPARG[word]; next_instr++; switch [opcode] { // TARGET[NOP] expands to NOP case NOP: { goto fast_next_opcode; // FAST_DISPATCH[] macro } // ... case BINARY_MULTIPLY: { // ... code for binary multiplication continue; // DISPATCH[] macro } // ... } // ... error handling }
4 thêm một bước nhảy khác. Do đó, để thực thi một opcode, VM phải nhảy hai lần: đến khi bắt đầu vòng lặp và sau đó đến khốistruct _ceval_runtime_state { /* Request for checking signals. It is shared by all interpreters [see bpo-40513]. Any thread of any interpreter can receive a signal, but only the main thread of the main interpreter can handle signals: see _Py_ThreadCanHandleSignals[]. */ _Py_atomic_int signals_pending; struct _gil_runtime_state gil; };
4 tiếp theo.struct _ceval_runtime_state { /* Request for checking signals. It is shared by all interpreters [see bpo-40513]. Any thread of any interpreter can receive a signal, but only the main thread of the main interpreter can handle signals: see _Py_ThreadCanHandleSignals[]. */ _Py_atomic_int signals_pending; struct _gil_runtime_state gil; };Vì tất cả các opcode được gửi bởi một bước nhảy, một CPU có một ít cơ hội dự đoán opcode tiếp theo. Điều tốt nhất có thể làm là chọn opcode cuối cùng hoặc, có thể là cái thường xuyên nhất.
Ý tưởng về việc tối ưu hóa là đặt một bước nhảy riêng biệt vào cuối mỗi khối
struct _ceval_runtime_state {
/* Request for checking signals. It is shared by all interpreters [see
bpo-40513]. Any thread of any interpreter can receive a signal, but only
the main thread of the main interpreter can handle signals: see
_Py_ThreadCanHandleSignals[]. */
_Py_atomic_int signals_pending;
struct _gil_runtime_state gil;
};
Việc tối ưu hóa có thể được bật hoặc tắt. Nó phụ thuộc vào việc trình biên dịch có hỗ trợ tiện ích mở rộng GCC C được gọi là "nhãn là giá trị" hay không. Hiệu quả của việc cho phép tối ưu hóa là các macro nhất định, chẳng hạn như
for [;;] {
// ... check if the bytecode execution must be suspended
fast_next_opcode:
// NEXTOPARG[] macro
_Py_CODEUNIT word = *next_instr;
opcode = _Py_OPCODE[word];
oparg = _Py_OPARG[word];
next_instr++;
switch [opcode] {
// TARGET[NOP] expands to NOP
case NOP: {
goto fast_next_opcode; // FAST_DISPATCH[] macro
}
// ...
case BINARY_MULTIPLY: {
// ... code for binary multiplication
continue; // DISPATCH[] macro
}
// ...
}
// ... error handling
}
for [;;] {
// ... check if the bytecode execution must be suspended
fast_next_opcode:
// NEXTOPARG[] macro
_Py_CODEUNIT word = *next_instr;
opcode = _Py_OPCODE[word];
oparg = _Py_OPARG[word];
next_instr++;
switch [opcode] {
// TARGET[NOP] expands to NOP
case NOP: {
goto fast_next_opcode; // FAST_DISPATCH[] macro
}
// ...
case BINARY_MULTIPLY: {
// ... code for binary multiplication
continue; // DISPATCH[] macro
}
// ...
}
// ... error handling
}
for [;;] {
// ... check if the bytecode execution must be suspended
fast_next_opcode:
// NEXTOPARG[] macro
_Py_CODEUNIT word = *next_instr;
opcode = _Py_OPCODE[word];
oparg = _Py_OPARG[word];
next_instr++;
switch [opcode] {
// TARGET[NOP] expands to NOP: TARGET_NOP:
// TARGET_NOP is a label
case NOP: TARGET_NOP: {
// FAST_DISPATCH[] macro
// when tracing is disabled
f->f_lasti = INSTR_OFFSET[];
NEXTOPARG[];
goto *opcode_targets[opcode];
}
// ...
case BINARY_MULTIPLY: TARGET_BINARY_MULTIPLY: {
// ... code for binary multiplication
// DISPATCH[] macro
if [!_Py_atomic_load_relaxed[eval_breaker]] {
FAST_DISPATCH[];
}
continue;
}
// ...
}
// ... error handling
}
for [;;] {
// ... check if the bytecode execution must be suspended
fast_next_opcode:
// NEXTOPARG[] macro
_Py_CODEUNIT word = *next_instr;
opcode = _Py_OPCODE[word];
oparg = _Py_OPARG[word];
next_instr++;
switch [opcode] {
// TARGET[NOP] expands to NOP: TARGET_NOP:
// TARGET_NOP is a label
case NOP: TARGET_NOP: {
// FAST_DISPATCH[] macro
// when tracing is disabled
f->f_lasti = INSTR_OFFSET[];
NEXTOPARG[];
goto *opcode_targets[opcode];
}
// ...
case BINARY_MULTIPLY: TARGET_BINARY_MULTIPLY: {
// ... code for binary multiplication
// DISPATCH[] macro
if [!_Py_atomic_load_relaxed[eval_breaker]] {
FAST_DISPATCH[];
}
continue;
}
// ...
}
// ... error handling
}
for [;;] {
// ... check if the bytecode execution must be suspended
fast_next_opcode:
// NEXTOPARG[] macro
_Py_CODEUNIT word = *next_instr;
opcode = _Py_OPCODE[word];
oparg = _Py_OPARG[word];
next_instr++;
switch [opcode] {
// TARGET[NOP] expands to NOP: TARGET_NOP:
// TARGET_NOP is a label
case NOP: TARGET_NOP: {
// FAST_DISPATCH[] macro
// when tracing is disabled
f->f_lasti = INSTR_OFFSET[];
NEXTOPARG[];
goto *opcode_targets[opcode];
}
// ...
case BINARY_MULTIPLY: TARGET_BINARY_MULTIPLY: {
// ... code for binary multiplication
// DISPATCH[] macro
if [!_Py_atomic_load_relaxed[eval_breaker]] {
FAST_DISPATCH[];
}
continue;
}
// ...
}
// ... error handling
}
struct _ceval_runtime_state {
/* Request for checking signals. It is shared by all interpreters [see
bpo-40513]. Any thread of any interpreter can receive a signal, but only
the main thread of the main interpreter can handle signals: see
_Py_ThreadCanHandleSignals[]. */
_Py_atomic_int signals_pending;
struct _gil_runtime_state gil;
};
for [;;] {
// ... check if the bytecode execution must be suspended
fast_next_opcode:
// NEXTOPARG[] macro
_Py_CODEUNIT word = *next_instr;
opcode = _Py_OPCODE[word];
oparg = _Py_OPARG[word];
next_instr++;
switch [opcode] {
// TARGET[NOP] expands to NOP
case NOP: {
goto fast_next_opcode; // FAST_DISPATCH[] macro
}
// ...
case BINARY_MULTIPLY: {
// ... code for binary multiplication
continue; // DISPATCH[] macro
}
// ...
}
// ... error handling
}
for [;;] {
// ... check if the bytecode execution must be suspended
fast_next_opcode:
// NEXTOPARG[] macro
_Py_CODEUNIT word = *next_instr;
opcode = _Py_OPCODE[word];
oparg = _Py_OPARG[word];
next_instr++;
switch [opcode] {
// TARGET[NOP] expands to NOP: TARGET_NOP:
// TARGET_NOP is a label
case NOP: TARGET_NOP: {
// FAST_DISPATCH[] macro
// when tracing is disabled
f->f_lasti = INSTR_OFFSET[];
NEXTOPARG[];
goto *opcode_targets[opcode];
}
// ...
case BINARY_MULTIPLY: TARGET_BINARY_MULTIPLY: {
// ... code for binary multiplication
// DISPATCH[] macro
if [!_Py_atomic_load_relaxed[eval_breaker]] {
FAST_DISPATCH[];
}
continue;
}
// ...
}
// ... error handling
}
for [;;] {
// ... check if the bytecode execution must be suspended
fast_next_opcode:
// NEXTOPARG[] macro
_Py_CODEUNIT word = *next_instr;
opcode = _Py_OPCODE[word];
oparg = _Py_OPARG[word];
next_instr++;
switch [opcode] {
// TARGET[NOP] expands to NOP
case NOP: {
goto fast_next_opcode; // FAST_DISPATCH[] macro
}
// ...
case BINARY_MULTIPLY: {
// ... code for binary multiplication
continue; // DISPATCH[] macro
}
// ...
}
// ... error handling
}
Macro
for [;;] {
// ... check if the bytecode execution must be suspended
fast_next_opcode:
// NEXTOPARG[] macro
_Py_CODEUNIT word = *next_instr;
opcode = _Py_OPCODE[word];
oparg = _Py_OPARG[word];
next_instr++;
switch [opcode] {
// TARGET[NOP] expands to NOP: TARGET_NOP:
// TARGET_NOP is a label
case NOP: TARGET_NOP: {
// FAST_DISPATCH[] macro
// when tracing is disabled
f->f_lasti = INSTR_OFFSET[];
NEXTOPARG[];
goto *opcode_targets[opcode];
}
// ...
case BINARY_MULTIPLY: TARGET_BINARY_MULTIPLY: {
// ... code for binary multiplication
// DISPATCH[] macro
if [!_Py_atomic_load_relaxed[eval_breaker]] {
FAST_DISPATCH[];
}
continue;
}
// ...
}
// ... error handling
}
Nếu trình biên dịch hỗ trợ tiện ích mở rộng "Nhãn là giá trị", chúng ta có thể sử dụng toán tử
for [;;] {
// ... check if the bytecode execution must be suspended
fast_next_opcode:
// NEXTOPARG[] macro
_Py_CODEUNIT word = *next_instr;
opcode = _Py_OPCODE[word];
oparg = _Py_OPARG[word];
next_instr++;
switch [opcode] {
// TARGET[NOP] expands to NOP: TARGET_NOP:
// TARGET_NOP is a label
case NOP: TARGET_NOP: {
// FAST_DISPATCH[] macro
// when tracing is disabled
f->f_lasti = INSTR_OFFSET[];
NEXTOPARG[];
goto *opcode_targets[opcode];
}
// ...
case BINARY_MULTIPLY: TARGET_BINARY_MULTIPLY: {
// ... code for binary multiplication
// DISPATCH[] macro
if [!_Py_atomic_load_relaxed[eval_breaker]] {
FAST_DISPATCH[];
}
continue;
}
// ...
}
// ... error handling
}
case TARGET[BINARY_ADD]: {
PyObject *right = POP[];
PyObject *left = TOP[];
PyObject *sum;
// ... special case of string addition
sum = PyNumber_Add[left, right];
Py_DECREF[left];
Py_DECREF[right];
SET_TOP[sum];
if [sum == NULL]
goto error;
DISPATCH[];
}
Sau đó chúng ta có thể vào nhãn bằng cách phân tích con trỏ:
Phần mở rộng này cho phép thực hiện một bảng nhảy trong C dưới dạng một mảng các con trỏ nhãn. Và đó là những gì Cpython làm:
static void *opcode_targets[256] = {
&&_unknown_opcode,
&&TARGET_POP_TOP,
&&TARGET_ROT_TWO,
&&TARGET_ROT_THREE,
&&TARGET_DUP_TOP,
&&TARGET_DUP_TOP_TWO,
&&TARGET_ROT_FOUR,
&&_unknown_opcode,
&&_unknown_opcode,
&&TARGET_NOP,
&&TARGET_UNARY_POSITIVE,
&&TARGET_UNARY_NEGATIVE,
&&TARGET_UNARY_NOT,
// ... quite a few more
};
Đây là phiên bản tối ưu của vòng lặp đánh giá trông như thế nào:
for [;;] {
// ... check if the bytecode execution must be suspended
fast_next_opcode:
// NEXTOPARG[] macro
_Py_CODEUNIT word = *next_instr;
opcode = _Py_OPCODE[word];
oparg = _Py_OPARG[word];
next_instr++;
switch [opcode] {
// TARGET[NOP] expands to NOP: TARGET_NOP:
// TARGET_NOP is a label
case NOP: TARGET_NOP: {
// FAST_DISPATCH[] macro
// when tracing is disabled
f->f_lasti = INSTR_OFFSET[];
NEXTOPARG[];
goto *opcode_targets[opcode];
}
// ...
case BINARY_MULTIPLY: TARGET_BINARY_MULTIPLY: {
// ... code for binary multiplication
// DISPATCH[] macro
if [!_Py_atomic_load_relaxed[eval_breaker]] {
FAST_DISPATCH[];
}
continue;
}
// ...
}
// ... error handling
}
Phần mở rộng được hỗ trợ bởi các trình biên dịch GCC và Clang. Vì vậy, khi bạn chạy
case TARGET[BINARY_ADD]: {
PyObject *right = POP[];
PyObject *left = TOP[];
PyObject *sum;
// ... special case of string addition
sum = PyNumber_Add[left, right];
Py_DECREF[left];
Py_DECREF[right];
SET_TOP[sum];
if [sum == NULL]
goto error;
DISPATCH[];
}
Tại thời điểm viết bài này, phiên bản "mã luồng" nhanh hơn tới 15-20% so với phiên bản "chuyển đổi" bình thường, tùy thuộc vào trình biên dịch và kiến trúc CPU.
Phần này sẽ cho chúng ta một ý tưởng về cách VM CPython đi từ hướng dẫn này sang hướng dẫn tiếp theo và những gì nó có thể làm ở giữa. Bước hợp lý tiếp theo là nghiên cứu sâu hơn về cách VM thực hiện một hướng dẫn duy nhất. CPython 3.9 có 119 mã hóa khác nhau. Tất nhiên, chúng tôi sẽ không nghiên cứu việc triển khai từng opcode trong bài đăng này. Thay vào đó, chúng tôi sẽ tập trung vào các nguyên tắc chung mà VM sử dụng để thực hiện chúng.
Giá trị ngăn xếp
Điều quan trọng nhất và may mắn thay, rất đơn giản về VM CPython là dựa trên ngăn xếp. Điều này có nghĩa là để tính toán mọi thứ, các giá trị VM POP [hoặc peek] từ ngăn xếp, thực hiện tính toán trên chúng và đẩy kết quả trở lại. Đây là một số ví dụ:
- Giá trị Opcode ____92 Pops từ ngăn xếp, phủ nhận nó và đẩy kết quả.
- Giá trị Opcode Opcode
3 từ ngăn xếp, gọicase TARGET[BINARY_ADD]: { PyObject *right = POP[]; PyObject *left = TOP[]; PyObject *sum; // ... special case of string addition sum = PyNumber_Add[left, right]; Py_DECREF[left]; Py_DECREF[right]; SET_TOP[sum]; if [sum == NULL] goto error; DISPATCH[]; }
4 trên đó và đẩy kết quả.case TARGET[BINARY_ADD]: { PyObject *right = POP[]; PyObject *left = TOP[]; PyObject *sum; // ... special case of string addition sum = PyNumber_Add[left, right]; Py_DECREF[left]; Py_DECREF[right]; SET_TOP[sum]; if [sum == NULL] goto error; DISPATCH[]; } - Giá trị Opcode Opcode
5 từ ngăn xếp, peek một giá trị khác từ trên cùng, thêm giá trị thứ nhất vào thứ hai và thay thế giá trị trên cùng với kết quả.for [;;] { // ... check if the bytecode execution must be suspended fast_next_opcode: // NEXTOPARG[] macro _Py_CODEUNIT word = *next_instr; opcode = _Py_OPCODE[word]; oparg = _Py_OPARG[word]; next_instr++; switch [opcode] { // TARGET[NOP] expands to NOP case NOP: { goto fast_next_opcode; // FAST_DISPATCH[] macro } // ... case BINARY_MULTIPLY: { // ... code for binary multiplication continue; // DISPATCH[] macro } // ... } // ... error handling }
Ngăn xếp giá trị nằm trong một đối tượng khung. Nó được thực hiện như một phần của mảng được gọi là
case TARGET[BINARY_ADD]: {
PyObject *right = POP[];
PyObject *left = TOP[];
PyObject *sum;
// ... special case of string addition
sum = PyNumber_Add[left, right];
Py_DECREF[left];
Py_DECREF[right];
SET_TOP[sum];
if [sum == NULL]
goto error;
DISPATCH[];
}
case TARGET[BINARY_ADD]: {
PyObject *right = POP[];
PyObject *left = TOP[];
PyObject *sum;
// ... special case of string addition
sum = PyNumber_Add[left, right];
Py_DECREF[left];
Py_DECREF[right];
SET_TOP[sum];
if [sum == NULL]
goto error;
DISPATCH[];
}
case TARGET[BINARY_ADD]: {
PyObject *right = POP[];
PyObject *left = TOP[];
PyObject *sum;
// ... special case of string addition
sum = PyNumber_Add[left, right];
Py_DECREF[left];
Py_DECREF[right];
SET_TOP[sum];
if [sum == NULL]
goto error;
DISPATCH[];
}
case TARGET[BINARY_ADD]: {
PyObject *right = POP[];
PyObject *left = TOP[];
PyObject *sum;
// ... special case of string addition
sum = PyNumber_Add[left, right];
Py_DECREF[left];
Py_DECREF[right];
SET_TOP[sum];
if [sum == NULL]
goto error;
DISPATCH[];
}
Xử lý lỗi và ngăn chặn ngăn chặn
Không phải tất cả các tính toán được thực hiện bởi VM đều thành công. Giả sử chúng ta cố gắng thêm một số vào một chuỗi như
// typedef struct _frame PyFrameObject; in other place
struct _frame {
PyObject_VAR_HEAD
struct _frame *f_back; /* previous frame, or NULL */
PyCodeObject *f_code; /* code segment */
PyObject *f_builtins; /* builtin symbol table [PyDictObject] */
PyObject *f_globals; /* global symbol table [PyDictObject] */
PyObject *f_locals; /* local symbol table [any mapping] */
PyObject **f_valuestack; /* points after the last local */
/* Next free slot in f_valuestack. Frame creation sets to f_valuestack.
Frame evaluation usually NULLs it, but a frame that yields sets it
to the current stack top. */
PyObject **f_stacktop;
PyObject *f_trace; /* Trace function */
char f_trace_lines; /* Emit per-line trace events? */
char f_trace_opcodes; /* Emit per-opcode trace events? */
/* Borrowed reference to a generator, or NULL */
PyObject *f_gen;
int f_lasti; /* Last instruction if called */
int f_lineno; /* Current line number */
int f_iblock; /* index in f_blockstack */
char f_executing; /* whether the frame is still executing */
PyTryBlock f_blockstack[CO_MAXBLOCKS]; /* for try and loop blocks */
PyObject *f_localsplus[1]; /* locals+stack, dynamically sized */
};
for [;;] {
// ... check if the bytecode execution must be suspended
fast_next_opcode:
// NEXTOPARG[] macro
_Py_CODEUNIT word = *next_instr;
opcode = _Py_OPCODE[word];
oparg = _Py_OPARG[word];
next_instr++;
switch [opcode] {
// TARGET[NOP] expands to NOP
case NOP: {
goto fast_next_opcode; // FAST_DISPATCH[] macro
}
// ...
case BINARY_MULTIPLY: {
// ... code for binary multiplication
continue; // DISPATCH[] macro
}
// ...
}
// ... error handling
}
// typedef struct _frame PyFrameObject; in other place
struct _frame {
PyObject_VAR_HEAD
struct _frame *f_back; /* previous frame, or NULL */
PyCodeObject *f_code; /* code segment */
PyObject *f_builtins; /* builtin symbol table [PyDictObject] */
PyObject *f_globals; /* global symbol table [PyDictObject] */
PyObject *f_locals; /* local symbol table [any mapping] */
PyObject **f_valuestack; /* points after the last local */
/* Next free slot in f_valuestack. Frame creation sets to f_valuestack.
Frame evaluation usually NULLs it, but a frame that yields sets it
to the current stack top. */
PyObject **f_stacktop;
PyObject *f_trace; /* Trace function */
char f_trace_lines; /* Emit per-line trace events? */
char f_trace_opcodes; /* Emit per-opcode trace events? */
/* Borrowed reference to a generator, or NULL */
PyObject *f_gen;
int f_lasti; /* Last instruction if called */
int f_lineno; /* Current line number */
int f_iblock; /* index in f_blockstack */
char f_executing; /* whether the frame is still executing */
PyTryBlock f_blockstack[CO_MAXBLOCKS]; /* for try and loop blocks */
PyObject *f_localsplus[1]; /* locals+stack, dynamically sized */
};
case TARGET[BINARY_ADD]: {
PyObject *right = POP[];
PyObject *left = TOP[];
PyObject *sum;
// ... special case of string addition
sum = PyNumber_Add[left, right];
Py_DECREF[left];
Py_DECREF[right];
SET_TOP[sum];
if [sum == NULL]
goto error;
DISPATCH[];
}
Điều quan trọng đối với chúng tôi bây giờ không phải là cách
// typedef struct _frame PyFrameObject; in other place
struct _frame {
PyObject_VAR_HEAD
struct _frame *f_back; /* previous frame, or NULL */
PyCodeObject *f_code; /* code segment */
PyObject *f_builtins; /* builtin symbol table [PyDictObject] */
PyObject *f_globals; /* global symbol table [PyDictObject] */
PyObject *f_locals; /* local symbol table [any mapping] */
PyObject **f_valuestack; /* points after the last local */
/* Next free slot in f_valuestack. Frame creation sets to f_valuestack.
Frame evaluation usually NULLs it, but a frame that yields sets it
to the current stack top. */
PyObject **f_stacktop;
PyObject *f_trace; /* Trace function */
char f_trace_lines; /* Emit per-line trace events? */
char f_trace_opcodes; /* Emit per-opcode trace events? */
/* Borrowed reference to a generator, or NULL */
PyObject *f_gen;
int f_lasti; /* Last instruction if called */
int f_lineno; /* Current line number */
int f_iblock; /* index in f_blockstack */
char f_executing; /* whether the frame is still executing */
PyTryBlock f_blockstack[CO_MAXBLOCKS]; /* for try and loop blocks */
PyObject *f_localsplus[1]; /* locals+stack, dynamically sized */
};
02 Trả về// typedef struct _frame PyFrameObject; in other place struct _frame { PyObject_VAR_HEAD struct _frame *f_back; /* previous frame, or NULL */ PyCodeObject *f_code; /* code segment */ PyObject *f_builtins; /* builtin symbol table [PyDictObject] */ PyObject *f_globals; /* global symbol table [PyDictObject] */ PyObject *f_locals; /* local symbol table [any mapping] */ PyObject **f_valuestack; /* points after the last local */ /* Next free slot in f_valuestack. Frame creation sets to f_valuestack. Frame evaluation usually NULLs it, but a frame that yields sets it to the current stack top. */ PyObject **f_stacktop; PyObject *f_trace; /* Trace function */ char f_trace_lines; /* Emit per-line trace events? */ char f_trace_opcodes; /* Emit per-opcode trace events? */ /* Borrowed reference to a generator, or NULL */ PyObject *f_gen; int f_lasti; /* Last instruction if called */ int f_lineno; /* Current line number */ int f_iblock; /* index in f_blockstack */ char f_executing; /* whether the frame is still executing */ PyTryBlock f_blockstack[CO_MAXBLOCKS]; /* for try and loop blocks */ PyObject *f_localsplus[1]; /* locals+stack, dynamically sized */ };
05.// typedef struct _frame PyFrameObject; in other place struct _frame { PyObject_VAR_HEAD struct _frame *f_back; /* previous frame, or NULL */ PyCodeObject *f_code; /* code segment */ PyObject *f_builtins; /* builtin symbol table [PyDictObject] */ PyObject *f_globals; /* global symbol table [PyDictObject] */ PyObject *f_locals; /* local symbol table [any mapping] */ PyObject **f_valuestack; /* points after the last local */ /* Next free slot in f_valuestack. Frame creation sets to f_valuestack. Frame evaluation usually NULLs it, but a frame that yields sets it to the current stack top. */ PyObject **f_stacktop; PyObject *f_trace; /* Trace function */ char f_trace_lines; /* Emit per-line trace events? */ char f_trace_opcodes; /* Emit per-opcode trace events? */ /* Borrowed reference to a generator, or NULL */ PyObject *f_gen; int f_lasti; /* Last instruction if called */ int f_lineno; /* Current line number */ int f_iblock; /* index in f_blockstack */ char f_executing; /* whether the frame is still executing */ PyTryBlock f_blockstack[CO_MAXBLOCKS]; /* for try and loop blocks */ PyObject *f_localsplus[1]; /* locals+stack, dynamically sized */ };
02 đặt ngoại lệ hiện tại cho ngoại lệ// typedef struct _frame PyFrameObject; in other place struct _frame { PyObject_VAR_HEAD struct _frame *f_back; /* previous frame, or NULL */ PyCodeObject *f_code; /* code segment */ PyObject *f_builtins; /* builtin symbol table [PyDictObject] */ PyObject *f_globals; /* global symbol table [PyDictObject] */ PyObject *f_locals; /* local symbol table [any mapping] */ PyObject **f_valuestack; /* points after the last local */ /* Next free slot in f_valuestack. Frame creation sets to f_valuestack. Frame evaluation usually NULLs it, but a frame that yields sets it to the current stack top. */ PyObject **f_stacktop; PyObject *f_trace; /* Trace function */ char f_trace_lines; /* Emit per-line trace events? */ char f_trace_opcodes; /* Emit per-opcode trace events? */ /* Borrowed reference to a generator, or NULL */ PyObject *f_gen; int f_lasti; /* Last instruction if called */ int f_lineno; /* Current line number */ int f_iblock; /* index in f_blockstack */ char f_executing; /* whether the frame is still executing */ PyTryBlock f_blockstack[CO_MAXBLOCKS]; /* for try and loop blocks */ PyObject *f_localsplus[1]; /* locals+stack, dynamically sized */ };
07. Điều này liên quan đến việc thiết lập// typedef struct _frame PyFrameObject; in other place struct _frame { PyObject_VAR_HEAD struct _frame *f_back; /* previous frame, or NULL */ PyCodeObject *f_code; /* code segment */ PyObject *f_builtins; /* builtin symbol table [PyDictObject] */ PyObject *f_globals; /* global symbol table [PyDictObject] */ PyObject *f_locals; /* local symbol table [any mapping] */ PyObject **f_valuestack; /* points after the last local */ /* Next free slot in f_valuestack. Frame creation sets to f_valuestack. Frame evaluation usually NULLs it, but a frame that yields sets it to the current stack top. */ PyObject **f_stacktop; PyObject *f_trace; /* Trace function */ char f_trace_lines; /* Emit per-line trace events? */ char f_trace_opcodes; /* Emit per-opcode trace events? */ /* Borrowed reference to a generator, or NULL */ PyObject *f_gen; int f_lasti; /* Last instruction if called */ int f_lineno; /* Current line number */ int f_iblock; /* index in f_blockstack */ char f_executing; /* whether the frame is still executing */ PyTryBlock f_blockstack[CO_MAXBLOCKS]; /* for try and loop blocks */ PyObject *f_localsplus[1]; /* locals+stack, dynamically sized */ };
08,// typedef struct _frame PyFrameObject; in other place struct _frame { PyObject_VAR_HEAD struct _frame *f_back; /* previous frame, or NULL */ PyCodeObject *f_code; /* code segment */ PyObject *f_builtins; /* builtin symbol table [PyDictObject] */ PyObject *f_globals; /* global symbol table [PyDictObject] */ PyObject *f_locals; /* local symbol table [any mapping] */ PyObject **f_valuestack; /* points after the last local */ /* Next free slot in f_valuestack. Frame creation sets to f_valuestack. Frame evaluation usually NULLs it, but a frame that yields sets it to the current stack top. */ PyObject **f_stacktop; PyObject *f_trace; /* Trace function */ char f_trace_lines; /* Emit per-line trace events? */ char f_trace_opcodes; /* Emit per-opcode trace events? */ /* Borrowed reference to a generator, or NULL */ PyObject *f_gen; int f_lasti; /* Last instruction if called */ int f_lineno; /* Current line number */ int f_iblock; /* index in f_blockstack */ char f_executing; /* whether the frame is still executing */ PyTryBlock f_blockstack[CO_MAXBLOCKS]; /* for try and loop blocks */ PyObject *f_localsplus[1]; /* locals+stack, dynamically sized */ };
09 và// typedef struct _frame PyFrameObject; in other place struct _frame { PyObject_VAR_HEAD struct _frame *f_back; /* previous frame, or NULL */ PyCodeObject *f_code; /* code segment */ PyObject *f_builtins; /* builtin symbol table [PyDictObject] */ PyObject *f_globals; /* global symbol table [PyDictObject] */ PyObject *f_locals; /* local symbol table [any mapping] */ PyObject **f_valuestack; /* points after the last local */ /* Next free slot in f_valuestack. Frame creation sets to f_valuestack. Frame evaluation usually NULLs it, but a frame that yields sets it to the current stack top. */ PyObject **f_stacktop; PyObject *f_trace; /* Trace function */ char f_trace_lines; /* Emit per-line trace events? */ char f_trace_opcodes; /* Emit per-opcode trace events? */ /* Borrowed reference to a generator, or NULL */ PyObject *f_gen; int f_lasti; /* Last instruction if called */ int f_lineno; /* Current line number */ int f_iblock; /* index in f_blockstack */ char f_executing; /* whether the frame is still executing */ PyTryBlock f_blockstack[CO_MAXBLOCKS]; /* for try and loop blocks */ PyObject *f_localsplus[1]; /* locals+stack, dynamically sized */ };
10.// typedef struct _frame PyFrameObject; in other place struct _frame { PyObject_VAR_HEAD struct _frame *f_back; /* previous frame, or NULL */ PyCodeObject *f_code; /* code segment */ PyObject *f_builtins; /* builtin symbol table [PyDictObject] */ PyObject *f_globals; /* global symbol table [PyDictObject] */ PyObject *f_locals; /* local symbol table [any mapping] */ PyObject **f_valuestack; /* points after the last local */ /* Next free slot in f_valuestack. Frame creation sets to f_valuestack. Frame evaluation usually NULLs it, but a frame that yields sets it to the current stack top. */ PyObject **f_stacktop; PyObject *f_trace; /* Trace function */ char f_trace_lines; /* Emit per-line trace events? */ char f_trace_opcodes; /* Emit per-opcode trace events? */ /* Borrowed reference to a generator, or NULL */ PyObject *f_gen; int f_lasti; /* Last instruction if called */ int f_lineno; /* Current line number */ int f_iblock; /* index in f_blockstack */ char f_executing; /* whether the frame is still executing */ PyTryBlock f_blockstack[CO_MAXBLOCKS]; /* for try and loop blocks */ PyObject *f_localsplus[1]; /* locals+stack, dynamically sized */ };
// typedef struct _frame PyFrameObject; in other place
struct _frame {
PyObject_VAR_HEAD
struct _frame *f_back; /* previous frame, or NULL */
PyCodeObject *f_code; /* code segment */
PyObject *f_builtins; /* builtin symbol table [PyDictObject] */
PyObject *f_globals; /* global symbol table [PyDictObject] */
PyObject *f_locals; /* local symbol table [any mapping] */
PyObject **f_valuestack; /* points after the last local */
/* Next free slot in f_valuestack. Frame creation sets to f_valuestack.
Frame evaluation usually NULLs it, but a frame that yields sets it
to the current stack top. */
PyObject **f_stacktop;
PyObject *f_trace; /* Trace function */
char f_trace_lines; /* Emit per-line trace events? */
char f_trace_opcodes; /* Emit per-opcode trace events? */
/* Borrowed reference to a generator, or NULL */
PyObject *f_gen;
int f_lasti; /* Last instruction if called */
int f_lineno; /* Current line number */
int f_iblock; /* index in f_blockstack */
char f_executing; /* whether the frame is still executing */
PyTryBlock f_blockstack[CO_MAXBLOCKS]; /* for try and loop blocks */
PyObject *f_localsplus[1]; /* locals+stack, dynamically sized */
};
// typedef struct _frame PyFrameObject; in other place
struct _frame {
PyObject_VAR_HEAD
struct _frame *f_back; /* previous frame, or NULL */
PyCodeObject *f_code; /* code segment */
PyObject *f_builtins; /* builtin symbol table [PyDictObject] */
PyObject *f_globals; /* global symbol table [PyDictObject] */
PyObject *f_locals; /* local symbol table [any mapping] */
PyObject **f_valuestack; /* points after the last local */
/* Next free slot in f_valuestack. Frame creation sets to f_valuestack.
Frame evaluation usually NULLs it, but a frame that yields sets it
to the current stack top. */
PyObject **f_stacktop;
PyObject *f_trace; /* Trace function */
char f_trace_lines; /* Emit per-line trace events? */
char f_trace_opcodes; /* Emit per-opcode trace events? */
/* Borrowed reference to a generator, or NULL */
PyObject *f_gen;
int f_lasti; /* Last instruction if called */
int f_lineno; /* Current line number */
int f_iblock; /* index in f_blockstack */
char f_executing; /* whether the frame is still executing */
PyTryBlock f_blockstack[CO_MAXBLOCKS]; /* for try and loop blocks */
PyObject *f_localsplus[1]; /* locals+stack, dynamically sized */
};
// typedef struct _frame PyFrameObject; in other place
struct _frame {
PyObject_VAR_HEAD
struct _frame *f_back; /* previous frame, or NULL */
PyCodeObject *f_code; /* code segment */
PyObject *f_builtins; /* builtin symbol table [PyDictObject] */
PyObject *f_globals; /* global symbol table [PyDictObject] */
PyObject *f_locals; /* local symbol table [any mapping] */
PyObject **f_valuestack; /* points after the last local */
/* Next free slot in f_valuestack. Frame creation sets to f_valuestack.
Frame evaluation usually NULLs it, but a frame that yields sets it
to the current stack top. */
PyObject **f_stacktop;
PyObject *f_trace; /* Trace function */
char f_trace_lines; /* Emit per-line trace events? */
char f_trace_opcodes; /* Emit per-opcode trace events? */
/* Borrowed reference to a generator, or NULL */
PyObject *f_gen;
int f_lasti; /* Last instruction if called */
int f_lineno; /* Current line number */
int f_iblock; /* index in f_blockstack */
char f_executing; /* whether the frame is still executing */
PyTryBlock f_blockstack[CO_MAXBLOCKS]; /* for try and loop blocks */
PyObject *f_localsplus[1]; /* locals+stack, dynamically sized */
};
// typedef struct _frame PyFrameObject; in other place
struct _frame {
PyObject_VAR_HEAD
struct _frame *f_back; /* previous frame, or NULL */
PyCodeObject *f_code; /* code segment */
PyObject *f_builtins; /* builtin symbol table [PyDictObject] */
PyObject *f_globals; /* global symbol table [PyDictObject] */
PyObject *f_locals; /* local symbol table [any mapping] */
PyObject **f_valuestack; /* points after the last local */
/* Next free slot in f_valuestack. Frame creation sets to f_valuestack.
Frame evaluation usually NULLs it, but a frame that yields sets it
to the current stack top. */
PyObject **f_stacktop;
PyObject *f_trace; /* Trace function */
char f_trace_lines; /* Emit per-line trace events? */
char f_trace_opcodes; /* Emit per-opcode trace events? */
/* Borrowed reference to a generator, or NULL */
PyObject *f_gen;
int f_lasti; /* Last instruction if called */
int f_lineno; /* Current line number */
int f_iblock; /* index in f_blockstack */
char f_executing; /* whether the frame is still executing */
PyTryBlock f_blockstack[CO_MAXBLOCKS]; /* for try and loop blocks */
PyObject *f_localsplus[1]; /* locals+stack, dynamically sized */
};
// typedef struct _frame PyFrameObject; in other place
struct _frame {
PyObject_VAR_HEAD
struct _frame *f_back; /* previous frame, or NULL */
PyCodeObject *f_code; /* code segment */
PyObject *f_builtins; /* builtin symbol table [PyDictObject] */
PyObject *f_globals; /* global symbol table [PyDictObject] */
PyObject *f_locals; /* local symbol table [any mapping] */
PyObject **f_valuestack; /* points after the last local */
/* Next free slot in f_valuestack. Frame creation sets to f_valuestack.
Frame evaluation usually NULLs it, but a frame that yields sets it
to the current stack top. */
PyObject **f_stacktop;
PyObject *f_trace; /* Trace function */
char f_trace_lines; /* Emit per-line trace events? */
char f_trace_opcodes; /* Emit per-opcode trace events? */
/* Borrowed reference to a generator, or NULL */
PyObject *f_gen;
int f_lasti; /* Last instruction if called */
int f_lineno; /* Current line number */
int f_iblock; /* index in f_blockstack */
char f_executing; /* whether the frame is still executing */
PyTryBlock f_blockstack[CO_MAXBLOCKS]; /* for try and loop blocks */
PyObject *f_localsplus[1]; /* locals+stack, dynamically sized */
};
Nhưng giả sử rằng chúng ta đặt cùng một mã bên trong mệnh đề
// typedef struct _frame PyFrameObject; in other place
struct _frame {
PyObject_VAR_HEAD
struct _frame *f_back; /* previous frame, or NULL */
PyCodeObject *f_code; /* code segment */
PyObject *f_builtins; /* builtin symbol table [PyDictObject] */
PyObject *f_globals; /* global symbol table [PyDictObject] */
PyObject *f_locals; /* local symbol table [any mapping] */
PyObject **f_valuestack; /* points after the last local */
/* Next free slot in f_valuestack. Frame creation sets to f_valuestack.
Frame evaluation usually NULLs it, but a frame that yields sets it
to the current stack top. */
PyObject **f_stacktop;
PyObject *f_trace; /* Trace function */
char f_trace_lines; /* Emit per-line trace events? */
char f_trace_opcodes; /* Emit per-opcode trace events? */
/* Borrowed reference to a generator, or NULL */
PyObject *f_gen;
int f_lasti; /* Last instruction if called */
int f_lineno; /* Current line number */
int f_iblock; /* index in f_blockstack */
char f_executing; /* whether the frame is still executing */
PyTryBlock f_blockstack[CO_MAXBLOCKS]; /* for try and loop blocks */
PyObject *f_localsplus[1]; /* locals+stack, dynamically sized */
};
// typedef struct _frame PyFrameObject; in other place
struct _frame {
PyObject_VAR_HEAD
struct _frame *f_back; /* previous frame, or NULL */
PyCodeObject *f_code; /* code segment */
PyObject *f_builtins; /* builtin symbol table [PyDictObject] */
PyObject *f_globals; /* global symbol table [PyDictObject] */
PyObject *f_locals; /* local symbol table [any mapping] */
PyObject **f_valuestack; /* points after the last local */
/* Next free slot in f_valuestack. Frame creation sets to f_valuestack.
Frame evaluation usually NULLs it, but a frame that yields sets it
to the current stack top. */
PyObject **f_stacktop;
PyObject *f_trace; /* Trace function */
char f_trace_lines; /* Emit per-line trace events? */
char f_trace_opcodes; /* Emit per-opcode trace events? */
/* Borrowed reference to a generator, or NULL */
PyObject *f_gen;
int f_lasti; /* Last instruction if called */
int f_lineno; /* Current line number */
int f_iblock; /* index in f_blockstack */
char f_executing; /* whether the frame is still executing */
PyTryBlock f_blockstack[CO_MAXBLOCKS]; /* for try and loop blocks */
PyObject *f_localsplus[1]; /* locals+stack, dynamically sized */
};
// typedef struct _frame PyFrameObject; in other place
struct _frame {
PyObject_VAR_HEAD
struct _frame *f_back; /* previous frame, or NULL */
PyCodeObject *f_code; /* code segment */
PyObject *f_builtins; /* builtin symbol table [PyDictObject] */
PyObject *f_globals; /* global symbol table [PyDictObject] */
PyObject *f_locals; /* local symbol table [any mapping] */
PyObject **f_valuestack; /* points after the last local */
/* Next free slot in f_valuestack. Frame creation sets to f_valuestack.
Frame evaluation usually NULLs it, but a frame that yields sets it
to the current stack top. */
PyObject **f_stacktop;
PyObject *f_trace; /* Trace function */
char f_trace_lines; /* Emit per-line trace events? */
char f_trace_opcodes; /* Emit per-opcode trace events? */
/* Borrowed reference to a generator, or NULL */
PyObject *f_gen;
int f_lasti; /* Last instruction if called */
int f_lineno; /* Current line number */
int f_iblock; /* index in f_blockstack */
char f_executing; /* whether the frame is still executing */
PyTryBlock f_blockstack[CO_MAXBLOCKS]; /* for try and loop blocks */
PyObject *f_localsplus[1]; /* locals+stack, dynamically sized */
};
// typedef struct _frame PyFrameObject; in other place
struct _frame {
PyObject_VAR_HEAD
struct _frame *f_back; /* previous frame, or NULL */
PyCodeObject *f_code; /* code segment */
PyObject *f_builtins; /* builtin symbol table [PyDictObject] */
PyObject *f_globals; /* global symbol table [PyDictObject] */
PyObject *f_locals; /* local symbol table [any mapping] */
PyObject **f_valuestack; /* points after the last local */
/* Next free slot in f_valuestack. Frame creation sets to f_valuestack.
Frame evaluation usually NULLs it, but a frame that yields sets it
to the current stack top. */
PyObject **f_stacktop;
PyObject *f_trace; /* Trace function */
char f_trace_lines; /* Emit per-line trace events? */
char f_trace_opcodes; /* Emit per-opcode trace events? */
/* Borrowed reference to a generator, or NULL */
PyObject *f_gen;
int f_lasti; /* Last instruction if called */
int f_lineno; /* Current line number */
int f_iblock; /* index in f_blockstack */
char f_executing; /* whether the frame is still executing */
PyTryBlock f_blockstack[CO_MAXBLOCKS]; /* for try and loop blocks */
PyObject *f_localsplus[1]; /* locals+stack, dynamically sized */
};
Làm thế nào VM có thể tiếp tục thực thi sau khi lỗi đã xảy ra? Chúng ta hãy xem mã byte được tạo bởi trình biên dịch cho câu lệnh
// typedef struct _frame PyFrameObject; in other place
struct _frame {
PyObject_VAR_HEAD
struct _frame *f_back; /* previous frame, or NULL */
PyCodeObject *f_code; /* code segment */
PyObject *f_builtins; /* builtin symbol table [PyDictObject] */
PyObject *f_globals; /* global symbol table [PyDictObject] */
PyObject *f_locals; /* local symbol table [any mapping] */
PyObject **f_valuestack; /* points after the last local */
/* Next free slot in f_valuestack. Frame creation sets to f_valuestack.
Frame evaluation usually NULLs it, but a frame that yields sets it
to the current stack top. */
PyObject **f_stacktop;
PyObject *f_trace; /* Trace function */
char f_trace_lines; /* Emit per-line trace events? */
char f_trace_opcodes; /* Emit per-opcode trace events? */
/* Borrowed reference to a generator, or NULL */
PyObject *f_gen;
int f_lasti; /* Last instruction if called */
int f_lineno; /* Current line number */
int f_iblock; /* index in f_blockstack */
char f_executing; /* whether the frame is still executing */
PyTryBlock f_blockstack[CO_MAXBLOCKS]; /* for try and loop blocks */
PyObject *f_localsplus[1]; /* locals+stack, dynamically sized */
};
// typedef struct _frame PyFrameObject; in other place
struct _frame {
PyObject_VAR_HEAD
struct _frame *f_back; /* previous frame, or NULL */
PyCodeObject *f_code; /* code segment */
PyObject *f_builtins; /* builtin symbol table [PyDictObject] */
PyObject *f_globals; /* global symbol table [PyDictObject] */
PyObject *f_locals; /* local symbol table [any mapping] */
PyObject **f_valuestack; /* points after the last local */
/* Next free slot in f_valuestack. Frame creation sets to f_valuestack.
Frame evaluation usually NULLs it, but a frame that yields sets it
to the current stack top. */
PyObject **f_stacktop;
PyObject *f_trace; /* Trace function */
char f_trace_lines; /* Emit per-line trace events? */
char f_trace_opcodes; /* Emit per-opcode trace events? */
/* Borrowed reference to a generator, or NULL */
PyObject *f_gen;
int f_lasti; /* Last instruction if called */
int f_lineno; /* Current line number */
int f_iblock; /* index in f_blockstack */
char f_executing; /* whether the frame is still executing */
PyTryBlock f_blockstack[CO_MAXBLOCKS]; /* for try and loop blocks */
PyObject *f_localsplus[1]; /* locals+stack, dynamically sized */
};
Lưu ý các mã hóa
// typedef struct _frame PyFrameObject; in other place
struct _frame {
PyObject_VAR_HEAD
struct _frame *f_back; /* previous frame, or NULL */
PyCodeObject *f_code; /* code segment */
PyObject *f_builtins; /* builtin symbol table [PyDictObject] */
PyObject *f_globals; /* global symbol table [PyDictObject] */
PyObject *f_locals; /* local symbol table [any mapping] */
PyObject **f_valuestack; /* points after the last local */
/* Next free slot in f_valuestack. Frame creation sets to f_valuestack.
Frame evaluation usually NULLs it, but a frame that yields sets it
to the current stack top. */
PyObject **f_stacktop;
PyObject *f_trace; /* Trace function */
char f_trace_lines; /* Emit per-line trace events? */
char f_trace_opcodes; /* Emit per-opcode trace events? */
/* Borrowed reference to a generator, or NULL */
PyObject *f_gen;
int f_lasti; /* Last instruction if called */
int f_lineno; /* Current line number */
int f_iblock; /* index in f_blockstack */
char f_executing; /* whether the frame is still executing */
PyTryBlock f_blockstack[CO_MAXBLOCKS]; /* for try and loop blocks */
PyObject *f_localsplus[1]; /* locals+stack, dynamically sized */
};
// typedef struct _frame PyFrameObject; in other place
struct _frame {
PyObject_VAR_HEAD
struct _frame *f_back; /* previous frame, or NULL */
PyCodeObject *f_code; /* code segment */
PyObject *f_builtins; /* builtin symbol table [PyDictObject] */
PyObject *f_globals; /* global symbol table [PyDictObject] */
PyObject *f_locals; /* local symbol table [any mapping] */
PyObject **f_valuestack; /* points after the last local */
/* Next free slot in f_valuestack. Frame creation sets to f_valuestack.
Frame evaluation usually NULLs it, but a frame that yields sets it
to the current stack top. */
PyObject **f_stacktop;
PyObject *f_trace; /* Trace function */
char f_trace_lines; /* Emit per-line trace events? */
char f_trace_opcodes; /* Emit per-opcode trace events? */
/* Borrowed reference to a generator, or NULL */
PyObject *f_gen;
int f_lasti; /* Last instruction if called */
int f_lineno; /* Current line number */
int f_iblock; /* index in f_blockstack */
char f_executing; /* whether the frame is still executing */
PyTryBlock f_blockstack[CO_MAXBLOCKS]; /* for try and loop blocks */
PyObject *f_localsplus[1]; /* locals+stack, dynamically sized */
};
// typedef struct _frame PyFrameObject; in other place
struct _frame {
PyObject_VAR_HEAD
struct _frame *f_back; /* previous frame, or NULL */
PyCodeObject *f_code; /* code segment */
PyObject *f_builtins; /* builtin symbol table [PyDictObject] */
PyObject *f_globals; /* global symbol table [PyDictObject] */
PyObject *f_locals; /* local symbol table [any mapping] */
PyObject **f_valuestack; /* points after the last local */
/* Next free slot in f_valuestack. Frame creation sets to f_valuestack.
Frame evaluation usually NULLs it, but a frame that yields sets it
to the current stack top. */
PyObject **f_stacktop;
PyObject *f_trace; /* Trace function */
char f_trace_lines; /* Emit per-line trace events? */
char f_trace_opcodes; /* Emit per-opcode trace events? */
/* Borrowed reference to a generator, or NULL */
PyObject *f_gen;
int f_lasti; /* Last instruction if called */
int f_lineno; /* Current line number */
int f_iblock; /* index in f_blockstack */
char f_executing; /* whether the frame is still executing */
PyTryBlock f_blockstack[CO_MAXBLOCKS]; /* for try and loop blocks */
PyObject *f_localsplus[1]; /* locals+stack, dynamically sized */
};
// typedef struct _frame PyFrameObject; in other place
struct _frame {
PyObject_VAR_HEAD
struct _frame *f_back; /* previous frame, or NULL */
PyCodeObject *f_code; /* code segment */
PyObject *f_builtins; /* builtin symbol table [PyDictObject] */
PyObject *f_globals; /* global symbol table [PyDictObject] */
PyObject *f_locals; /* local symbol table [any mapping] */
PyObject **f_valuestack; /* points after the last local */
/* Next free slot in f_valuestack. Frame creation sets to f_valuestack.
Frame evaluation usually NULLs it, but a frame that yields sets it
to the current stack top. */
PyObject **f_stacktop;
PyObject *f_trace; /* Trace function */
char f_trace_lines; /* Emit per-line trace events? */
char f_trace_opcodes; /* Emit per-opcode trace events? */
/* Borrowed reference to a generator, or NULL */
PyObject *f_gen;
int f_lasti; /* Last instruction if called */
int f_lineno; /* Current line number */
int f_iblock; /* index in f_blockstack */
char f_executing; /* whether the frame is still executing */
PyTryBlock f_blockstack[CO_MAXBLOCKS]; /* for try and loop blocks */
PyObject *f_localsplus[1]; /* locals+stack, dynamically sized */
};
// typedef struct _frame PyFrameObject; in other place
struct _frame {
PyObject_VAR_HEAD
struct _frame *f_back; /* previous frame, or NULL */
PyCodeObject *f_code; /* code segment */
PyObject *f_builtins; /* builtin symbol table [PyDictObject] */
PyObject *f_globals; /* global symbol table [PyDictObject] */
PyObject *f_locals; /* local symbol table [any mapping] */
PyObject **f_valuestack; /* points after the last local */
/* Next free slot in f_valuestack. Frame creation sets to f_valuestack.
Frame evaluation usually NULLs it, but a frame that yields sets it
to the current stack top. */
PyObject **f_stacktop;
PyObject *f_trace; /* Trace function */
char f_trace_lines; /* Emit per-line trace events? */
char f_trace_opcodes; /* Emit per-opcode trace events? */
/* Borrowed reference to a generator, or NULL */
PyObject *f_gen;
int f_lasti; /* Last instruction if called */
int f_lineno; /* Current line number */
int f_iblock; /* index in f_blockstack */
char f_executing; /* whether the frame is still executing */
PyTryBlock f_blockstack[CO_MAXBLOCKS]; /* for try and loop blocks */
PyObject *f_localsplus[1]; /* locals+stack, dynamically sized */
};
// typedef struct _frame PyFrameObject; in other place
struct _frame {
PyObject_VAR_HEAD
struct _frame *f_back; /* previous frame, or NULL */
PyCodeObject *f_code; /* code segment */
PyObject *f_builtins; /* builtin symbol table [PyDictObject] */
PyObject *f_globals; /* global symbol table [PyDictObject] */
PyObject *f_locals; /* local symbol table [any mapping] */
PyObject **f_valuestack; /* points after the last local */
/* Next free slot in f_valuestack. Frame creation sets to f_valuestack.
Frame evaluation usually NULLs it, but a frame that yields sets it
to the current stack top. */
PyObject **f_stacktop;
PyObject *f_trace; /* Trace function */
char f_trace_lines; /* Emit per-line trace events? */
char f_trace_opcodes; /* Emit per-opcode trace events? */
/* Borrowed reference to a generator, or NULL */
PyObject *f_gen;
int f_lasti; /* Last instruction if called */
int f_lineno; /* Current line number */
int f_iblock; /* index in f_blockstack */
char f_executing; /* whether the frame is still executing */
PyTryBlock f_blockstack[CO_MAXBLOCKS]; /* for try and loop blocks */
PyObject *f_localsplus[1]; /* locals+stack, dynamically sized */
};
// typedef struct _frame PyFrameObject; in other place
struct _frame {
PyObject_VAR_HEAD
struct _frame *f_back; /* previous frame, or NULL */
PyCodeObject *f_code; /* code segment */
PyObject *f_builtins; /* builtin symbol table [PyDictObject] */
PyObject *f_globals; /* global symbol table [PyDictObject] */
PyObject *f_locals; /* local symbol table [any mapping] */
PyObject **f_valuestack; /* points after the last local */
/* Next free slot in f_valuestack. Frame creation sets to f_valuestack.
Frame evaluation usually NULLs it, but a frame that yields sets it
to the current stack top. */
PyObject **f_stacktop;
PyObject *f_trace; /* Trace function */
char f_trace_lines; /* Emit per-line trace events? */
char f_trace_opcodes; /* Emit per-opcode trace events? */
/* Borrowed reference to a generator, or NULL */
PyObject *f_gen;
int f_lasti; /* Last instruction if called */
int f_lineno; /* Current line number */
int f_iblock; /* index in f_blockstack */
char f_executing; /* whether the frame is still executing */
PyTryBlock f_blockstack[CO_MAXBLOCKS]; /* for try and loop blocks */
PyObject *f_localsplus[1]; /* locals+stack, dynamically sized */
};
Một trình xử lý ngoại lệ được triển khai dưới dạng cấu trúc C đơn giản được gọi là khối:
// typedef struct _frame PyFrameObject; in other place
struct _frame {
PyObject_VAR_HEAD
struct _frame *f_back; /* previous frame, or NULL */
PyCodeObject *f_code; /* code segment */
PyObject *f_builtins; /* builtin symbol table [PyDictObject] */
PyObject *f_globals; /* global symbol table [PyDictObject] */
PyObject *f_locals; /* local symbol table [any mapping] */
PyObject **f_valuestack; /* points after the last local */
/* Next free slot in f_valuestack. Frame creation sets to f_valuestack.
Frame evaluation usually NULLs it, but a frame that yields sets it
to the current stack top. */
PyObject **f_stacktop;
PyObject *f_trace; /* Trace function */
char f_trace_lines; /* Emit per-line trace events? */
char f_trace_opcodes; /* Emit per-opcode trace events? */
/* Borrowed reference to a generator, or NULL */
PyObject *f_gen;
int f_lasti; /* Last instruction if called */
int f_lineno; /* Current line number */
int f_iblock; /* index in f_blockstack */
char f_executing; /* whether the frame is still executing */
PyTryBlock f_blockstack[CO_MAXBLOCKS]; /* for try and loop blocks */
PyObject *f_localsplus[1]; /* locals+stack, dynamically sized */
};
VM giữ các khối trong ngăn xếp khối. Để thiết lập một trình xử lý ngoại lệ có nghĩa là đẩy một khối mới vào ngăn xếp khối. Đây là những gì opcodes như
// typedef struct _frame PyFrameObject; in other place
struct _frame {
PyObject_VAR_HEAD
struct _frame *f_back; /* previous frame, or NULL */
PyCodeObject *f_code; /* code segment */
PyObject *f_builtins; /* builtin symbol table [PyDictObject] */
PyObject *f_globals; /* global symbol table [PyDictObject] */
PyObject *f_locals; /* local symbol table [any mapping] */
PyObject **f_valuestack; /* points after the last local */
/* Next free slot in f_valuestack. Frame creation sets to f_valuestack.
Frame evaluation usually NULLs it, but a frame that yields sets it
to the current stack top. */
PyObject **f_stacktop;
PyObject *f_trace; /* Trace function */
char f_trace_lines; /* Emit per-line trace events? */
char f_trace_opcodes; /* Emit per-opcode trace events? */
/* Borrowed reference to a generator, or NULL */
PyObject *f_gen;
int f_lasti; /* Last instruction if called */
int f_lineno; /* Current line number */
int f_iblock; /* index in f_blockstack */
char f_executing; /* whether the frame is still executing */
PyTryBlock f_blockstack[CO_MAXBLOCKS]; /* for try and loop blocks */
PyObject *f_localsplus[1]; /* locals+stack, dynamically sized */
};
// typedef struct _frame PyFrameObject; in other place
struct _frame {
PyObject_VAR_HEAD
struct _frame *f_back; /* previous frame, or NULL */
PyCodeObject *f_code; /* code segment */
PyObject *f_builtins; /* builtin symbol table [PyDictObject] */
PyObject *f_globals; /* global symbol table [PyDictObject] */
PyObject *f_locals; /* local symbol table [any mapping] */
PyObject **f_valuestack; /* points after the last local */
/* Next free slot in f_valuestack. Frame creation sets to f_valuestack.
Frame evaluation usually NULLs it, but a frame that yields sets it
to the current stack top. */
PyObject **f_stacktop;
PyObject *f_trace; /* Trace function */
char f_trace_lines; /* Emit per-line trace events? */
char f_trace_opcodes; /* Emit per-opcode trace events? */
/* Borrowed reference to a generator, or NULL */
PyObject *f_gen;
int f_lasti; /* Last instruction if called */
int f_lineno; /* Current line number */
int f_iblock; /* index in f_blockstack */
char f_executing; /* whether the frame is still executing */
PyTryBlock f_blockstack[CO_MAXBLOCKS]; /* for try and loop blocks */
PyObject *f_localsplus[1]; /* locals+stack, dynamically sized */
};
// typedef struct _frame PyFrameObject; in other place
struct _frame {
PyObject_VAR_HEAD
struct _frame *f_back; /* previous frame, or NULL */
PyCodeObject *f_code; /* code segment */
PyObject *f_builtins; /* builtin symbol table [PyDictObject] */
PyObject *f_globals; /* global symbol table [PyDictObject] */
PyObject *f_locals; /* local symbol table [any mapping] */
PyObject **f_valuestack; /* points after the last local */
/* Next free slot in f_valuestack. Frame creation sets to f_valuestack.
Frame evaluation usually NULLs it, but a frame that yields sets it
to the current stack top. */
PyObject **f_stacktop;
PyObject *f_trace; /* Trace function */
char f_trace_lines; /* Emit per-line trace events? */
char f_trace_opcodes; /* Emit per-opcode trace events? */
/* Borrowed reference to a generator, or NULL */
PyObject *f_gen;
int f_lasti; /* Last instruction if called */
int f_lineno; /* Current line number */
int f_iblock; /* index in f_blockstack */
char f_executing; /* whether the frame is still executing */
PyTryBlock f_blockstack[CO_MAXBLOCKS]; /* for try and loop blocks */
PyObject *f_localsplus[1]; /* locals+stack, dynamically sized */
};
// typedef struct _frame PyFrameObject; in other place
struct _frame {
PyObject_VAR_HEAD
struct _frame *f_back; /* previous frame, or NULL */
PyCodeObject *f_code; /* code segment */
PyObject *f_builtins; /* builtin symbol table [PyDictObject] */
PyObject *f_globals; /* global symbol table [PyDictObject] */
PyObject *f_locals; /* local symbol table [any mapping] */
PyObject **f_valuestack; /* points after the last local */
/* Next free slot in f_valuestack. Frame creation sets to f_valuestack.
Frame evaluation usually NULLs it, but a frame that yields sets it
to the current stack top. */
PyObject **f_stacktop;
PyObject *f_trace; /* Trace function */
char f_trace_lines; /* Emit per-line trace events? */
char f_trace_opcodes; /* Emit per-opcode trace events? */
/* Borrowed reference to a generator, or NULL */
PyObject *f_gen;
int f_lasti; /* Last instruction if called */
int f_lineno; /* Current line number */
int f_iblock; /* index in f_blockstack */
char f_executing; /* whether the frame is still executing */
PyTryBlock f_blockstack[CO_MAXBLOCKS]; /* for try and loop blocks */
PyObject *f_localsplus[1]; /* locals+stack, dynamically sized */
};
// typedef struct _frame PyFrameObject; in other place
struct _frame {
PyObject_VAR_HEAD
struct _frame *f_back; /* previous frame, or NULL */
PyCodeObject *f_code; /* code segment */
PyObject *f_builtins; /* builtin symbol table [PyDictObject] */
PyObject *f_globals; /* global symbol table [PyDictObject] */
PyObject *f_locals; /* local symbol table [any mapping] */
PyObject **f_valuestack; /* points after the last local */
/* Next free slot in f_valuestack. Frame creation sets to f_valuestack.
Frame evaluation usually NULLs it, but a frame that yields sets it
to the current stack top. */
PyObject **f_stacktop;
PyObject *f_trace; /* Trace function */
char f_trace_lines; /* Emit per-line trace events? */
char f_trace_opcodes; /* Emit per-opcode trace events? */
/* Borrowed reference to a generator, or NULL */
PyObject *f_gen;
int f_lasti; /* Last instruction if called */
int f_lineno; /* Current line number */
int f_iblock; /* index in f_blockstack */
char f_executing; /* whether the frame is still executing */
PyTryBlock f_blockstack[CO_MAXBLOCKS]; /* for try and loop blocks */
PyObject *f_localsplus[1]; /* locals+stack, dynamically sized */
};
// typedef struct _frame PyFrameObject; in other place
struct _frame {
PyObject_VAR_HEAD
struct _frame *f_back; /* previous frame, or NULL */
PyCodeObject *f_code; /* code segment */
PyObject *f_builtins; /* builtin symbol table [PyDictObject] */
PyObject *f_globals; /* global symbol table [PyDictObject] */
PyObject *f_locals; /* local symbol table [any mapping] */
PyObject **f_valuestack; /* points after the last local */
/* Next free slot in f_valuestack. Frame creation sets to f_valuestack.
Frame evaluation usually NULLs it, but a frame that yields sets it
to the current stack top. */
PyObject **f_stacktop;
PyObject *f_trace; /* Trace function */
char f_trace_lines; /* Emit per-line trace events? */
char f_trace_opcodes; /* Emit per-opcode trace events? */
/* Borrowed reference to a generator, or NULL */
PyObject *f_gen;
int f_lasti; /* Last instruction if called */
int f_lineno; /* Current line number */
int f_iblock; /* index in f_blockstack */
char f_executing; /* whether the frame is still executing */
PyTryBlock f_blockstack[CO_MAXBLOCKS]; /* for try and loop blocks */
PyObject *f_localsplus[1]; /* locals+stack, dynamically sized */
};
// typedef struct _frame PyFrameObject; in other place
struct _frame {
PyObject_VAR_HEAD
struct _frame *f_back; /* previous frame, or NULL */
PyCodeObject *f_code; /* code segment */
PyObject *f_builtins; /* builtin symbol table [PyDictObject] */
PyObject *f_globals; /* global symbol table [PyDictObject] */
PyObject *f_locals; /* local symbol table [any mapping] */
PyObject **f_valuestack; /* points after the last local */
/* Next free slot in f_valuestack. Frame creation sets to f_valuestack.
Frame evaluation usually NULLs it, but a frame that yields sets it
to the current stack top. */
PyObject **f_stacktop;
PyObject *f_trace; /* Trace function */
char f_trace_lines; /* Emit per-line trace events? */
char f_trace_opcodes; /* Emit per-opcode trace events? */
/* Borrowed reference to a generator, or NULL */
PyObject *f_gen;
int f_lasti; /* Last instruction if called */
int f_lineno; /* Current line number */
int f_iblock; /* index in f_blockstack */
char f_executing; /* whether the frame is still executing */
PyTryBlock f_blockstack[CO_MAXBLOCKS]; /* for try and loop blocks */
PyObject *f_localsplus[1]; /* locals+stack, dynamically sized */
};
// typedef struct _frame PyFrameObject; in other place
struct _frame {
PyObject_VAR_HEAD
struct _frame *f_back; /* previous frame, or NULL */
PyCodeObject *f_code; /* code segment */
PyObject *f_builtins; /* builtin symbol table [PyDictObject] */
PyObject *f_globals; /* global symbol table [PyDictObject] */
PyObject *f_locals; /* local symbol table [any mapping] */
PyObject **f_valuestack; /* points after the last local */
/* Next free slot in f_valuestack. Frame creation sets to f_valuestack.
Frame evaluation usually NULLs it, but a frame that yields sets it
to the current stack top. */
PyObject **f_stacktop;
PyObject *f_trace; /* Trace function */
char f_trace_lines; /* Emit per-line trace events? */
char f_trace_opcodes; /* Emit per-opcode trace events? */
/* Borrowed reference to a generator, or NULL */
PyObject *f_gen;
int f_lasti; /* Last instruction if called */
int f_lineno; /* Current line number */
int f_iblock; /* index in f_blockstack */
char f_executing; /* whether the frame is still executing */
PyTryBlock f_blockstack[CO_MAXBLOCKS]; /* for try and loop blocks */
PyObject *f_localsplus[1]; /* locals+stack, dynamically sized */
};
Có một điều nữa để nói về xử lý ngoại lệ. Hãy nghĩ về những gì xảy ra khi xảy ra lỗi trong khi VM xử lý một ngoại lệ:
// typedef struct _frame PyFrameObject; in other place
struct _frame {
PyObject_VAR_HEAD
struct _frame *f_back; /* previous frame, or NULL */
PyCodeObject *f_code; /* code segment */
PyObject *f_builtins; /* builtin symbol table [PyDictObject] */
PyObject *f_globals; /* global symbol table [PyDictObject] */
PyObject *f_locals; /* local symbol table [any mapping] */
PyObject **f_valuestack; /* points after the last local */
/* Next free slot in f_valuestack. Frame creation sets to f_valuestack.
Frame evaluation usually NULLs it, but a frame that yields sets it
to the current stack top. */
PyObject **f_stacktop;
PyObject *f_trace; /* Trace function */
char f_trace_lines; /* Emit per-line trace events? */
char f_trace_opcodes; /* Emit per-opcode trace events? */
/* Borrowed reference to a generator, or NULL */
PyObject *f_gen;
int f_lasti; /* Last instruction if called */
int f_lineno; /* Current line number */
int f_iblock; /* index in f_blockstack */
char f_executing; /* whether the frame is still executing */
PyTryBlock f_blockstack[CO_MAXBLOCKS]; /* for try and loop blocks */
PyObject *f_localsplus[1]; /* locals+stack, dynamically sized */
};
Đúng như dự đoán, Cpython in ngoại lệ ban đầu. Để thực hiện hành vi đó, khi CPython xử lý một ngoại lệ bằng cách sử dụng khối
// typedef struct _frame PyFrameObject; in other place
struct _frame {
PyObject_VAR_HEAD
struct _frame *f_back; /* previous frame, or NULL */
PyCodeObject *f_code; /* code segment */
PyObject *f_builtins; /* builtin symbol table [PyDictObject] */
PyObject *f_globals; /* global symbol table [PyDictObject] */
PyObject *f_locals; /* local symbol table [any mapping] */
PyObject **f_valuestack; /* points after the last local */
/* Next free slot in f_valuestack. Frame creation sets to f_valuestack.
Frame evaluation usually NULLs it, but a frame that yields sets it
to the current stack top. */
PyObject **f_stacktop;
PyObject *f_trace; /* Trace function */
char f_trace_lines; /* Emit per-line trace events? */
char f_trace_opcodes; /* Emit per-opcode trace events? */
/* Borrowed reference to a generator, or NULL */
PyObject *f_gen;
int f_lasti; /* Last instruction if called */
int f_lineno; /* Current line number */
int f_iblock; /* index in f_blockstack */
char f_executing; /* whether the frame is still executing */
PyTryBlock f_blockstack[CO_MAXBLOCKS]; /* for try and loop blocks */
PyObject *f_localsplus[1]; /* locals+stack, dynamically sized */
};
// typedef struct _frame PyFrameObject; in other place
struct _frame {
PyObject_VAR_HEAD
struct _frame *f_back; /* previous frame, or NULL */
PyCodeObject *f_code; /* code segment */
PyObject *f_builtins; /* builtin symbol table [PyDictObject] */
PyObject *f_globals; /* global symbol table [PyDictObject] */
PyObject *f_locals; /* local symbol table [any mapping] */
PyObject **f_valuestack; /* points after the last local */
/* Next free slot in f_valuestack. Frame creation sets to f_valuestack.
Frame evaluation usually NULLs it, but a frame that yields sets it
to the current stack top. */
PyObject **f_stacktop;
PyObject *f_trace; /* Trace function */
char f_trace_lines; /* Emit per-line trace events? */
char f_trace_opcodes; /* Emit per-opcode trace events? */
/* Borrowed reference to a generator, or NULL */
PyObject *f_gen;
int f_lasti; /* Last instruction if called */
int f_lineno; /* Current line number */
int f_iblock; /* index in f_blockstack */
char f_executing; /* whether the frame is still executing */
PyTryBlock f_blockstack[CO_MAXBLOCKS]; /* for try and loop blocks */
PyObject *f_localsplus[1]; /* locals+stack, dynamically sized */
};
// typedef struct _frame PyFrameObject; in other place
struct _frame {
PyObject_VAR_HEAD
struct _frame *f_back; /* previous frame, or NULL */
PyCodeObject *f_code; /* code segment */
PyObject *f_builtins; /* builtin symbol table [PyDictObject] */
PyObject *f_globals; /* global symbol table [PyDictObject] */
PyObject *f_locals; /* local symbol table [any mapping] */
PyObject **f_valuestack; /* points after the last local */
/* Next free slot in f_valuestack. Frame creation sets to f_valuestack.
Frame evaluation usually NULLs it, but a frame that yields sets it
to the current stack top. */
PyObject **f_stacktop;
PyObject *f_trace; /* Trace function */
char f_trace_lines; /* Emit per-line trace events? */
char f_trace_opcodes; /* Emit per-opcode trace events? */
/* Borrowed reference to a generator, or NULL */
PyObject *f_gen;
int f_lasti; /* Last instruction if called */
int f_lineno; /* Current line number */
int f_iblock; /* index in f_blockstack */
char f_executing; /* whether the frame is still executing */
PyTryBlock f_blockstack[CO_MAXBLOCKS]; /* for try and loop blocks */
PyObject *f_localsplus[1]; /* locals+stack, dynamically sized */
};
// typedef struct _frame PyFrameObject; in other place
struct _frame {
PyObject_VAR_HEAD
struct _frame *f_back; /* previous frame, or NULL */
PyCodeObject *f_code; /* code segment */
PyObject *f_builtins; /* builtin symbol table [PyDictObject] */
PyObject *f_globals; /* global symbol table [PyDictObject] */
PyObject *f_locals; /* local symbol table [any mapping] */
PyObject **f_valuestack; /* points after the last local */
/* Next free slot in f_valuestack. Frame creation sets to f_valuestack.
Frame evaluation usually NULLs it, but a frame that yields sets it
to the current stack top. */
PyObject **f_stacktop;
PyObject *f_trace; /* Trace function */
char f_trace_lines; /* Emit per-line trace events? */
char f_trace_opcodes; /* Emit per-opcode trace events? */
/* Borrowed reference to a generator, or NULL */
PyObject *f_gen;
int f_lasti; /* Last instruction if called */
int f_lineno; /* Current line number */
int f_iblock; /* index in f_blockstack */
char f_executing; /* whether the frame is still executing */
PyTryBlock f_blockstack[CO_MAXBLOCKS]; /* for try and loop blocks */
PyObject *f_localsplus[1]; /* locals+stack, dynamically sized */
};
Ngăn xếp khối được triển khai dưới dạng mảng
// typedef struct _frame PyFrameObject; in other place
struct _frame {
PyObject_VAR_HEAD
struct _frame *f_back; /* previous frame, or NULL */
PyCodeObject *f_code; /* code segment */
PyObject *f_builtins; /* builtin symbol table [PyDictObject] */
PyObject *f_globals; /* global symbol table [PyDictObject] */
PyObject *f_locals; /* local symbol table [any mapping] */
PyObject **f_valuestack; /* points after the last local */
/* Next free slot in f_valuestack. Frame creation sets to f_valuestack.
Frame evaluation usually NULLs it, but a frame that yields sets it
to the current stack top. */
PyObject **f_stacktop;
PyObject *f_trace; /* Trace function */
char f_trace_lines; /* Emit per-line trace events? */
char f_trace_opcodes; /* Emit per-opcode trace events? */
/* Borrowed reference to a generator, or NULL */
PyObject *f_gen;
int f_lasti; /* Last instruction if called */
int f_lineno; /* Current line number */
int f_iblock; /* index in f_blockstack */
char f_executing; /* whether the frame is still executing */
PyTryBlock f_blockstack[CO_MAXBLOCKS]; /* for try and loop blocks */
PyObject *f_localsplus[1]; /* locals+stack, dynamically sized */
};
// typedef struct _frame PyFrameObject; in other place
struct _frame {
PyObject_VAR_HEAD
struct _frame *f_back; /* previous frame, or NULL */
PyCodeObject *f_code; /* code segment */
PyObject *f_builtins; /* builtin symbol table [PyDictObject] */
PyObject *f_globals; /* global symbol table [PyDictObject] */
PyObject *f_locals; /* local symbol table [any mapping] */
PyObject **f_valuestack; /* points after the last local */
/* Next free slot in f_valuestack. Frame creation sets to f_valuestack.
Frame evaluation usually NULLs it, but a frame that yields sets it
to the current stack top. */
PyObject **f_stacktop;
PyObject *f_trace; /* Trace function */
char f_trace_lines; /* Emit per-line trace events? */
char f_trace_opcodes; /* Emit per-opcode trace events? */
/* Borrowed reference to a generator, or NULL */
PyObject *f_gen;
int f_lasti; /* Last instruction if called */
int f_lineno; /* Current line number */
int f_iblock; /* index in f_blockstack */
char f_executing; /* whether the frame is still executing */
PyTryBlock f_blockstack[CO_MAXBLOCKS]; /* for try and loop blocks */
PyObject *f_localsplus[1]; /* locals+stack, dynamically sized */
};
// typedef struct _frame PyFrameObject; in other place
struct _frame {
PyObject_VAR_HEAD
struct _frame *f_back; /* previous frame, or NULL */
PyCodeObject *f_code; /* code segment */
PyObject *f_builtins; /* builtin symbol table [PyDictObject] */
PyObject *f_globals; /* global symbol table [PyDictObject] */
PyObject *f_locals; /* local symbol table [any mapping] */
PyObject **f_valuestack; /* points after the last local */
/* Next free slot in f_valuestack. Frame creation sets to f_valuestack.
Frame evaluation usually NULLs it, but a frame that yields sets it
to the current stack top. */
PyObject **f_stacktop;
PyObject *f_trace; /* Trace function */
char f_trace_lines; /* Emit per-line trace events? */
char f_trace_opcodes; /* Emit per-opcode trace events? */
/* Borrowed reference to a generator, or NULL */
PyObject *f_gen;
int f_lasti; /* Last instruction if called */
int f_lineno; /* Current line number */
int f_iblock; /* index in f_blockstack */
char f_executing; /* whether the frame is still executing */
PyTryBlock f_blockstack[CO_MAXBLOCKS]; /* for try and loop blocks */
PyObject *f_localsplus[1]; /* locals+stack, dynamically sized */
};
Bản tóm tắt
Hôm nay, chúng tôi đã học được rằng CPython VM thực thi các hướng dẫn mã byte từng cái một trong một vòng lặp vô hạn. Vòng lặp chứa một câu lệnh
struct _ceval_runtime_state {
/* Request for checking signals. It is shared by all interpreters [see
bpo-40513]. Any thread of any interpreter can receive a signal, but only
the main thread of the main interpreter can handle signals: see
_Py_ThreadCanHandleSignals[]. */
_Py_atomic_int signals_pending;
struct _gil_runtime_state gil;
};
struct _ceval_runtime_state {
/* Request for checking signals. It is shared by all interpreters [see
bpo-40513]. Any thread of any interpreter can receive a signal, but only
the main thread of the main interpreter can handle signals: see
_Py_ThreadCanHandleSignals[]. */
_Py_atomic_int signals_pending;
struct _gil_runtime_state gil;
};
Chúng tôi cũng đã xem xét hai cấu trúc dữ liệu quan trọng cho việc thực thi mã byte:
- Giá trị ngăn xếp mà VM sử dụng để tính toán mọi thứ; và
- ngăn xếp khối mà VM sử dụng để xử lý các ngoại lệ.
Kết luận quan trọng nhất từ bài viết là: Nếu bạn muốn nghiên cứu việc thực hiện một số khía cạnh của Python, vòng lặp đánh giá là một nơi hoàn hảo để bắt đầu. Bạn muốn biết điều gì xảy ra khi bạn viết
// typedef struct _frame PyFrameObject; in other place
struct _frame {
PyObject_VAR_HEAD
struct _frame *f_back; /* previous frame, or NULL */
PyCodeObject *f_code; /* code segment */
PyObject *f_builtins; /* builtin symbol table [PyDictObject] */
PyObject *f_globals; /* global symbol table [PyDictObject] */
PyObject *f_locals; /* local symbol table [any mapping] */
PyObject **f_valuestack; /* points after the last local */
/* Next free slot in f_valuestack. Frame creation sets to f_valuestack.
Frame evaluation usually NULLs it, but a frame that yields sets it
to the current stack top. */
PyObject **f_stacktop;
PyObject *f_trace; /* Trace function */
char f_trace_lines; /* Emit per-line trace events? */
char f_trace_opcodes; /* Emit per-opcode trace events? */
/* Borrowed reference to a generator, or NULL */
PyObject *f_gen;
int f_lasti; /* Last instruction if called */
int f_lineno; /* Current line number */
int f_iblock; /* index in f_blockstack */
char f_executing; /* whether the frame is still executing */
PyTryBlock f_blockstack[CO_MAXBLOCKS]; /* for try and loop blocks */
PyObject *f_localsplus[1]; /* locals+stack, dynamically sized */
};
for [;;] {
// ... check if the bytecode execution must be suspended
fast_next_opcode:
// NEXTOPARG[] macro
_Py_CODEUNIT word = *next_instr;
opcode = _Py_OPCODE[word];
oparg = _Py_OPARG[word];
next_instr++;
switch [opcode] {
// TARGET[NOP] expands to NOP
case NOP: {
goto fast_next_opcode; // FAST_DISPATCH[] macro
}
// ...
case BINARY_MULTIPLY: {
// ... code for binary multiplication
continue; // DISPATCH[] macro
}
// ...
}
// ... error handling
}
// typedef struct _frame PyFrameObject; in other place
struct _frame {
PyObject_VAR_HEAD
struct _frame *f_back; /* previous frame, or NULL */
PyCodeObject *f_code; /* code segment */
PyObject *f_builtins; /* builtin symbol table [PyDictObject] */
PyObject *f_globals; /* global symbol table [PyDictObject] */
PyObject *f_locals; /* local symbol table [any mapping] */
PyObject **f_valuestack; /* points after the last local */
/* Next free slot in f_valuestack. Frame creation sets to f_valuestack.
Frame evaluation usually NULLs it, but a frame that yields sets it
to the current stack top. */
PyObject **f_stacktop;
PyObject *f_trace; /* Trace function */
char f_trace_lines; /* Emit per-line trace events? */
char f_trace_opcodes; /* Emit per-opcode trace events? */
/* Borrowed reference to a generator, or NULL */
PyObject *f_gen;
int f_lasti; /* Last instruction if called */
int f_lineno; /* Current line number */
int f_iblock; /* index in f_blockstack */
char f_executing; /* whether the frame is still executing */
PyTryBlock f_blockstack[CO_MAXBLOCKS]; /* for try and loop blocks */
PyObject *f_localsplus[1]; /* locals+stack, dynamically sized */
};
// typedef struct _frame PyFrameObject; in other place
struct _frame {
PyObject_VAR_HEAD
struct _frame *f_back; /* previous frame, or NULL */
PyCodeObject *f_code; /* code segment */
PyObject *f_builtins; /* builtin symbol table [PyDictObject] */
PyObject *f_globals; /* global symbol table [PyDictObject] */
PyObject *f_locals; /* local symbol table [any mapping] */
PyObject **f_valuestack; /* points after the last local */
/* Next free slot in f_valuestack. Frame creation sets to f_valuestack.
Frame evaluation usually NULLs it, but a frame that yields sets it
to the current stack top. */
PyObject **f_stacktop;
PyObject *f_trace; /* Trace function */
char f_trace_lines; /* Emit per-line trace events? */
char f_trace_opcodes; /* Emit per-opcode trace events? */
/* Borrowed reference to a generator, or NULL */
PyObject *f_gen;
int f_lasti; /* Last instruction if called */
int f_lineno; /* Current line number */
int f_iblock; /* index in f_blockstack */
char f_executing; /* whether the frame is still executing */
PyTryBlock f_blockstack[CO_MAXBLOCKS]; /* for try and loop blocks */
PyObject *f_localsplus[1]; /* locals+stack, dynamically sized */
};
// typedef struct _frame PyFrameObject; in other place
struct _frame {
PyObject_VAR_HEAD
struct _frame *f_back; /* previous frame, or NULL */
PyCodeObject *f_code; /* code segment */
PyObject *f_builtins; /* builtin symbol table [PyDictObject] */
PyObject *f_globals; /* global symbol table [PyDictObject] */
PyObject *f_locals; /* local symbol table [any mapping] */
PyObject **f_valuestack; /* points after the last local */
/* Next free slot in f_valuestack. Frame creation sets to f_valuestack.
Frame evaluation usually NULLs it, but a frame that yields sets it
to the current stack top. */
PyObject **f_stacktop;
PyObject *f_trace; /* Trace function */
char f_trace_lines; /* Emit per-line trace events? */
char f_trace_opcodes; /* Emit per-opcode trace events? */
/* Borrowed reference to a generator, or NULL */
PyObject *f_gen;
int f_lasti; /* Last instruction if called */
int f_lineno; /* Current line number */
int f_iblock; /* index in f_blockstack */
char f_executing; /* whether the frame is still executing */
PyTryBlock f_blockstack[CO_MAXBLOCKS]; /* for try and loop blocks */
PyObject *f_localsplus[1]; /* locals+stack, dynamically sized */
};
Nếu bạn có bất kỳ câu hỏi, nhận xét hoặc đề xuất nào, vui lòng liên hệ với tôi tại
Cập nhật từ ngày 10 tháng 11 năm 2020: Tôi đã được chỉ ra trong các bình luận về HN rằng
2 và case TARGET[BINARY_ADD]: {
PyObject *right = POP[];
PyObject *left = TOP[];
PyObject *sum;
// ... special case of string addition
sum = PyNumber_Add[left, right];
Py_DECREF[left];
Py_DECREF[right];
SET_TOP[sum];
if [sum == NULL]
goto error;
DISPATCH[];
}
3 opcodes nhìn thấy giá trị trên đầu ngăn xếp và thay thế nó bằng kết quả thay vì bật giá trị và đẩy kết quả. Điều này thực sự là như vậy. Về mặt ngữ nghĩa, hai cách tiếp cận là tương đương. Sự khác biệt duy nhất là cách tiếp cận pop/đẩy đầu tiên và sau đó tăng case TARGET[BINARY_ADD]: {
PyObject *right = POP[];
PyObject *left = TOP[];
PyObject *sum;
// ... special case of string addition
sum = PyNumber_Add[left, right];
Py_DECREF[left];
Py_DECREF[right];
SET_TOP[sum];
if [sum == NULL]
goto error;
DISPATCH[];
}
8. Cpython tránh các hoạt động dư thừa này.: I was pointed out in the comments on HN that the
case TARGET[BINARY_ADD]: {
PyObject *right = POP[];
PyObject *left = TOP[];
PyObject *sum;
// ... special case of string addition
sum = PyNumber_Add[left, right];
Py_DECREF[left];
Py_DECREF[right];
SET_TOP[sum];
if [sum == NULL]
goto error;
DISPATCH[];
}
case TARGET[BINARY_ADD]: {
PyObject *right = POP[];
PyObject *left = TOP[];
PyObject *sum;
// ... special case of string addition
sum = PyNumber_Add[left, right];
Py_DECREF[left];
Py_DECREF[right];
SET_TOP[sum];
if [sum == NULL]
goto error;
DISPATCH[];
}
case TARGET[BINARY_ADD]: {
PyObject *right = POP[];
PyObject *left = TOP[];
PyObject *sum;
// ... special case of string addition
sum = PyNumber_Add[left, right];
Py_DECREF[left];
Py_DECREF[right];
SET_TOP[sum];
if [sum == NULL]
goto error;
DISPATCH[];
}
case TARGET[BINARY_ADD]: {
PyObject *right = POP[];
PyObject *left = TOP[];
PyObject *sum;
// ... special case of string addition
sum = PyNumber_Add[left, right];
Py_DECREF[left];
Py_DECREF[right];
SET_TOP[sum];
if [sum == NULL]
goto error;
DISPATCH[];
}
Python có sử dụng mã byte không?
Thay vì dịch mã nguồn sang mã máy như C ++, mã python được dịch thành mã byte. Bytecode này là một tập hợp các hướng dẫn cấp thấp có thể được thực thi bởi một trình thông dịch. Trong hầu hết các PC, trình thông dịch Python được cài đặt tại/usr/local/bin/python3.
Làm thế nào là mã byte python được tạo ra?
Mã byte được tự động tạo trong cùng một thư mục với tệp .py, khi một mô -đun Python lần đầu tiên được nhập hoặc khi nguồn gần đây hơn tệp được biên dịch hiện tại.Lần tới, khi chương trình được chạy, người thông báo Python sử dụng tệp này để bỏ qua bước biên dịch.automatically created in the same directory as . py file, when a module of python is imported for the first time, or when the source is more recent than the current compiled file. Next time, when the program is run, python interpretator use this file to skip the compilation step.
Tại sao Python sử dụng mã byte?
Khi trình thông dịch CPython thực thi chương trình của bạn, trước tiên nó sẽ dịch sang một chuỗi các hướng dẫn mã byte.Bytecode là ngôn ngữ trung gian cho máy ảo Python được sử dụng làm tối ưu hóa hiệu suất.used as a performance optimization.
Bytecode được biên dịch như thế nào?
Trình biên dịch chuyển đổi mã nguồn thành mã byte, một mã trung gian thu hẹp khoảng cách giữa mã nguồn cấp cao và mã máy cấp thấp.Trình biên dịch là một loại chương trình đặc biệt dịch các câu lệnh trong mã nguồn sang mã byte, mã máy hoặc ngôn ngữ lập trình khác., an intermediary code that bridges the gap between the high-level source code and low-level machine code. The compiler is a special type of program that translates statements in the source code to bytecode, machine code or another programming language.