深入理解Python虛擬機中整型(int)的實現(xiàn)原理及源碼剖析

更新時間：2023年03月13日 09:27:29 作者：一無是處的研究僧

在本篇文章當中主要給大家介紹在 cpython 內(nèi)部是如何實現(xiàn)整型數(shù)據(jù) int 的，主要是分析 int 類型的表示方式，分析 int 類型的巧妙設計

數(shù)據(jù)結構

在 cpython 內(nèi)部的 int 類型的實現(xiàn)數(shù)據(jù)結構如下所示：

typedef struct _longobject PyLongObject;
struct _longobject {
    PyObject_VAR_HEAD
    digit ob_digit[1];
};
#define PyObject_VAR_HEAD      PyVarObject ob_base;
typedef struct {
    PyObject ob_base;
    Py_ssize_t ob_size; /* Number of items in variable part */
} PyVarObject;
typedef struct _object {
    _PyObject_HEAD_EXTRA
    Py_ssize_t ob_refcnt;
    struct _typeobject *ob_type;
} PyObject;

上面的數(shù)據(jù)結構用圖的方式表示出來如下圖所示：

ob_refcnt，表示對象的引用記數(shù)的個數(shù)，這個對于垃圾回收很有用處，后面我們分析虛擬機中垃圾回收部分在深入分析。
ob_type，表示這個對象的數(shù)據(jù)類型是什么，在 python 當中有時候需要對數(shù)據(jù)的數(shù)據(jù)類型進行判斷比如 isinstance, type 這兩個關鍵字就會使用到這個字段。
ob_size，這個字段表示這個整型對象數(shù)組 ob_digit 當中一共有多少個元素。
digit 類型其實就是 uint32_t 類型的一個宏定義，表示 32 位的整型數(shù)據(jù)。

深入分析 PyLongObject 字段的語意

首先我們知道在 python 當中的整數(shù)是不會溢出的，這正是 PyLongObject 使用數(shù)組的原因。在 cpython 內(nèi)部的實現(xiàn)當中，整數(shù)有 0 、正數(shù)、負數(shù)，對于這一點在 cpython 當中有以下幾個規(guī)定：

ob_size，保存的是數(shù)組的長度，ob_size 大于 0 時保存的是正數(shù)，當 ob_size 小于 0 時保存的是負數(shù)。
ob_digit，保存的是整數(shù)的絕對值。在前面我們談到了，ob_digit 是一個 32 位的數(shù)據(jù)，但是在 cpython 內(nèi)部只會使用其中的前 30 位，這只為了避免溢出的問題。

我們下面使用幾個例子來深入理解一下上面的規(guī)則：

在上圖當中 ob_size 大于 0 ，說明這個數(shù)是一個正數(shù)，而 ob_digit 指向一個 int32 的數(shù)據(jù)，數(shù)的值等于 10，因此上面這個數(shù)表示整數(shù) 10 。

同理 ob_size 小于 0，而 ob_digit 等于 10，因此上圖當中的數(shù)據(jù)表示 -10 。

上面是一個 ob_digit 數(shù)組長度為 2 的例子，上面所表示數(shù)據(jù)如下所示：

1⋅2⁰+1⋅2¹+1⋅2²+...+1⋅2²⁹+0⋅2³⁰+0⋅2³¹+1⋅2³²

因為對于每一個數(shù)組元素來說我們只使用前 30 位，因此到第二個整型數(shù)據(jù)的時候正好對應著 230，大家可以對應著上面的結果了解整個計算過程。

上面也就很簡單了：

−(1⋅2⁰+1⋅2¹+1⋅2²+...+1⋅2²⁹+0⋅2³⁰+0⋅2³¹+1⋅2³²)

小整數(shù)池

為了避免頻繁的創(chuàng)建一些常用的整數(shù)，加快程序執(zhí)行的速度，我們可以將一些常用的整數(shù)先緩存起來，如果需要的話就直接將這個數(shù)據(jù)返回即可。在 cpython 當中相關的代碼如下所示：（小整數(shù)池當中緩存數(shù)據(jù)的區(qū)間為[-5, 256]）

#define NSMALLPOSINTS           257
#define NSMALLNEGINTS           5
 
