• Include： 头文件部分
• Lib： 自带标准库，用python编写
• Module： 用C编写的模块
• Objects： 所有python内建对象
• Parser： 解释器的scanner和parser部分
• Python： 包含了解释器的compiler和执行引擎部分

typedef struct _object {
    PyObject_HEAD
} PyObject;

#define PyObject_HEAD          \
    _PyObject_HEAD_EXTRA       \    // Debug
    Py_ssize_t ob_refcnt;      \    // 引用计数（Py_ssize_t相当于unsigned）
    struct _typeobject *ob_type;    // 类型对象

• python对象不能是被静态初始化的， 并且也不能是在栈空间上生存的。除了类型对象(type object)都是被动态初始化的
• 一个对象一旦被创建，它在内存中的大小就是不变的了。这就意味着 需要容纳可变长度数据的对象只能在对象内维护一个指向其他内存区域的指针。这种设计有利于内存管理，避免动态修改内存大小导致的地址变化

[intobject.h]
typedef struct {
    PyObject_HEAD
    long ob_ival;
} PyIntObject;

• 除了HEAD之外，实际只有一个long
• 进行基本的数值操作的时候，都是拿intObj->ob_ival进行操作
• 它的类型对象是PyInt_Type，定义了许多相关的int_methods，如加法溢出时转为PyLongObject：

typedef struct {
    PyObject_VAR_HEAD
} PyVarObject;


#define PyObject_VAR_HEAD    \
    PyObject_HEAD            \
    Py_ssize_t ob_size;

• 其基于PyObject_VAR_HEAD，是对PyObject的拓展，相比PyObject_HEAD增加了一个ob_size，因此能记录大小的不断改变

1. 当一个对象的引用计数减少到 0 之后，Py_DECREF 将调用该对象的 析构函数(tp_dealloc) 来释放该对象所占有的内存和系统资源。
2. 在每一个对象创建的时候，Python提供了一个_Py_NewReference(op)宏来将对象的引用计数初始化为 1。
3. 类型对象是超越引用计数规则的，因为类型对象永远不会被析构
4. 一般来说，Python中大量采用了内存对象池的技术，使用这种技术避免频繁地申请和释放内存空间。因此在析构时，通常都是将对象占用的空间归还到内存池中。这一点在接下来对 Python 内建对象的实现中可以看得一清二楚

[stringobject.h]
typedef struct {
    PyObject_VAR_HEAD
    long ob_shash;     // 缓存该对象的 HASH 值，初始-1
    int ob_sstate;     // 是否使用intern（共享短字符串）机制
    char ob_sval[1];   // char[]也是以'\0'结尾的，但因为size的存在其中间其实是可以出现'\0'的
} PyStringObject;

1. 这是一个immutable对象，只能由FromString或FromStringAndSize创建
2. python会为 空字符'' 建立一个 PyStringObject 对象，将这个 PyStringObject 对象通过 Intern 机制进行共享，然后将 nullstring 指向这个被共享的对象

[listobject.h]
typedef struct {
    PyObject_VAR_HEAD
    PyObject **ob_item;     // 指向各元素的指针数组
    Py_ssize_t allocated;   // 可容纳元素的总数，相当于capacity，始终>=ob_size
} PyListObject;

1. 创建: PyList_New，具有free_lists缓冲池技术(存PyListObject*)，优先从池中拿出来使用
2. 添加: PyList_Append
3. 插入: PyList_Insert，会在不够用时进行list_resize、会将插入点后的元素后移、与vector非常相似
4. 移除: list_remove ....等等
5. 销毁listObj的时候，不一定会立即释放，而是放在free_lists中以备后用，但是list中的各元素引用计数肯定是要改变的

---

[dictobject.h]
#define PyDict_MINSIZE 8    // dict最小成员数


typedef struct {
    Py_hash_t me_hash;    // 存储key的hash值
    PyObject *me_key;     // key
    PyObject *me_value;   // value
} PyDictEntry;


typedef struct _dictobject {
    PyObject_HEAD
    int ma_fill;          // Active和Dummy的成员个数
    int ma_used;          // Active的成员个数
    int ma_mask;          // 成员总数
    PyDictEntry *ma_table;    // 额外成员空间
    PyDictEntry *(*ma_lookup)(PyDictObject *mp, PyObject *key, long hash);
    PyDictEntry ma_smalltable[PyDict_MINSIZE];    // 初始成员空间
} PyDictObject;

