CPython 实现原理
  • README
  • 一、简介
    • 1.1 如何使用此书
    • 1.2 额外材料和学习资料
  • 二、获取 CPython 源码
    • 2.1 源代码里有什么?
  • 三、准备你的开发环境
    • 3.1 选IDE还是编辑器?
    • 3.2 安装Visual Studio
    • 3.3 安装Visual Studio Code
    • 3.4 安装JetBrains Clion
    • 3.5 安装Vim
    • 3.6 总结
  • 四、编译 CPython
    • 4.1 在 macOS 上编译 CPython
    • 4.2 在 Linux 上编译 CPython
    • 4.3 安装自定义版本
    • 4.4 make 快速入门
    • 4.5 CPython 的 make 目标
    • 4.6 在 Windows 上编译 CPython
    • 4.7 PGO 优化
    • 4.8 总结
  • 五、Python 语言和语法
    • 5.1 为什么 CPython 是用 C 语言而不是用 Python 语言来实现
    • 5.2 Python 语言规范
    • 5.3 分析器生成器
    • 5.4 重新生成语法
    • 5.5 总结
  • 六、配置和输入
    • 6.1 配置状态
    • 6.2 构建配置
    • 6.3 从输入构建模块
    • 6.4 总结
  • 七、基于语法树的词法分析和解析
    • 7.1 具象语法树生成器
    • 7.2 CPython 解析器-分词器
    • 7.3 抽象语法树
    • 7.4 要记住的术语
    • 7.5 一个示例:添加一个约等于比较运算法
    • 7.6 总结
  • 八、编译器
    • 8.1 相关源文件
    • 8.2 重要的专业术语
    • 8.3 实例化一个编译器
    • 8.4 未来标志和编译器标志
    • 8.5 符号表
    • 8.6 核心编译过程
    • 8.7 汇编
    • 8.8 创建一个 Code Object
    • 8.9 使用 Instaviz 展示 Code Object
    • 8.10 一个示例:实现约等于操作符
    • 8.11 总结
  • 九、求值循环
    • 9.1 构建线程状态
    • 9.2 构建帧对象
    • 9.3 帧的执行
    • 9.4 值栈
    • 9.5 例子:在列表中添加元素
    • 9.6 总结
  • 十、内存管理
    • 10.1 C 中的内存分配
    • 10.2 Python 内存管理系统设计
    • 10.3 CPython 内存分配器
  • 十一、并行和并发
    • 11.1 并行和并发模型
    • 11.2 进程的结构
    • 11.3 多进程并行
    • 11.4 多线程
    • 11.5 异步编程
    • 11.6 生成器
    • 11.7 协程
    • 11.8 异步生成器
    • 11.9 子解释器
    • 11.10 总结
  • 十二、对象和类型
    • 12.1 本章的例子
    • 12.2 内置类型
    • 12.3 对象和可变长度对象类型
    • 12.4 类型类
    • 12.5 布尔和整数类型
    • 12.6 Unicode 字符串类型
    • 12.7 字典类型
    • 12.8 总结
  • 十三、标准库
    • 13.1 Python 模块
    • 13.2 Python 和 C 模块
  • 十四、测试套件
    • 14.1 在 Windows 上运行测试套件
    • 14.2 在 Linux 或 MacOS 上运行测试套件
    • 14.3 测试标志
    • 14.4 运行特定测试
    • 14.5 测试模块
    • 14.6 测试工具
    • 14.7 总结
  • 十五、调试
  • 十六、基准测试、性能分析和追踪
  • 十七、下一步计划
    • 17.1 为 CPython 编写 C 扩展
    • 17.2 改进你的 Python 应用程序
    • 17.3 为 CPython 项目做贡献
    • 17.4 继续学习
  • 十八、附录
    • 18.1 C 预处理器
    • 18.2 基础 C 语法
    • 18.3 总结
  • 致谢
Powered by GitBook
On this page
  • 静态内存分配
  • 自动内存分配
  • 动态内存分配
Edit on GitHub
  1. 十、内存管理

10.1 C 中的内存分配

简单了解 C 语言中内存分配方式。