static PyLongObject small_ints[NSMALLNEGINTS + NSMALLPOSINTS];

我們使用下面的代碼進行測試，看是否使用了小整數(shù)池當中的數(shù)據(jù)，如果使用的話，對于使用小整數(shù)池當中的數(shù)據(jù)，他們的 id() 返回值是一樣的，id 這個內(nèi)嵌函數(shù)返回的是 python 對象的內(nèi)存地址。

>>> a = 1
>>> b = 2
>>> c = 1
>>> id(a), id(c)
(4343136496, 4343136496)
>>> a = -6
>>> c = -6
>>> id(a), id(c)
(4346020624, 4346021072)
>>> a = 257
>>> b = 257
>>> id(a), id(c)
(4346021104, 4346021072)
>>>

從上面的結果我們可以看到的是，對于區(qū)間[-5, 256]當中的值，id 的返回值確實是一樣的，不在這個區(qū)間之內(nèi)的返回值就是不一樣的。

我們還可以這個特性實現(xiàn)一個小的 trick，就是求一個 PyLongObject 對象所占的內(nèi)存空間大小，因為我們可以使用 -5 和 256 這兩個數(shù)據(jù)的內(nèi)存首地址，然后將這個地址相減就可以得到 261 個 PyLongObject 所占的內(nèi)存空間大小（注意雖然小整數(shù)池當中一共有 262 個數(shù)據(jù)，但是最后一個數(shù)據(jù)是內(nèi)存首地址，并不是尾地址，因此只有 261 個數(shù)據(jù)），這樣我們就可以求一個 PyLongObject 對象的內(nèi)存大小。

>>> a = -5
>>> b = 256
>>> (id(b) - id(a)) / 261
32.0
>>>

從上面的輸出結果我們可以看到一個 PyLongObject 對象占 32 個字節(jié)。我們可以使用下面的 C 程序查看一個 PyLongObject 真實所占的內(nèi)存空間大小。

#include "Python.h"
#include <stdio.h>
 
int main()
{
  printf("%ld\n", sizeof(PyLongObject));
  return 0;
}

上面的程序的輸出結果如下所示：

上面兩個結果是相等的，因此也驗證了我們的想法。

從小整數(shù)池當中獲取數(shù)據(jù)的核心代碼如下所示：

static PyObject *
get_small_int(sdigit ival)
{
    PyObject *v;
    assert(-NSMALLNEGINTS <= ival && ival < NSMALLPOSINTS);
    v = (PyObject *)&small_ints[ival + NSMALLNEGINTS];
    Py_INCREF(v);
    return v;
}

整數(shù)的加法實現(xiàn)

關于 PyLongObject 的操作有很多，我們看一下加法的實現(xiàn)，見微知著，剩下的其他的方法我們就不介紹了，大家感興趣可以去看具體的源代碼。

如果你了解過大整數(shù)加法就能夠知道，大整數(shù)加法的具體實現(xiàn)過程了，在 cpython 內(nèi)部的實現(xiàn)方式其實也是一樣的，就是不斷的進行加法操作然后進行進位操作。

#define Py_ABS(x) ((x) < 0 ? -(x) : (x)) // 返回 x 的絕對值
#define PyLong_BASE	((digit)1 << PyLong_SHIFT)
#define PyLong_MASK	((digit)(PyLong_BASE - 1))
 
 
static PyLongObject *
x_add(PyLongObject *a, PyLongObject *b)
{
    // 首先獲得兩個整型數(shù)據(jù)的 size 
    Py_ssize_t size_a = Py_ABS(Py_SIZE(a)), size_b = Py_ABS(Py_SIZE(b));
    PyLongObject *z;
    Py_ssize_t i;
    digit carry = 0;
    // 確保 a 保存的數(shù)據(jù) size 是更大的
    /* Ensure a is the larger of the two: */
    if (size_a < size_b) {
        { PyLongObject *temp = a; a = b; b = temp; }
        { Py_ssize_t size_temp = size_a;
            size_a = size_b;
            size_b = size_temp; }
    }
    // 創(chuàng)建一個新的 PyLongObject 對象，而且數(shù)組的長度是 size_a + 1
    z = _PyLong_New(size_a+1);
    if (z == NULL)
        return NULL;
    // 下面就是整個加法操作的核心
    for (i = 0; i < size_b; ++i) {
        carry += a->ob_digit[i] + b->ob_digit[i];
        // 將低 30 位的數(shù)據(jù)保存下來
        z->ob_digit[i] = carry & PyLong_MASK;
        // 將 carry 右移 30 位，如果上面的加法有進位的話 剛好可以在下一次加法當中使用（注意上面的 carry）
        // 使用的是 += 而不是 =
        carry >>= PyLong_SHIFT; // PyLong_SHIFT = 30
    }
    // 將剩下的長度保存 （因為 a 的 size 是比 b 大的）
    for (; i < size_a; ++i) {
        carry += a->ob_digit[i];
        z->ob_digit[i] = carry & PyLong_MASK;
        carry >>= PyLong_SHIFT;
    }
    // 最后保存高位的進位
    z->ob_digit[i] = carry;
    return long_normalize(z); // long_normalize 這個函數(shù)的主要功能是保證 ob_size 保存的是真正的數(shù)據(jù)的長度 因為可以是一個正數(shù)加上一個負數(shù) size 還變小了
}
 