1. 通过Hash算法来碰撞到指定的Bucket上，碰撞到同一个Bucket槽上所有数据形成一个单链表（与python不同，用的是开链法）
2. 需要buckets和entries两个数组来实现间接索引（空间换时间）。默认情况Entries槽中的数据按照添加顺序排列
3. 删除的数据会形成一个FreeList的链表，添加数据的时候，优先向FreeList链表中添加数据，FreeList为空则按照count依次排列
4. 字典查询及其的效率取决于碰撞的次数，这也解释了为什么Dictionary的查找会很快。

[intobject.c]
#define BLOCK_SIZE 1000 /* 1K less typical malloc overhead */
#define BHEAD_SIZE 8    /* Enough for a 64-bit pointer */ 
#define N_INTOBJECTS ((BLOCK_SIZE - BHEAD_SIZE) / sizeof(PyIntObject))


struct _intblock {
    struct _intblock *next; 
    PyIntObject objects[N_INTOBJECTS];
};
typedef struct _intblock PyIntBlock;


static PyIntBlock *block_list = NULL; 
static PyIntObject *free_list = NULL;

• 一个完整的arena包括一个arena_object和透过这个arena_object管理着的pool集合
• pool_header管理的内存与pool_header自身是一块连续的内存，而arena_object与其管理的内存是分离的
• 当pool_header被申请，它所管理的block集合的内存也被申请了，当arena_object被申请，它所管理的pool集合内存没有被申请。
• 多个arena构成的集合，是一个arena数组，数组首地址由arenas维护。
• 当一个arena没有与pool集合建立联系，处于"未使用"状态。一旦建立了联系，就进入"可用"状态。对两种状态都有一个arena链表，分别是unused_arena_objects(通过nextarena链接，单向链表)和usable_arena_objects(通过nextarena和prearena连接，双向链表)
• 申请arena时，会先检查是否还有未使用的arena，有则从单向链表中抽取出arena，并断绝联系。

• used状态：pool中至少有一个block被使用，至少还有一个block未被使用。受控于python内部维护的usedpool数组
• full状态：所有block都已经被使用，这种pool在arena中，但不在arena的freepools链表中。
• empty状态：所有block都未被使用，这类pool的集合通过其pool_header中的nextpool构成一个链表。表头就是arena_object中的freepools

• 当申请特定大小小块内存时，首先根据大小寻找对应usedpool，如果没有可用的pool，会从usable_arena中第一个可用的arena获得一个pool。如果usable_arena为空，python会申请一个arena并构建usable_arena链表。
• 当释放一个block，pool可能从used状态变为empty状态，或者从full变为used。若回收了block之后pool仍处于used状态，block被重新放到自由block链表中。若从full回到used，将pool链回到usedpool即可。
• 从used变为empty时，将pool链到freepools中。如果arena中的pool都是empty的，释放pool集合占用的内存。

• python回收其实只是将它在block/pool的那个地方置空，总的申请空间不会变（需要调到底层才会还给系统）
• 内存合并只会合block，因为一个pool是一个页
• 一个pool里的block大小都是一样的，block-pool-arena，先查找有没有相应的pool，然后把对象存进这个pool的block
• 分代回收，步进式回收，优化GC卡顿

---

1. 从f_back我们可以看出一点，在Python实际执行的过程中，会产生很多PyFrameObject对象，而这些对象会被链接起来，形成一条执行环境链表。这正是对x86机器上栈帧间关系的模拟
2. 在f_code中存放的是一个待执行的PyCodeObject对象，而接下来的f_builtins、f_globals、f_locals是3个独立的名字空间
3. 而在编译一段Code Block时，会计算出这段Code Block执行过程中所需要的栈空间大小。这个栈空间大小存储在PyCodeObject的co_stacksize中。因为不同的Code Block在执行时所需的栈空间大小不同，所以决定PyFrameObject的开头一定有一个PyObject_VAR_HEAD

1. 通过LOAD_CONST 0，将函数f对应的PyCodeObject对象压入到运行时栈
2. 执行MAKE_FUNCTION，根据这个PyCodeObject创建一个PyFunctionObject对象。
3. MAKE_FUNCTION结束后，又再次把PyFunctionObject压入栈中。
4. 通过STORE_NAME, 为名字赋一个引用对象，对象由栈顶弹栈得到(即3压入的对象）。

函数调用