Understanding Python's Virtual Machine Execution and Runtime Stack

When the interpreter starts, it first initializes a runtime environment that is separate from the execution environment; the runtime environment is a global concept that prepares the Python process, threads, and type objects before the virtual machine can begin executing bytecode.

Source code is compiled into a PyCodeObject where the co_code field stores the bytecode sequence. The virtual machine creates a stack‑frame object for each code object using functions such as PyEval_EvalCode and PyEval_EvalCodeEx , which internally call _PyEval_Vector to set up the frame.

Frame evaluation is performed by the high‑level wrappers PyEval_EvalFrame and PyEval_EvalFrameEx . Both eventually invoke _PyEval_EvalFrame , which either calls the default evaluator _PyEval_EvalFrameDefault or a custom eval_frame implementation, and this default function walks the co_code bytecode instruction by instruction.

The bytecode consists of alternating opcode and argument bytes; for example the simple script a = 1; b = 2; c = a + b compiles to the following instruction list:

RESUME
LOAD_CONST    0
STORE_NAME    0
LOAD_CONST    1
STORE_NAME    1
LOAD_NAME     0
LOAD_NAME     1
BINARY_OP     0 (+)
STORE_NAME    2
RETURN_CONST  2

Execution of these opcodes relies heavily on the runtime stack, which is a portion of the localsplus array inside a PyFrameObject . The stack pointer points to the current top of the stack, and a collection of macros defined in Python/ceval_macros.h manipulate it, e.g.:

#define STACK_LEVEL()   ((int)(stack_pointer - _PyFrame_Stackbase(frame)))
#define STACK_SIZE()    (frame->f_code->co_stacksize)
#define PUSH(v)          (*stack_pointer++ = (v))
#define POP()            (*--stack_pointer)
#define TOP()            (stack_pointer[-1])
#define PEEK(n)          (stack_pointer[-(n)])
#define SET_TOP(v)       (stack_pointer[-1] = (v))
#define STACK_GROW(n)    (stack_pointer += (n))
#define STACK_SHRINK(n)  (stack_pointer -= (n))

These macros allow the virtual machine to push values onto the stack, pop them, inspect arbitrary depths, and adjust the stack size while guaranteeing that the number of elements never exceeds co_stacksize . Understanding this stack API is essential for grasping how Python evaluates expressions, builds data structures, and returns results.

Overall, the article provides a macro‑level view of the Python VM’s execution pipeline—from compilation to frame creation, bytecode traversal, and runtime‑stack manipulation—offering insight into the inner workings of a dynamic language interpreter.