在 C 语言中,在使用变量前首先需要从操作系统为它们分配内存。C 语言中有三种内存分配的机制:

  1. 静态内存分配(static memory allocation):这部分内存在编译阶段就要计算出大小,在可执行文件运行时真正被分配;

  2. 自动内存分配(automatic memory allocation):当一个帧开始时,会在调用栈中分配此作用域(例如函数)需要的内存,在帧执行完成后这部分内存被释放;

  3. 动态内存分配(dynamic memory allocation):可以在运行时通过调用内存分配的 API 动态的分配内存。

静态内存分配

C 中的类型所占的内存大小是固定的。对于全局和静态变量,编译器可以计算出它们需要的内存大小并将这些大小信息编译到应用程序中。

举个例子:

static int number = 0;

你可以通过 sizeof() 函数去查看 C 中类型所占的内存大小。就我的操作系统来说,在 64 位 macOS 上通过 GCC 编译器得到的 int 类型大小是 4 bytes。根据操作系统架构和编译器的类型,C 中的基础类型可能有不同的大小。

对于静态定义的数组类型,这里以一个包含了 10 个整型的数组作为例子:

static int numbers[10] = {0,1,2,3,4,5,6,7,8,9};

C 编译器会为这段代码分配 sizeof(int) * 10 bytes 大小的内存空间。

C 编译器使用系统调用去分配内存。这些系统调用依赖于操作系统架构,是内核中更底层的函数,用于从系统内存页分配内存。

自动内存分配

类似于静态内存分配,自动内存分配将在编译期间计算需要分配的内存大小。下面给出了一个计算 100 华氏度的例子:

#include <stdio.h>
static const double five_ninths = 5.0/9.0;

double celsius(double fahrenheit) {
    double c = (fahrenheit - 32) * five_ninths;
    return c;
}

int main() {
    double f = 100;
    printf("%f F is %f Cn", f, celsius(f));
    return 0;
}

这个例子使用了静态和动态内存分配技术:

  • five_ninths 这个变量由于带有 static 关键字所以使用了静态内存分配;

  • 当函数 celsius() 调用时,函数中的变量 c 使用了自动内存分配,为其分配的内存在函数结束后释放;

  • 当函数 main() 调用时,函数中的变量 f 使用了自动内存分配,为其分配的内存在函数结束后释放;

  • celsius(f) 输出的结果隐式的自动分配了内存;

  • 所有自动分配的内存在 main() 函数结束后被释放。

动态内存分配

许多情况下,静态内存分配和自动分配内存两者都不能满足我们的需求。举个例子,编译阶段有时无法知道我们究竟需要多大的内存,因为这些数据可能是用户输入的。

这种情况下,内存就需要动态地分配。动态内存分配通过调用 C 语言的内存分配 API 来工作。操作系统保留了一部分系统内存,用于动态分配给进程。这部分内存也称为堆(heap)。

在下面的例子中,你将把内存动态地分配给一个由华氏温度和摄氏温度值组成的数组。此应用程序会根据用户指定华氏温度值的数量计算相对应的摄氏度值:

#include <stdio.h>
#include <stdlib.h>

static const double five_ninths = 5.0/9.0;

double celsius(double fahrenheit) {
    double c = (fahrenheit - 32) * five_ninths;
    return c;
}

int main(int argc, char** argv) {
    if (argc != 2)
        return -1;
    int number = atoi(argv[1]);
    double* c_values = (double*)calloc(number, sizeof(double));
    double* f_values = (double*)calloc(number, sizeof(double));
    for (int i = 0 ; i < number ; i++ ){
        f_values[i] = (i + 10) * 10.0 ;
        c_values[i] = celsius((double)f_values[i]);
    }
    for (int i = 0 ; i < number ; i++ ){
        printf("%f F is %f Cn", f_values[i], c_values[i]);
    }
    free(c_values);
    free(f_values);
    return 0;
}

传入参数 4 去执行这段代码,你将会得到以下结果:

100.000000 F is 37.777778 C
110.000000 F is 43.333334 C
120.000000 F is 48.888888 C
130.000000 F is 54.444444 C

这个例子就是使用了堆中的内存块进行动态内存分配,然后当不再需要它们时把内存块返回给堆。如果存在动态分配的内存没有被释放,就会造成内存泄漏(memory leak)。

Previous十、内存管理Next10.2 Python 内存管理系统设计

Last updated 2 years ago