PyLongObject *
_PyLong_New(Py_ssize_t size)
{
    PyLongObject *result;
    /* Number of bytes needed is: offsetof(PyLongObject, ob_digit) +
       sizeof(digit)*size.  Previous incarnations of this code used
       sizeof(PyVarObject) instead of the offsetof, but this risks being
       incorrect in the presence of padding between the PyVarObject header
       and the digits. */
    if (size > (Py_ssize_t)MAX_LONG_DIGITS) {
        PyErr_SetString(PyExc_OverflowError,
                        "too many digits in integer");
        return NULL;
    }
    // offsetof 會調(diào)用 gcc 的一個內(nèi)嵌函數(shù) __builtin_offsetof 
    // offsetof(PyLongObject, ob_digit)  這個功能是得到 PyLongObject 對象 字段 ob_digit 之前的所有字段所占的內(nèi)存空間的大小
    result = PyObject_MALLOC(offsetof(PyLongObject, ob_digit) +
                             size*sizeof(digit));
    if (!result) {
        PyErr_NoMemory();
        return NULL;
    }
    // 將對象的 result 的引用計數(shù)設置成 1
    return (PyLongObject*)PyObject_INIT_VAR(result, &PyLong_Type, size);
}
 
 
static PyLongObject *
long_normalize(PyLongObject *v)
{
    Py_ssize_t j = Py_ABS(Py_SIZE(v));
    Py_ssize_t i = j;
 
    while (i > 0 && v->ob_digit[i-1] == 0)
        --i;
    if (i != j)
        Py_SIZE(v) = (Py_SIZE(v) < 0) ? -(i) : i;
    return v;
}

總結

在本篇文章當中主要給大家介紹了 cpython 內(nèi)部是如何實現(xiàn)整型數(shù)據(jù) int 的，分析了 int 類型的表示方式和設計。int 內(nèi)部使用 digit 來表示 32 位的整型數(shù)據(jù)，同時為了避免溢出的問題，只會使用其中的前 30 位。在 cpython 內(nèi)部的實現(xiàn)當中，整數(shù)有 0 、正數(shù)、負數(shù)，對于這一點有以下幾個規(guī)定：

ob_size，保存的是數(shù)組的長度，ob_size 大于 0 時保存的是正數(shù)，當 ob_size 小于 0 時保存的是負數(shù)。
ob_digit，保存的是整數(shù)的絕對值。
此外，為避免頻繁創(chuàng)建一些常用的整數(shù)，cpython 使用了小整數(shù)池的技術，將一些常用的整數(shù)先緩存起來。最后，本文還介紹了整數(shù)的加法實現(xiàn)，即不斷進行加法操作然后進行進位操作。

cpython 使用這種方式的主要原理就是大整數(shù)的加減乘除，本篇文章主要是介紹了加法操作，大家如果感興趣可以自行閱讀其他的源程序。

以上就是深入理解Python虛擬機中整型(int)的實現(xiàn)原理及源碼剖析的詳細內(nèi)容，更多關于Python虛擬機整型的資料請關注腳本之家其它相關文章！

您可能感興趣的文章: