Hướng dẫn can you dynamically allocate memory in python? - bạn có thể cấp phát bộ nhớ động trong python không?

Tổng quan¶

Quản lý bộ nhớ trong Python liên quan đến một đống riêng tư chứa tất cả các đối tượng Python và cấu trúc dữ liệu. Việc quản lý đống riêng tư này được đảm bảo trong nội bộ bởi Trình quản lý bộ nhớ Python. Trình quản lý bộ nhớ Python có các thành phần khác nhau liên quan đến các khía cạnh quản lý lưu trữ động khác nhau, như chia sẻ, phân khúc, phân tách hoặc bộ nhớ đệm.

Ở cấp độ thấp nhất, bộ phân bổ bộ nhớ thô đảm bảo rằng có đủ chỗ trong đống riêng để lưu trữ tất cả dữ liệu liên quan đến Python bằng cách tương tác với trình quản lý bộ nhớ của hệ điều hành. Ngoài bộ phân bổ bộ nhớ thô, một số bộ phân bổ dành riêng cho đối tượng hoạt động trên cùng một đống và thực hiện các chính sách quản lý bộ nhớ riêng biệt thích nghi với đặc thù của mọi loại đối tượng. Ví dụ, các đối tượng số nguyên được quản lý khác nhau trong đống so với chuỗi, bộ dữ liệu hoặc từ điển vì các số nguyên ngụ ý các yêu cầu lưu trữ khác nhau và đánh đổi tốc độ/không gian. Do đó, Trình quản lý bộ nhớ Python ủy thác một số công việc cho các phân bổ dành riêng cho đối tượng, nhưng đảm bảo rằng phần sau hoạt động trong giới hạn của đống riêng tư.

Điều quan trọng là phải hiểu rằng việc quản lý đống Python được thực hiện bởi chính người phiên dịch và người dùng không có quyền kiểm soát nó, ngay cả khi họ thường xuyên thao túng các con trỏ đối tượng vào các khối bộ nhớ bên trong đống đó. Việc phân bổ không gian heap cho các đối tượng Python và các bộ đệm nội bộ khác được thực hiện theo yêu cầu của Trình quản lý bộ nhớ Python thông qua các hàm API Python/C được liệt kê trong tài liệu này.

Để tránh tham nhũng bộ nhớ, các nhà văn mở rộng không bao giờ nên cố gắng hoạt động trên các đối tượng Python với các chức năng được xuất bởi thư viện C: malloc(),

a = 2   # a is a reference to 2
b = a   # b is a reference to 'a'
b = 3   # b now points to 3, while 'a' continues to point to 2

a = 2   # a is a reference to 2
b = a   # b is a reference to 'a'
b = 3   # b now points to 3, while 'a' continues to point to 2

a = 2   # a is a reference to 2
b = a   # b is a reference to 'a'
b = 3   # b now points to 3, while 'a' continues to point to 2

PyObject *res;
char *buf = (char *) malloc(BUFSIZ); /* for I/O */

if (buf == NULL)
    return PyErr_NoMemory();
...Do some I/O operation involving buf...
res = PyBytes_FromString(buf);
free(buf); /* malloc'ed */
return res;

Trong ví dụ này, yêu cầu bộ nhớ cho bộ đệm I/O được xử lý bởi Trình phân bổ thư viện C. Trình quản lý bộ nhớ Python chỉ tham gia vào việc phân bổ đối tượng byte được trả về.

Tuy nhiên, trong hầu hết các tình huống, nên phân bổ bộ nhớ từ đống Python cụ thể vì cái sau nằm dưới sự kiểm soát của Trình quản lý bộ nhớ Python. Ví dụ: điều này là bắt buộc khi trình thông dịch được mở rộng với các loại đối tượng mới được viết bằng C. Một lý do khác để sử dụng heap Python là mong muốn thông báo cho Trình quản lý bộ nhớ Python về nhu cầu bộ nhớ của mô -đun mở rộng. Ngay cả khi bộ nhớ được yêu cầu được sử dụng riêng cho các mục đích nội bộ, cụ thể cao, việc ủy ​​thác tất cả các yêu cầu bộ nhớ cho Trình quản lý bộ nhớ Python khiến trình thông dịch có toàn bộ hình ảnh chính xác hơn về dấu chân bộ nhớ của nó. Do đó, trong một số trường hợp nhất định, Trình quản lý bộ nhớ Python có thể hoặc không thể kích hoạt các hành động thích hợp, như thu gom rác, nén bộ nhớ hoặc các thủ tục phòng ngừa khác. Lưu ý rằng bằng cách sử dụng trình phân bổ thư viện C như trong ví dụ trước, bộ nhớ được phân bổ cho bộ đệm I/O thoát hoàn toàn Trình quản lý bộ nhớ Python.

Xem thêm

Biến môi trường

a = 2   # a is a reference to 2
b = a   # b is a reference to 'a'
b = 3   # b now points to 3, while 'a' continues to point to 2

a = 2   # a is a reference to 2
b = a   # b is a reference to 'a'
b = 3   # b now points to 3, while 'a' continues to point to 2

Biến môi trường

a = 2   # a is a reference to 2
b = a   # b is a reference to 'a'
b = 3   # b now points to 3, while 'a' continues to point to 2

a = 2   # a is a reference to 2
b = a   # b is a reference to 'a'
b = 3   # b now points to 3, while 'a' continues to point to 2

Miền phân cấp

Tất cả các chức năng phân bổ thuộc về một trong ba tên miền khác nhau (xem thêm

a = 2   # a is a reference to 2
b = a   # b is a reference to 'a'
b = 3   # b now points to 3, while 'a' continues to point to 2

a = 2   # a is a reference to 2
b = a   # b is a reference to 'a'
b = 3   # b now points to 3, while 'a' continues to point to 2

a = 2   # a is a reference to 2
b = a   # b is a reference to 'a'
b = 3   # b now points to 3, while 'a' continues to point to 2

a = 2   # a is a reference to 2
b = a   # b is a reference to 'a'
b = 3   # b now points to 3, while 'a' continues to point to 2

a = 2   # a is a reference to 2
b = a   # b is a reference to 'a'
b = 3   # b now points to 3, while 'a' continues to point to 2

Ba miền phân bổ là:

• Tên miền RAW: Dự định phân bổ bộ nhớ cho bộ đệm bộ nhớ có mục đích chung trong đó phân bổ phải đi đến trình phân bổ hệ thống hoặc nơi bộ phân bổ có thể hoạt động mà không cần Gil. Bộ nhớ được yêu cầu trực tiếp đến hệ thống.GIL. The memory is requested directly to the system.

• Tên miền MEM MEM: dự định phân bổ bộ nhớ cho bộ đệm python và bộ đệm bộ nhớ đa năng trong đó phân bổ phải được thực hiện với GIL được giữ. Bộ nhớ được lấy từ đống riêng Python.GIL held. The memory is taken from the Python private heap.

• Miền đối tượng: dự định phân bổ bộ nhớ thuộc về các đối tượng Python. Bộ nhớ được lấy từ đống riêng Python.

Khi giải phóng bộ nhớ được phân bổ trước đây bởi các hàm phân bổ thuộc một miền nhất định, phải sử dụng các chức năng giải quyết cụ thể phù hợp. Ví dụ,

a = 2   # a is a reference to 2
b = a   # b is a reference to 'a'
b = 3   # b now points to 3, while 'a' continues to point to 2

a = 2   # a is a reference to 2
b = a   # b is a reference to 'a'
b = 3   # b now points to 3, while 'a' continues to point to 2

Giao diện bộ nhớ thô

Các bộ chức năng sau đây là trình bao bọc cho bộ phân bổ hệ thống. Các chức năng này là an toàn cho luồng, GIL không cần phải được giữ.GIL does not need to be held.

Bộ phân bổ bộ nhớ thô mặc định sử dụng các chức năng sau: malloc(),

a = 2   # a is a reference to 2
b = a   # b is a reference to 'a'
b = 3   # b now points to 3, while 'a' continues to point to 2

a = 2   # a is a reference to 2
b = a   # b is a reference to 'a'
b = 3   # b now points to 3, while 'a' continues to point to 2

a = 2   # a is a reference to 2
b = a   # b is a reference to 'a'
b = 3   # b now points to 3, while 'a' continues to point to 2

alist = ['eggs', 2, 'juice']  # alist is reference to a new list
blist = alist # blist is a reference; changing blist affects alist
blist.append('coffee') # alist and blist both point to 
                       # ['eggs', 2, 'juice', 'coffee']

alist = ['eggs', 2, 'juice']  # alist is reference to a new list
blist = alist # blist is a reference; changing blist affects alist
blist.append('coffee') # alist and blist both point to 
                       # ['eggs', 2, 'juice', 'coffee']

a = 2   # a is a reference to 2
b = a   # b is a reference to 'a'
b = 3   # b now points to 3, while 'a' continues to point to 2

a = 2   # a is a reference to 2
b = a   # b is a reference to 'a'
b = 3   # b now points to 3, while 'a' continues to point to 2

a = 2   # a is a reference to 2
b = a   # b is a reference to 'a'
b = 3   # b now points to 3, while 'a' continues to point to 2

alist = ['eggs', 2, 'juice']  # alist is reference to a new list
blist = alist # blist is a reference; changing blist affects alist
blist.append('coffee') # alist and blist both point to 
                       # ['eggs', 2, 'juice', 'coffee']

alist = ['eggs', 2, 'juice']  # alist is reference to a new list
blist = alist # blist is a reference; changing blist affects alist
blist.append('coffee') # alist and blist both point to 
                       # ['eggs', 2, 'juice', 'coffee']

Mới trong phiên bản 3.4.

alist = ['eggs', 2, 'juice']  # alist is reference to a new list
blist = alist # blist is a reference; changing blist affects alist
blist.append('coffee') # alist and blist both point to 
                       # ['eggs', 2, 'juice', 'coffee']

Allocates n bytes and returns a pointer of type void* to the allocated memory, or

alist = ['eggs', 2, 'juice']  # alist is reference to a new list
blist = alist # blist is a reference; changing blist affects alist
blist.append('coffee') # alist and blist both point to 
                       # ['eggs', 2, 'juice', 'coffee']

Yêu cầu số byte không trả về một con trỏ không khác nhau nếu có thể, như thể

alist = ['eggs', 2, 'juice']  # alist is reference to a new list
blist = alist # blist is a reference; changing blist affects alist
blist.append('coffee') # alist and blist both point to 
                       # ['eggs', 2, 'juice', 'coffee']

alist = ['eggs', 2, 'juice']  # alist is reference to a new list
blist = alist # blist is a reference; changing blist affects alist
blist.append('coffee') # alist and blist both point to 
                       # ['eggs', 2, 'juice', 'coffee']

Allocates nelem elements each whose size in bytes is elsize and returns a pointer of type void* to the allocated memory, or

alist = ['eggs', 2, 'juice']  # alist is reference to a new list
blist = alist # blist is a reference; changing blist affects alist
blist.append('coffee') # alist and blist both point to 
                       # ['eggs', 2, 'juice', 'coffee']

Yêu cầu các phần tử bằng 0 hoặc các phần tử có kích thước 0 byte trả về một con trỏ không khác biệt khác nhau nếu có thể, như thể

new_list4k = [None]*4096 # initialize to list of 4096 None's 
new_list4k = [0]*4096    # initialize to 4096 0's
big_list = []
big_list.extend(new_list4k) # resizes big_list to accomodate at least 4k items

Mới trong phiên bản 3.5.

Resizes the memory block pointed to by p to n bytes. The contents will be unchanged to the minimum of the old and the new sizes.

Nếu P là

alist = ['eggs', 2, 'juice']  # alist is reference to a new list
blist = alist # blist is a reference; changing blist affects alist
blist.append('coffee') # alist and blist both point to 
                       # ['eggs', 2, 'juice', 'coffee']

new_list4k = [None]*4096 # initialize to list of 4096 None's 
new_list4k = [0]*4096    # initialize to 4096 0's
big_list = []
big_list.extend(new_list4k) # resizes big_list to accomodate at least 4k items

Trừ khi p là

alist = ['eggs', 2, 'juice']  # alist is reference to a new list
blist = alist # blist is a reference; changing blist affects alist
blist.append('coffee') # alist and blist both point to 
                       # ['eggs', 2, 'juice', 'coffee']

a = 2   # a is a reference to 2
b = a   # b is a reference to 'a'
b = 3   # b now points to 3, while 'a' continues to point to 2

new_list4k = [None]*4096 # initialize to list of 4096 None's 
new_list4k = [0]*4096    # initialize to 4096 0's
big_list = []
big_list.extend(new_list4k) # resizes big_list to accomodate at least 4k items

new_list4k = [None]*4096 # initialize to list of 4096 None's 
new_list4k = [0]*4096    # initialize to 4096 0's
big_list = []
big_list.extend(new_list4k) # resizes big_list to accomodate at least 4k items

Nếu yêu cầu không thành công,

new_list4k = [None]*4096 # initialize to list of 4096 None's 
new_list4k = [0]*4096    # initialize to 4096 0's
big_list = []
big_list.extend(new_list4k) # resizes big_list to accomodate at least 4k items

alist = ['eggs', 2, 'juice']  # alist is reference to a new list
blist = alist # blist is a reference; changing blist affects alist
blist.append('coffee') # alist and blist both point to 
                       # ['eggs', 2, 'juice', 'coffee']

a = 2   # a is a reference to 2
b = a   # b is a reference to 'a'
b = 3   # b now points to 3, while 'a' continues to point to 2

new_list4k = [None]*4096 # initialize to list of 4096 None's 
new_list4k = [0]*4096    # initialize to 4096 0's
big_list = []
big_list.extend(new_list4k) # resizes big_list to accomodate at least 4k items

new_list4k = [None]*4096 # initialize to list of 4096 None's 
new_list4k = [0]*4096    # initialize to 4096 0's
big_list = []
big_list.extend(new_list4k) # resizes big_list to accomodate at least 4k items

import numpy as np
my_array = np.zeros(8192) # create a fixed array length of 8K elements
my_array += 4             # fills everything with 4

Frees the memory block pointed to by p, which must have been returned by a previous call to

a = 2   # a is a reference to 2
b = a   # b is a reference to 'a'
b = 3   # b now points to 3, while 'a' continues to point to 2

new_list4k = [None]*4096 # initialize to list of 4096 None's 
new_list4k = [0]*4096    # initialize to 4096 0's
big_list = []
big_list.extend(new_list4k) # resizes big_list to accomodate at least 4k items

new_list4k = [None]*4096 # initialize to list of 4096 None's 
new_list4k = [0]*4096    # initialize to 4096 0's
big_list = []
big_list.extend(new_list4k) # resizes big_list to accomodate at least 4k items

import numpy as np
my_array = np.zeros(8192) # create a fixed array length of 8K elements
my_array += 4             # fills everything with 4

Nếu P là

alist = ['eggs', 2, 'juice']  # alist is reference to a new list
blist = alist # blist is a reference; changing blist affects alist
blist.append('coffee') # alist and blist both point to 
                       # ['eggs', 2, 'juice', 'coffee']

Giao diện bộ nhớ

Các bộ chức năng sau, được mô hình hóa theo tiêu chuẩn ANSI C, nhưng chỉ định hành vi khi yêu cầu 0 byte, có sẵn để phân bổ và giải phóng bộ nhớ từ đống Python.

Bộ phân bổ bộ nhớ mặc định sử dụng bộ phân bổ bộ nhớ Pymalloc.default memory allocator uses the pymalloc memory allocator.

Cảnh báo

GIL phải được giữ khi sử dụng các chức năng này.GIL must be held when using these functions.

Đã thay đổi trong phiên bản 3.6: Bộ phân bổ mặc định hiện là pymalloc thay vì hệ thống malloc().The default allocator is now pymalloc instead of system malloc().

Phân bổ n byte và trả về một con trỏ khoảng trống* cho bộ nhớ được phân bổ hoặc

alist = ['eggs', 2, 'juice']  # alist is reference to a new list
blist = alist # blist is a reference; changing blist affects alist
blist.append('coffee') # alist and blist both point to 
                       # ['eggs', 2, 'juice', 'coffee']

alist = ['eggs', 2, 'juice']  # alist is reference to a new list
blist = alist # blist is a reference; changing blist affects alist
blist.append('coffee') # alist and blist both point to 
                       # ['eggs', 2, 'juice', 'coffee']

Yêu cầu Zero Byte trả về một con trỏ không khác biệt nếu có thể, như thể

import numpy as np
my_array = np.zeros(8192) # create a fixed array length of 8K elements
my_array += 4             # fills everything with 4

Phân bổ các phần tử nelem, mỗi phần tử có kích thước trong byte là elsize và trả về một con trỏ khoảng trống* cho bộ nhớ được phân bổ hoặc

alist = ['eggs', 2, 'juice']  # alist is reference to a new list
blist = alist # blist is a reference; changing blist affects alist
blist.append('coffee') # alist and blist both point to 
                       # ['eggs', 2, 'juice', 'coffee']

alist = ['eggs', 2, 'juice']  # alist is reference to a new list
blist = alist # blist is a reference; changing blist affects alist
blist.append('coffee') # alist and blist both point to 
                       # ['eggs', 2, 'juice', 'coffee']

Yêu cầu các phần tử bằng 0 hoặc các phần tử có kích thước 0 byte trả về một con trỏ không khác biệt khác nhau nếu có thể, như thể

PyObject *res;
char *buf = (char *) malloc(BUFSIZ); /* for I/O */

if (buf == NULL)
    return PyErr_NoMemory();
...Do some I/O operation involving buf...
res = PyBytes_FromString(buf);
free(buf); /* malloc'ed */
return res;

Mới trong phiên bản 3.5.

Thay đổi kích thước khối bộ nhớ được trỏ bởi p thành n byte. Các nội dung sẽ không thay đổi ở mức tối thiểu của cũ và kích thước mới.

Nếu P là

alist = ['eggs', 2, 'juice']  # alist is reference to a new list
blist = alist # blist is a reference; changing blist affects alist
blist.append('coffee') # alist and blist both point to 
                       # ['eggs', 2, 'juice', 'coffee']

PyObject *res;
char *buf = (char *) malloc(BUFSIZ); /* for I/O */

if (buf == NULL)
    return PyErr_NoMemory();
...Do some I/O operation involving buf...
res = PyBytes_FromString(buf);
free(buf); /* malloc'ed */
return res;

Trừ khi p là

alist = ['eggs', 2, 'juice']  # alist is reference to a new list
blist = alist # blist is a reference; changing blist affects alist
blist.append('coffee') # alist and blist both point to 
                       # ['eggs', 2, 'juice', 'coffee']

a = 2   # a is a reference to 2
b = a   # b is a reference to 'a'
b = 3   # b now points to 3, while 'a' continues to point to 2

PyObject *res;
char *buf = (char *) malloc(BUFSIZ); /* for I/O */

if (buf == NULL)
    return PyErr_NoMemory();
...Do some I/O operation involving buf...
res = PyBytes_FromString(buf);
free(buf); /* malloc'ed */
return res;

PyObject *res;
char *buf = (char *) malloc(BUFSIZ); /* for I/O */

if (buf == NULL)
    return PyErr_NoMemory();
...Do some I/O operation involving buf...
res = PyBytes_FromString(buf);
free(buf); /* malloc'ed */
return res;

Nếu yêu cầu không thành công,

PyObject *res;
char *buf = (char *) malloc(BUFSIZ); /* for I/O */

if (buf == NULL)
    return PyErr_NoMemory();
...Do some I/O operation involving buf...
res = PyBytes_FromString(buf);
free(buf); /* malloc'ed */
return res;

alist = ['eggs', 2, 'juice']  # alist is reference to a new list
blist = alist # blist is a reference; changing blist affects alist
blist.append('coffee') # alist and blist both point to 
                       # ['eggs', 2, 'juice', 'coffee']

Giải phóng khối bộ nhớ được chỉ bởi P, phải được trả lại bằng một cuộc gọi trước đó cho

a = 2   # a is a reference to 2
b = a   # b is a reference to 'a'
b = 3   # b now points to 3, while 'a' continues to point to 2

PyObject *res;
char *buf = (char *) malloc(BUFSIZ); /* for I/O */

if (buf == NULL)
    return PyErr_NoMemory();
...Do some I/O operation involving buf...
res = PyBytes_FromString(buf);
free(buf); /* malloc'ed */
return res;

PyObject *res;
char *buf = (char *) malloc(BUFSIZ); /* for I/O */

if (buf == NULL)
    return PyErr_NoMemory();
...Do some I/O operation involving buf...
res = PyBytes_FromString(buf);
free(buf); /* malloc'ed */
return res;

PyObject *res;
char *buf = (char *) PyMem_Malloc(BUFSIZ); /* for I/O */

if (buf == NULL)
    return PyErr_NoMemory();
/* ...Do some I/O operation involving buf... */
res = PyBytes_FromString(buf);
PyMem_Free(buf); /* allocated with PyMem_Malloc */
return res;

Nếu P là

alist = ['eggs', 2, 'juice']  # alist is reference to a new list
blist = alist # blist is a reference; changing blist affects alist
blist.append('coffee') # alist and blist both point to 
                       # ['eggs', 2, 'juice', 'coffee']

Các macro định hướng loại sau được cung cấp để thuận tiện. Lưu ý rằng loại đề cập đến bất kỳ loại C nào.

a = 2   # a is a reference to 2
b = a   # b is a reference to 'a'
b = 3   # b now points to 3, while 'a' continues to point to 2

PyObject *res;
char *buf = (char *) PyMem_Malloc(BUFSIZ); /* for I/O */

if (buf == NULL)
    return PyErr_NoMemory();
/* ...Do some I/O operation involving buf... */
res = PyBytes_FromString(buf);
PyMem_Free(buf); /* allocated with PyMem_Malloc */
return res;

Same as

a = 2   # a is a reference to 2
b = a   # b is a reference to 'a'
b = 3   # b now points to 3, while 'a' continues to point to 2

PyObject *res;
char *buf = (char *) PyMem_Malloc(BUFSIZ); /* for I/O */

if (buf == NULL)
    return PyErr_NoMemory();
/* ...Do some I/O operation involving buf... */
res = PyBytes_FromString(buf);
PyMem_Free(buf); /* allocated with PyMem_Malloc */
return res;

PyObject *res;
char *buf = (char *) malloc(BUFSIZ); /* for I/O */

if (buf == NULL)
    return PyErr_NoMemory();
...Do some I/O operation involving buf...
res = PyBytes_FromString(buf);
free(buf); /* malloc'ed */
return res;

PyObject *res;
char *buf = PyMem_New(char, BUFSIZ); /* for I/O */

if (buf == NULL)
    return PyErr_NoMemory();
/* ...Do some I/O operation involving buf... */
res = PyBytes_FromString(buf);
PyMem_Del(buf); /* allocated with PyMem_New */
return res;

alist = ['eggs', 2, 'juice']  # alist is reference to a new list
blist = alist # blist is a reference; changing blist affects alist
blist.append('coffee') # alist and blist both point to 
                       # ['eggs', 2, 'juice', 'coffee']

Same as

PyObject *res;
char *buf = (char *) malloc(BUFSIZ); /* for I/O */

if (buf == NULL)
    return PyErr_NoMemory();
...Do some I/O operation involving buf...
res = PyBytes_FromString(buf);
free(buf); /* malloc'ed */
return res;

PyObject *res;
char *buf = PyMem_New(char, BUFSIZ); /* for I/O */

if (buf == NULL)
    return PyErr_NoMemory();
/* ...Do some I/O operation involving buf... */
res = PyBytes_FromString(buf);
PyMem_Del(buf); /* allocated with PyMem_New */
return res;

alist = ['eggs', 2, 'juice']  # alist is reference to a new list
blist = alist # blist is a reference; changing blist affects alist
blist.append('coffee') # alist and blist both point to 
                       # ['eggs', 2, 'juice', 'coffee']

Đây là một macro tiền xử lý C; P luôn được chỉ định lại. Lưu giá trị ban đầu của P để tránh mất bộ nhớ khi xử lý lỗi.

a = 2   # a is a reference to 2
b = a   # b is a reference to 'a'
b = 3   # b now points to 3, while 'a' continues to point to 2

Same as

a = 2   # a is a reference to 2
b = a   # b is a reference to 'a'
b = 3   # b now points to 3, while 'a' continues to point to 2

Ngoài ra, các bộ macro sau được cung cấp để gọi trực tiếp bộ phân bổ bộ nhớ Python, mà không liên quan đến các hàm A API được liệt kê ở trên. Tuy nhiên, lưu ý rằng việc sử dụng của chúng không bảo tồn khả năng tương thích nhị phân trên các phiên bản Python và do đó không được dùng trong các mô -đun mở rộng.

• PyObject *res;
  char *buf = PyMem_New(char, BUFSIZ); /* for I/O */
  
  if (buf == NULL)
      return PyErr_NoMemory();
  /* ...Do some I/O operation involving buf... */
  res = PyBytes_FromString(buf);
  PyMem_Del(buf); /* allocated with PyMem_New */
  return res;
  

  3

• PyObject *res;
  char *buf = PyMem_New(char, BUFSIZ); /* for I/O */
  
  if (buf == NULL)
      return PyErr_NoMemory();
  /* ...Do some I/O operation involving buf... */
  res = PyBytes_FromString(buf);
  PyMem_Del(buf); /* allocated with PyMem_New */
  return res;
  

  4

• PyObject *res;
  char *buf = PyMem_New(char, BUFSIZ); /* for I/O */
  
  if (buf == NULL)
      return PyErr_NoMemory();
  /* ...Do some I/O operation involving buf... */
  res = PyBytes_FromString(buf);
  PyMem_Del(buf); /* allocated with PyMem_New */
  return res;
  

  5

• PyObject *res;
  char *buf = PyMem_New(char, BUFSIZ); /* for I/O */
  
  if (buf == NULL)
      return PyErr_NoMemory();
  /* ...Do some I/O operation involving buf... */
  res = PyBytes_FromString(buf);
  PyMem_Del(buf); /* allocated with PyMem_New */
  return res;
  

  6

• PyObject *res;
  char *buf = PyMem_New(char, BUFSIZ); /* for I/O */
  
  if (buf == NULL)
      return PyErr_NoMemory();
  /* ...Do some I/O operation involving buf... */
  res = PyBytes_FromString(buf);
  PyMem_Del(buf); /* allocated with PyMem_New */
  return res;
  

  7

• PyObject *res;
  char *buf = PyMem_New(char, BUFSIZ); /* for I/O */
  
  if (buf == NULL)
      return PyErr_NoMemory();
  /* ...Do some I/O operation involving buf... */
  res = PyBytes_FromString(buf);
  PyMem_Del(buf); /* allocated with PyMem_New */
  return res;
  

  8

Người phân bổ đối tượng

Các bộ chức năng sau, được mô hình hóa theo tiêu chuẩn ANSI C, nhưng chỉ định hành vi khi yêu cầu 0 byte, có sẵn để phân bổ và giải phóng bộ nhớ từ đống Python.

Ghi chú

Không có gì đảm bảo rằng bộ nhớ được trả về bởi các phân bổ này có thể được chuyển thành công vào một đối tượng Python khi chặn các hàm phân bổ trong miền này bằng các phương thức được mô tả trong phần phân bổ bộ nhớ tùy chỉnh.Customize Memory Allocators section.

Trình phân bổ đối tượng mặc định sử dụng Trình phân bổ bộ nhớ Pymalloc.default object allocator uses the pymalloc memory allocator.

Cảnh báo

GIL phải được giữ khi sử dụng các chức năng này.GIL must be held when using these functions.

Phân bổ n byte và trả về một con trỏ khoảng trống* cho bộ nhớ được phân bổ hoặc

alist = ['eggs', 2, 'juice']  # alist is reference to a new list
blist = alist # blist is a reference; changing blist affects alist
blist.append('coffee') # alist and blist both point to 
                       # ['eggs', 2, 'juice', 'coffee']

alist = ['eggs', 2, 'juice']  # alist is reference to a new list
blist = alist # blist is a reference; changing blist affects alist
blist.append('coffee') # alist and blist both point to 
                       # ['eggs', 2, 'juice', 'coffee']

Yêu cầu Zero Byte trả về một con trỏ không khác biệt nếu có thể, như thể

char *buf1 = PyMem_New(char, BUFSIZ);
char *buf2 = (char *) malloc(BUFSIZ);
char *buf3 = (char *) PyMem_Malloc(BUFSIZ);
...
PyMem_Del(buf3);  /* Wrong -- should be PyMem_Free() */
free(buf2);       /* Right -- allocated via malloc() */
free(buf1);       /* Fatal -- should be PyMem_Del()  */

Phân bổ các phần tử nelem, mỗi phần tử có kích thước trong byte là elsize và trả về một con trỏ khoảng trống* cho bộ nhớ được phân bổ hoặc

alist = ['eggs', 2, 'juice']  # alist is reference to a new list
blist = alist # blist is a reference; changing blist affects alist
blist.append('coffee') # alist and blist both point to 
                       # ['eggs', 2, 'juice', 'coffee']

alist = ['eggs', 2, 'juice']  # alist is reference to a new list
blist = alist # blist is a reference; changing blist affects alist
blist.append('coffee') # alist and blist both point to 
                       # ['eggs', 2, 'juice', 'coffee']

Yêu cầu các phần tử bằng 0 hoặc các phần tử có kích thước 0 byte trả về một con trỏ không khác biệt khác nhau nếu có thể, như thể

char *buf1 = PyMem_New(char, BUFSIZ);
char *buf2 = (char *) malloc(BUFSIZ);
char *buf3 = (char *) PyMem_Malloc(BUFSIZ);
...
PyMem_Del(buf3);  /* Wrong -- should be PyMem_Free() */
free(buf2);       /* Right -- allocated via malloc() */
free(buf1);       /* Fatal -- should be PyMem_Del()  */

Mới trong phiên bản 3.5.

Thay đổi kích thước khối bộ nhớ được trỏ bởi p thành n byte. Các nội dung sẽ không thay đổi ở mức tối thiểu của cũ và kích thước mới.

Nếu P là

alist = ['eggs', 2, 'juice']  # alist is reference to a new list
blist = alist # blist is a reference; changing blist affects alist
blist.append('coffee') # alist and blist both point to 
                       # ['eggs', 2, 'juice', 'coffee']

PyObject *res;
char *buf = (char *) malloc(BUFSIZ); /* for I/O */

if (buf == NULL)
    return PyErr_NoMemory();
...Do some I/O operation involving buf...
res = PyBytes_FromString(buf);
free(buf); /* malloc'ed */
return res;

Trừ khi p là

alist = ['eggs', 2, 'juice']  # alist is reference to a new list
blist = alist # blist is a reference; changing blist affects alist
blist.append('coffee') # alist and blist both point to 
                       # ['eggs', 2, 'juice', 'coffee']

a = 2   # a is a reference to 2
b = a   # b is a reference to 'a'
b = 3   # b now points to 3, while 'a' continues to point to 2

PyObject *res;
char *buf = (char *) malloc(BUFSIZ); /* for I/O */

if (buf == NULL)
    return PyErr_NoMemory();
...Do some I/O operation involving buf...
res = PyBytes_FromString(buf);
free(buf); /* malloc'ed */
return res;

PyObject *res;
char *buf = (char *) malloc(BUFSIZ); /* for I/O */

if (buf == NULL)
    return PyErr_NoMemory();
...Do some I/O operation involving buf...
res = PyBytes_FromString(buf);
free(buf); /* malloc'ed */
return res;

Nếu yêu cầu không thành công,

PyObject *res;
char *buf = (char *) malloc(BUFSIZ); /* for I/O */

if (buf == NULL)
    return PyErr_NoMemory();
...Do some I/O operation involving buf...
res = PyBytes_FromString(buf);
free(buf); /* malloc'ed */
return res;

alist = ['eggs', 2, 'juice']  # alist is reference to a new list
blist = alist # blist is a reference; changing blist affects alist
blist.append('coffee') # alist and blist both point to 
                       # ['eggs', 2, 'juice', 'coffee']

Giải phóng khối bộ nhớ được chỉ bởi P, phải được trả lại bằng một cuộc gọi trước đó cho

a = 2   # a is a reference to 2
b = a   # b is a reference to 'a'
b = 3   # b now points to 3, while 'a' continues to point to 2

PyObject *res;
char *buf = (char *) malloc(BUFSIZ); /* for I/O */

if (buf == NULL)
    return PyErr_NoMemory();
...Do some I/O operation involving buf...
res = PyBytes_FromString(buf);
free(buf); /* malloc'ed */
return res;

PyObject *res;
char *buf = (char *) malloc(BUFSIZ); /* for I/O */

if (buf == NULL)
    return PyErr_NoMemory();
...Do some I/O operation involving buf...
res = PyBytes_FromString(buf);
free(buf); /* malloc'ed */
return res;

PyObject *res;
char *buf = (char *) PyMem_Malloc(BUFSIZ); /* for I/O */

if (buf == NULL)
    return PyErr_NoMemory();
/* ...Do some I/O operation involving buf... */
res = PyBytes_FromString(buf);
PyMem_Free(buf); /* allocated with PyMem_Malloc */
return res;

Nếu P là

alist = ['eggs', 2, 'juice']  # alist is reference to a new list
blist = alist # blist is a reference; changing blist affects alist
blist.append('coffee') # alist and blist both point to 
                       # ['eggs', 2, 'juice', 'coffee']

Phân bổ bộ nhớ mặc định

Bộ phân bổ bộ nhớ mặc định:

a = 2   # a is a reference to 2
b = a   # b is a reference to 'a'
b = 3   # b now points to 3, while 'a' continues to point to 2

a = 2   # a is a reference to 2
b = a   # b is a reference to 'a'
b = 3   # b now points to 3, while 'a' continues to point to 2

a = 2   # a is a reference to 2
b = a   # b is a reference to 'a'
b = 3   # b now points to 3, while 'a' continues to point to 2

a = 2   # a is a reference to 2
b = a   # b is a reference to 'a'
b = 3   # b now points to 3, while 'a' continues to point to 2

a = 2   # a is a reference to 2
b = a   # b is a reference to 'a'
b = 3   # b now points to 3, while 'a' continues to point to 2

a = 2   # a is a reference to 2
b = a   # b is a reference to 'a'
b = 3   # b now points to 3, while 'a' continues to point to 2

a = 2   # a is a reference to 2
b = a   # b is a reference to 'a'
b = 3   # b now points to 3, while 'a' continues to point to 2

a = 2   # a is a reference to 2
b = a   # b is a reference to 'a'
b = 3   # b now points to 3, while 'a' continues to point to 2

a = 2   # a is a reference to 2
b = a   # b is a reference to 'a'
b = 3   # b now points to 3, while 'a' continues to point to 2

a = 2   # a is a reference to 2
b = a   # b is a reference to 'a'
b = 3   # b now points to 3, while 'a' continues to point to 2

a = 2   # a is a reference to 2
b = a   # b is a reference to 'a'
b = 3   # b now points to 3, while 'a' continues to point to 2

a = 2   # a is a reference to 2
b = a   # b is a reference to 'a'
b = 3   # b now points to 3, while 'a' continues to point to 2

a = 2   # a is a reference to 2
b = a   # b is a reference to 'a'
b = 3   # b now points to 3, while 'a' continues to point to 2

a = 2   # a is a reference to 2
b = a   # b is a reference to 'a'
b = 3   # b now points to 3, while 'a' continues to point to 2

a = 2   # a is a reference to 2
b = a   # b is a reference to 'a'
b = 3   # b now points to 3, while 'a' continues to point to 2

Legend:

• a = 2   # a is a reference to 2
  b = a   # b is a reference to 'a'
  b = 3   # b now points to 3, while 'a' continues to point to 2
  

  01 + gỡ lỗi

  a = 2   # a is a reference to 2
  b = a   # b is a reference to 'a'
  b = 3   # b now points to 3, while 'a' continues to point to 2
  

  3 environment variable.

• Phát hành bản dựng, không có pymalloc

• Gỡ lỗi xây dựng, không có pymallocpymalloc memory allocator.

• Tên: Giá trị cho biến môi trường

  a = 2   # a is a reference to 2
  b = a   # b is a reference to 'a'
  b = 3   # b now points to 3, while 'a' continues to point to 2
  

  3.debug hooks on the Python memory allocators.

• a = 2   # a is a reference to 2
  b = a   # b is a reference to 'a'
  b = 3   # b now points to 3, while 'a' continues to point to 2
  

  00: Bộ phân bổ hệ thống từ thư viện C tiêu chuẩn, hàm C: malloc(),

  a = 2   # a is a reference to 2
  b = a   # b is a reference to 'a'
  b = 3   # b now points to 3, while 'a' continues to point to 2
  

  0,

  a = 2   # a is a reference to 2
  b = a   # b is a reference to 'a'
  b = 3   # b now points to 3, while 'a' continues to point to 2
  

  1 và

  a = 2   # a is a reference to 2
  b = a   # b is a reference to 'a'
  b = 3   # b now points to 3, while 'a' continues to point to 2
  

  2.Python build in debug mode.

a = 2 # a is a reference to 2 b = a # b is a reference to 'a' b = 3 # b now points to 3, while 'a' continues to point to 2 01: Bộ phân bổ bộ nhớ Pymalloc.

Cấm+ DEBUG: với các móc gỡ lỗi trên các bộ phân bổ bộ nhớ Python.

Structure used to describe a memory block allocator. The structure has the following fields:

a = 2   # a is a reference to 2
b = a   # b is a reference to 'a'
b = 3   # b now points to 3, while 'a' continues to point to 2

a = 2   # a is a reference to 2
b = a   # b is a reference to 'a'
b = 3   # b now points to 3, while 'a' continues to point to 2

a = 2   # a is a reference to 2
b = a   # b is a reference to 'a'
b = 3   # b now points to 3, while 'a' continues to point to 2

a = 2   # a is a reference to 2
b = a   # b is a reference to 'a'
b = 3   # b now points to 3, while 'a' continues to point to 2

a = 2   # a is a reference to 2
b = a   # b is a reference to 'a'
b = 3   # b now points to 3, while 'a' continues to point to 2

Phân bổ một khối bộ nhớ được khởi tạo bằng các số khôngThe

a = 2   # a is a reference to 2
b = a   # b is a reference to 'a'
b = 3   # b now points to 3, while 'a' continues to point to 2

a = 2   # a is a reference to 2
b = a   # b is a reference to 'a'
b = 3   # b now points to 3, while 'a' continues to point to 2

a = 2   # a is a reference to 2
b = a   # b is a reference to 'a'
b = 3   # b now points to 3, while 'a' continues to point to 2

Enum used to identify an allocator domain. Domains:

Functions:

• a = 2   # a is a reference to 2
  b = a   # b is a reference to 'a'
  b = 3   # b now points to 3, while 'a' continues to point to 2
  

  6

• new_list4k = [None]*4096 # initialize to list of 4096 None's 
  new_list4k = [0]*4096    # initialize to 4096 0's
  big_list = []
  big_list.extend(new_list4k) # resizes big_list to accomodate at least 4k items
  

  7

• new_list4k = [None]*4096 # initialize to list of 4096 None's 
  new_list4k = [0]*4096    # initialize to 4096 0's
  big_list = []
  big_list.extend(new_list4k) # resizes big_list to accomodate at least 4k items
  

  8

• a = 2   # a is a reference to 2
  b = a   # b is a reference to 'a'
  b = 3   # b now points to 3, while 'a' continues to point to 2
  

  33

a = 2   # a is a reference to 2
b = a   # b is a reference to 'a'
b = 3   # b now points to 3, while 'a' continues to point to 2

a = 2   # a is a reference to 2
b = a   # b is a reference to 'a'
b = 3   # b now points to 3, while 'a' continues to point to 2

a = 2   # a is a reference to 2
b = a   # b is a reference to 'a'
b = 3   # b now points to 3, while 'a' continues to point to 2

Functions:

• a = 2   # a is a reference to 2
  b = a   # b is a reference to 'a'
  b = 3   # b now points to 3, while 'a' continues to point to 2
  

  9,

• PyObject *res;
  char *buf = (char *) malloc(BUFSIZ); /* for I/O */
  
  if (buf == NULL)
      return PyErr_NoMemory();
  ...Do some I/O operation involving buf...
  res = PyBytes_FromString(buf);
  free(buf); /* malloc'ed */
  return res;
  

  8

• PyObject *res;
  char *buf = (char *) malloc(BUFSIZ); /* for I/O */
  
  if (buf == NULL)
      return PyErr_NoMemory();
  ...Do some I/O operation involving buf...
  res = PyBytes_FromString(buf);
  free(buf); /* malloc'ed */
  return res;
  

  9

• a = 2   # a is a reference to 2
  b = a   # b is a reference to 'a'
  b = 3   # b now points to 3, while 'a' continues to point to 2
  

  8

Functions:

• a = 2   # a is a reference to 2
  b = a   # b is a reference to 'a'
  b = 3   # b now points to 3, while 'a' continues to point to 2
  

  7

• malloc()0

• malloc()1

• a = 2   # a is a reference to 2
  b = a   # b is a reference to 'a'
  b = 3   # b now points to 3, while 'a' continues to point to 2
  

  41

Get the memory block allocator of the specified domain.

Set the memory block allocator of the specified domain.

Pymem_domain_obj¶fnes:

VoidPymem_Getallocator (pymemallocatordomaindomain, pymemallocatorex*ALLOCATOR) Ăn bộ phân bổ khối bộ nhớ của miền được chỉ định.GIL is not held when the allocator is called.

Voidpymem_setallocator (PymemallocatorDomAINDOMAIN, PYMEMALLOCATOREX*ALLOCATOR) ¶ Set Trình phân bổ khối bộ nhớ của miền được chỉ định.

Bộ phân bổ mới phải trả về một con trỏ không khác nhau khi yêu cầu số không byte.Preinitialize Python with PyPreConfig.

Đối với miền

a = 2   # a is a reference to 2
b = a   # b is a reference to 'a'
b = 3   # b now points to 3, while 'a' continues to point to 2

Nếu bộ phân bổ mới không phải là một móc (không gọi trình phân bổ trước đó), hàm

a = 2   # a is a reference to 2
b = a   # b is a reference to 'a'
b = 3   # b now points to 3, while 'a' continues to point to 2

• Xem thêm

  a = 2   # a is a reference to 2
  b = a   # b is a reference to 'a'
  b = 3   # b now points to 3, while 'a' continues to point to 2
  

  45 và preinitialize python với pypreconfig.the section on allocator domains for more information.

• Cảnh báomust wrap the existing allocator. Substituting the current allocator for some other arbitrary one is not supported.

a = 2   # a is a reference to 2
b = a   # b is a reference to 'a'
b = 3   # b now points to 3, while 'a' continues to point to 2

Setup debug hooks in the Python memory allocators to detect memory errors.

Nó có thể được gọi sau a = 2 # a is a reference to 2 b = a # b is a reference to 'a' b = 3 # b now points to 3, while 'a' continues to point to 2 47 và trước a = 2 # a is a reference to 2 b = a # b is a reference to 'a' b = 3 # b now points to 3, while 'a' continues to point to 2 48 để cài đặt bộ phân bổ bộ nhớ tùy chỉnh. Không có giới hạn đối với bộ phân bổ được cài đặt khác với các bộ phân bổ được áp đặt bởi tên miền (ví dụ, miền RAW cho phép bộ phân bổ được gọi mà không cần GiL giữ). Xem phần trên các miền phân bổ để biết thêm thông tin.

Nếu được gọi sau khi Python đã hoàn thành khởi tạo (sau khi

a = 2   # a is a reference to 2
b = a   # b is a reference to 'a'
b = 3   # b now points to 3, while 'a' continues to point to 2

a = 2   # a is a reference to 2
b = a   # b is a reference to 'a'
b = 3   # b now points to 3, while 'a' continues to point to 2

Voidpymem_setupdebughooks (void) ¶setUp Debug Hook trong các trình phân bổ bộ nhớ Python để phát hiện các lỗi bộ nhớ.

a = 2   # a is a reference to 2
b = a   # b is a reference to 'a'
b = 3   # b now points to 3, while 'a' continues to point to 2

a = 2   # a is a reference to 2
b = a   # b is a reference to 'a'
b = 3   # b now points to 3, while 'a' continues to point to 2

Gỡ lỗi móc vào bộ phân bổ bộ nhớ Python

Khi Python được xây dựng ở chế độ gỡ lỗi, hàm

a = 2   # a is a reference to 2
b = a   # b is a reference to 'a'
b = 3   # b now points to 3, while 'a' continues to point to 2

Biến môi trường

a = 2   # a is a reference to 2
b = a   # b is a reference to 'a'
b = 3   # b now points to 3, while 'a' continues to point to 2

a = 2   # a is a reference to 2
b = a   # b is a reference to 'a'
b = 3   # b now points to 3, while 'a' continues to point to 2

• Hàm

  a = 2   # a is a reference to 2
  b = a   # b is a reference to 'a'
  b = 3   # b now points to 3, while 'a' continues to point to 2
  

  44 có thể được sử dụng để đặt các móc gỡ lỗi sau khi gọi

  a = 2   # a is a reference to 2
  b = a   # b is a reference to 'a'
  b = 3   # b now points to 3, while 'a' continues to point to 2
  

  46.

• Các móc gỡ lỗi này lấp đầy các khối bộ nhớ được phân bổ động với các mẫu bit đặc biệt, dễ nhận biết. Bộ nhớ mới được phân bổ được lấp đầy bằng byte

  a = 2   # a is a reference to 2
  b = a   # b is a reference to 'a'
  b = 3   # b now points to 3, while 'a' continues to point to 2
  

  55 (

  a = 2   # a is a reference to 2
  b = a   # b is a reference to 'a'
  b = 3   # b now points to 3, while 'a' continues to point to 2
  

  56), bộ nhớ được giải phóng được lấp đầy bằng byte

  a = 2   # a is a reference to 2
  b = a   # b is a reference to 'a'
  b = 3   # b now points to 3, while 'a' continues to point to 2
  

  57 (

  a = 2   # a is a reference to 2
  b = a   # b is a reference to 'a'
  b = 3   # b now points to 3, while 'a' continues to point to 2
  

  58). Các khối bộ nhớ được bao quanh bởi các byte bị cấm của các byte, chứa đầy byte

  a = 2   # a is a reference to 2
  b = a   # b is a reference to 'a'
  b = 3   # b now points to 3, while 'a' continues to point to 2
  

  59 (

  a = 2   # a is a reference to 2
  b = a   # b is a reference to 'a'
  b = 3   # b now points to 3, while 'a' continues to point to 2
  

  60). Các chuỗi của các byte này khó có thể là các địa chỉ, phao hoặc chuỗi ASCII hợp lệ.

• Kiểm tra thời gian chạy:

• Phát hiện vi phạm API. Ví dụ: phát hiện nếu

  a = 2   # a is a reference to 2
  b = a   # b is a reference to 'a'
  b = 3   # b now points to 3, while 'a' continues to point to 2
  

  41 được gọi trên khối bộ nhớ được phân bổ bởi

  a = 2   # a is a reference to 2
  b = a   # b is a reference to 'a'
  b = 3   # b now points to 3, while 'a' continues to point to 2
  

  9.GIL is held when allocator functions of

  a = 2   # a is a reference to 2
  b = a   # b is a reference to 'a'
  b = 3   # b now points to 3, while 'a' continues to point to 2
  

  63 (ex:

  a = 2   # a is a reference to 2
  b = a   # b is a reference to 'a'
  b = 3   # b now points to 3, while 'a' continues to point to 2
  

  7) and

  a = 2   # a is a reference to 2
  b = a   # b is a reference to 'a'
  b = 3   # b now points to 3, while 'a' continues to point to 2
  

  65 (ex:

  a = 2   # a is a reference to 2
  b = a   # b is a reference to 'a'
  b = 3   # b now points to 3, while 'a' continues to point to 2
  

  9) domains are called.

Phát hiện ghi trước khi bắt đầu bộ đệm (bộ đệm dưới dòng).

Phát hiện ghi sau khi kết thúc bộ đệm (tràn bộ đệm).

a = 2   # a is a reference to 2
b = a   # b is a reference to 'a'
b = 3   # b now points to 3, while 'a' continues to point to 2

Số byte ban đầu yêu cầu. Đây là một size_t, Big-endian (dễ đọc hơn trong kết xuất bộ nhớ).

a = 2   # a is a reference to 2
b = a   # b is a reference to 'a'
b = 3   # b now points to 3, while 'a' continues to point to 2

Định danh API (ký tự ASCII):

• a = 2   # a is a reference to 2
  b = a   # b is a reference to 'a'
  b = 3   # b now points to 3, while 'a' continues to point to 2
  

  76 cho

  a = 2   # a is a reference to 2
  b = a   # b is a reference to 'a'
  b = 3   # b now points to 3, while 'a' continues to point to 2
  

  43.

• a = 2   # a is a reference to 2
  b = a   # b is a reference to 'a'
  b = 3   # b now points to 3, while 'a' continues to point to 2
  

  78 cho

  a = 2   # a is a reference to 2
  b = a   # b is a reference to 'a'
  b = 3   # b now points to 3, while 'a' continues to point to 2
  

  65.

• a = 2   # a is a reference to 2
  b = a   # b is a reference to 'a'
  b = 3   # b now points to 3, while 'a' continues to point to 2
  

  80 cho

  a = 2   # a is a reference to 2
  b = a   # b is a reference to 'a'
  b = 3   # b now points to 3, while 'a' continues to point to 2
  

  63.

a = 2   # a is a reference to 2
b = a   # b is a reference to 'a'
b = 3   # b now points to 3, while 'a' continues to point to 2

Bản sao của pymem_forbiddenbyte. Được sử dụng để bắt dưới và đọc.

a = 2   # a is a reference to 2
b = a   # b is a reference to 'a'
b = 3   # b now points to 3, while 'a' continues to point to 2

Bộ nhớ được yêu cầu, chứa đầy các bản sao của pymem_cleanbyte, được sử dụng để bắt tham chiếu đến bộ nhớ không được hưởng. Khi một hàm giống như realloc được gọi là yêu cầu một khối bộ nhớ lớn hơn, các byte vượt quá mới cũng được lấp đầy bằng pymem_cleanbyte. Khi một hàm giống như tự do được gọi, chúng được ghi đè bằng pymem_deadbyte, để bắt tham chiếu đến bộ nhớ tự do. Khi một hàm giống như realloc được gọi là yêu cầu một khối bộ nhớ nhỏ hơn, các byte cũ dư thừa cũng được lấp đầy bằng pymem_deadbyte.

a = 2   # a is a reference to 2
b = a   # b is a reference to 'a'
b = 3   # b now points to 3, while 'a' continues to point to 2

Bản sao của pymem_forbiddenbyte. Được sử dụng để bắt quá mức và đọc.

a = 2   # a is a reference to 2
b = a   # b is a reference to 'a'
b = 3   # b now points to 3, while 'a' continues to point to 2

Chỉ được sử dụng nếu macro

a = 2   # a is a reference to 2
b = a   # b is a reference to 'a'
b = 3   # b now points to 3, while 'a' continues to point to 2

Một số sê-ri, được tăng thêm 1 trên mỗi cuộc gọi đến hàm giống như malloc hoặc giống như Realloc. Lớn

a = 2   # a is a reference to 2
b = a   # b is a reference to 'a'
b = 3   # b now points to 3, while 'a' continues to point to 2

Một hàm giống như realloc hoặc giống như tự do trước tiên kiểm tra xem các byte pymem_forbiddenbyte ở mỗi đầu có còn nguyên vẹn không. Nếu họ đã bị thay đổi, đầu ra chẩn đoán được ghi vào stderr và chương trình bị hủy bỏ thông qua py_fatalerror (). Chế độ thất bại chính khác đang gây ra lỗi bộ nhớ khi một chương trình đọc một trong các mẫu bit đặc biệt và cố gắng sử dụng nó làm địa chỉ. Nếu bạn nhận được một trình gỡ lỗi sau đó và nhìn vào đối tượng, bạn có thể thấy rằng nó hoàn toàn chứa đầy pymem_deadbyte (có nghĩa là bộ nhớ được giải phóng đang được sử dụng) hoặc pymem_cleanbyte (có nghĩa là bộ nhớ không được sử dụng).

Đã thay đổi trong phiên bản 3.6: Hàm

a = 2   # a is a reference to 2
b = a   # b is a reference to 'a'
b = 3   # b now points to 3, while 'a' continues to point to 2

a = 2   # a is a reference to 2
b = a   # b is a reference to 'a'
b = 3   # b now points to 3, while 'a' continues to point to 2

a = 2   # a is a reference to 2
b = a   # b is a reference to 'a'
b = 3   # b now points to 3, while 'a' continues to point to 2

a = 2   # a is a reference to 2
b = a   # b is a reference to 'a'
b = 3   # b now points to 3, while 'a' continues to point to 2

a = 2   # a is a reference to 2
b = a   # b is a reference to 'a'
b = 3   # b now points to 3, while 'a' continues to point to 2

a = 2   # a is a reference to 2
b = a   # b is a reference to 'a'
b = 3   # b now points to 3, while 'a' continues to point to 2

a = 2   # a is a reference to 2
b = a   # b is a reference to 'a'
b = 3   # b now points to 3, while 'a' continues to point to 2

a = 2   # a is a reference to 2
b = a   # b is a reference to 'a'
b = 3   # b now points to 3, while 'a' continues to point to 2

Thay đổi trong phiên bản 3.8: Các mẫu byte

a = 2   # a is a reference to 2
b = a   # b is a reference to 'a'
b = 3   # b now points to 3, while 'a' continues to point to 2

a = 2   # a is a reference to 2
b = a   # b is a reference to 'a'
b = 3   # b now points to 3, while 'a' continues to point to 2

a = 2   # a is a reference to 2
b = a   # b is a reference to 'a'
b = 3   # b now points to 3, while 'a' continues to point to 2

a = 2   # a is a reference to 2
b = a   # b is a reference to 'a'
b = 3   # b now points to 3, while 'a' continues to point to 2

a = 2   # a is a reference to 2
b = a   # b is a reference to 'a'
b = 3   # b now points to 3, while 'a' continues to point to 2

a = 2   # a is a reference to 2
b = a   # b is a reference to 'a'
b = 3   # b now points to 3, while 'a' continues to point to 2

a = 2   # a is a reference to 2
b = a   # b is a reference to 'a'
b = 3   # b now points to 3, while 'a' continues to point to 2

a = 2   # a is a reference to 2
b = a   # b is a reference to 'a'
b = 3   # b now points to 3, while 'a' continues to point to 2

a = 2   # a is a reference to 2
b = a   # b is a reference to 'a'
b = 3   # b now points to 3, while 'a' continues to point to 2

a = 2   # a is a reference to 2
b = a   # b is a reference to 'a'
b = 3   # b now points to 3, while 'a' continues to point to 2

a = 2   # a is a reference to 2
b = a   # b is a reference to 'a'
b = 3   # b now points to 3, while 'a' continues to point to 2

a = 2   # a is a reference to 2
b = a   # b is a reference to 'a'
b = 3   # b now points to 3, while 'a' continues to point to 2

a = 2   # a is a reference to 2
b = a   # b is a reference to 'a'
b = 3   # b now points to 3, while 'a' continues to point to 2

a = 2   # a is a reference to 2
b = a   # b is a reference to 'a'
b = 3   # b now points to 3, while 'a' continues to point to 2

a = 2   # a is a reference to 2
b = a   # b is a reference to 'a'
b = 3   # b now points to 3, while 'a' continues to point to 2

a = 2   # a is a reference to 2
b = a   # b is a reference to 'a'
b = 3   # b now points to 3, while 'a' continues to point to 2

a = 2   # a is a reference to 2
b = a   # b is a reference to 'a'
b = 3   # b now points to 3, while 'a' continues to point to 2

a = 2   # a is a reference to 2
b = a   # b is a reference to 'a'
b = 3   # b now points to 3, while 'a' continues to point to 2

a = 2   # a is a reference to 2
b = a   # b is a reference to 'a'
b = 3   # b now points to 3, while 'a' continues to point to 2

Người phân bổ pymalloc

Python có bộ phân bổ pymalloc được tối ưu hóa cho các đối tượng nhỏ (nhỏ hơn hoặc bằng 512 byte) với tuổi thọ ngắn. Nó sử dụng các ánh xạ bộ nhớ được gọi là đấu trường trên mạng với kích thước cố định là 256 kib. Nó rơi trở lại

a = 2   # a is a reference to 2
b = a   # b is a reference to 'a'
b = 3   # b now points to 3, while 'a' continues to point to 2

new_list4k = [None]*4096 # initialize to list of 4096 None's 
new_list4k = [0]*4096    # initialize to 4096 0's
big_list = []
big_list.extend(new_list4k) # resizes big_list to accomodate at least 4k items

Pymalloc là bộ phân bổ mặc định của các miền

a = 2   # a is a reference to 2
b = a   # b is a reference to 'a'
b = 3   # b now points to 3, while 'a' continues to point to 2

a = 2   # a is a reference to 2
b = a   # b is a reference to 'a'
b = 3   # b now points to 3, while 'a' continues to point to 2

a = 2   # a is a reference to 2
b = a   # b is a reference to 'a'
b = 3   # b now points to 3, while 'a' continues to point to 2

a = 2   # a is a reference to 2
b = a   # b is a reference to 'a'
b = 3   # b now points to 3, while 'a' continues to point to 2

a = 2   # a is a reference to 2
b = a   # b is a reference to 'a'
b = 3   # b now points to 3, while 'a' continues to point to 2

a = 2   # a is a reference to 2
b = a   # b is a reference to 'a'
b = 3   # b now points to 3, while 'a' continues to point to 2

a = 2   # a is a reference to 2
b = a   # b is a reference to 'a'
b = 3   # b now points to 3, while 'a' continues to point to 2

a = 2   # a is a reference to 2
b = a   # b is a reference to 'a'
b = 3   # b now points to 3, while 'a' continues to point to 2

Trình phân bổ đấu trường sử dụng các chức năng sau:

• alist = ['eggs', 2, 'juice']  # alist is reference to a new list
  blist = alist # blist is a reference; changing blist affects alist
  blist.append('coffee') # alist and blist both point to 
                         # ['eggs', 2, 'juice', 'coffee']
  

  09 và

  alist = ['eggs', 2, 'juice']  # alist is reference to a new list
  blist = alist # blist is a reference; changing blist affects alist
  blist.append('coffee') # alist and blist both point to 
                         # ['eggs', 2, 'juice', 'coffee']
  

  10 trên Windows,

• alist = ['eggs', 2, 'juice']  # alist is reference to a new list
  blist = alist # blist is a reference; changing blist affects alist
  blist.append('coffee') # alist and blist both point to 
                         # ['eggs', 2, 'juice', 'coffee']
  

  11 và

  alist = ['eggs', 2, 'juice']  # alist is reference to a new list
  blist = alist # blist is a reference; changing blist affects alist
  blist.append('coffee') # alist and blist both point to 
                         # ['eggs', 2, 'juice', 'coffee']
  

  12 nếu có,

• malloc() và

  a = 2   # a is a reference to 2
  b = a   # b is a reference to 'a'
  b = 3   # b now points to 3, while 'a' continues to point to 2
  

  2 khác.

Bộ phân bổ này bị vô hiệu hóa nếu Python được cấu hình với tùy chọn

alist = ['eggs', 2, 'juice']  # alist is reference to a new list
blist = alist # blist is a reference; changing blist affects alist
blist.append('coffee') # alist and blist both point to 
                       # ['eggs', 2, 'juice', 'coffee']

a = 2   # a is a reference to 2
b = a   # b is a reference to 'a'
b = 3   # b now points to 3, while 'a' continues to point to 2

alist = ['eggs', 2, 'juice']  # alist is reference to a new list
blist = alist # blist is a reference; changing blist affects alist
blist.append('coffee') # alist and blist both point to 
                       # ['eggs', 2, 'juice', 'coffee']

a = 2   # a is a reference to 2
b = a   # b is a reference to 'a'
b = 3   # b now points to 3, while 'a' continues to point to 2

alist = ['eggs', 2, 'juice']  # alist is reference to a new list
blist = alist # blist is a reference; changing blist affects alist
blist.append('coffee') # alist and blist both point to 
                       # ['eggs', 2, 'juice', 'coffee']

a = 2   # a is a reference to 2
b = a   # b is a reference to 'a'
b = 3   # b now points to 3, while 'a' continues to point to 2

alist = ['eggs', 2, 'juice']  # alist is reference to a new list
blist = alist # blist is a reference; changing blist affects alist
blist.append('coffee') # alist and blist both point to 
                       # ['eggs', 2, 'juice', 'coffee']

alist = ['eggs', 2, 'juice']  # alist is reference to a new list
blist = alist # blist is a reference; changing blist affects alist
blist.append('coffee') # alist and blist both point to 
                       # ['eggs', 2, 'juice', 'coffee']

tracemalloc c api¶

Mới trong phiên bản 3.7.

a = 2   # a is a reference to 2
b = a   # b is a reference to 'a'
b = 3   # b now points to 3, while 'a' continues to point to 2

Track an allocated memory block in the

a = 2   # a is a reference to 2
b = a   # b is a reference to 'a'
b = 3   # b now points to 3, while 'a' continues to point to 2

Trả về

alist = ['eggs', 2, 'juice']  # alist is reference to a new list
blist = alist # blist is a reference; changing blist affects alist
blist.append('coffee') # alist and blist both point to 
                       # ['eggs', 2, 'juice', 'coffee']

alist = ['eggs', 2, 'juice']  # alist is reference to a new list
blist = alist # blist is a reference; changing blist affects alist
blist.append('coffee') # alist and blist both point to 
                       # ['eggs', 2, 'juice', 'coffee']

alist = ['eggs', 2, 'juice']  # alist is reference to a new list
blist = alist # blist is a reference; changing blist affects alist
blist.append('coffee') # alist and blist both point to 
                       # ['eggs', 2, 'juice', 'coffee']

Nếu khối bộ nhớ đã được theo dõi, hãy cập nhật dấu vết hiện có.

a = 2   # a is a reference to 2
b = a   # b is a reference to 'a'
b = 3   # b now points to 3, while 'a' continues to point to 2

Untrack an allocated memory block in the

a = 2   # a is a reference to 2
b = a   # b is a reference to 'a'
b = 3   # b now points to 3, while 'a' continues to point to 2

Trả về

alist = ['eggs', 2, 'juice']  # alist is reference to a new list
blist = alist # blist is a reference; changing blist affects alist
blist.append('coffee') # alist and blist both point to 
                       # ['eggs', 2, 'juice', 'coffee']

alist = ['eggs', 2, 'juice']  # alist is reference to a new list
blist = alist # blist is a reference; changing blist affects alist
blist.append('coffee') # alist and blist both point to 
                       # ['eggs', 2, 'juice', 'coffee']

Ví dụ;

Dưới đây là ví dụ từ phần tổng quan, viết lại để bộ đệm I/O được phân bổ từ đống python bằng cách sử dụng bộ chức năng đầu tiên:Overview, rewritten so that the I/O buffer is allocated from the Python heap by using the first function set:

PyObject *res;
char *buf = (char *) PyMem_Malloc(BUFSIZ); /* for I/O */

if (buf == NULL)
    return PyErr_NoMemory();
/* ...Do some I/O operation involving buf... */
res = PyBytes_FromString(buf);
PyMem_Free(buf); /* allocated with PyMem_Malloc */
return res;

Cùng một mã sử dụng chức năng định hướng loại:

PyObject *res;
char *buf = PyMem_New(char, BUFSIZ); /* for I/O */

if (buf == NULL)
    return PyErr_NoMemory();
/* ...Do some I/O operation involving buf... */
res = PyBytes_FromString(buf);
PyMem_Del(buf); /* allocated with PyMem_New */
return res;

Lưu ý rằng trong hai ví dụ ở trên, bộ đệm luôn được thao tác thông qua các hàm thuộc cùng một bộ. Thật vậy, cần phải sử dụng cùng một họ API bộ nhớ cho một khối bộ nhớ nhất định, do đó nguy cơ trộn các bộ phân phối khác nhau bị giảm xuống mức tối thiểu. Trình tự mã sau đây chứa hai lỗi, một trong số đó được dán nhãn là gây tử vong vì nó trộn hai bộ phân bổ khác nhau hoạt động trên các đống khác nhau.

char *buf1 = PyMem_New(char, BUFSIZ);
char *buf2 = (char *) malloc(BUFSIZ);
char *buf3 = (char *) PyMem_Malloc(BUFSIZ);
...
PyMem_Del(buf3);  /* Wrong -- should be PyMem_Free() */
free(buf2);       /* Right -- allocated via malloc() */
free(buf1);       /* Fatal -- should be PyMem_Del()  */

Ngoài các chức năng nhằm xử lý các khối bộ nhớ thô từ đống Python, các đối tượng trong Python được phân bổ và phát hành với

alist = ['eggs', 2, 'juice']  # alist is reference to a new list
blist = alist # blist is a reference; changing blist affects alist
blist.append('coffee') # alist and blist both point to 
                       # ['eggs', 2, 'juice', 'coffee']

alist = ['eggs', 2, 'juice']  # alist is reference to a new list
blist = alist # blist is a reference; changing blist affects alist
blist.append('coffee') # alist and blist both point to 
                       # ['eggs', 2, 'juice', 'coffee']

alist = ['eggs', 2, 'juice']  # alist is reference to a new list
blist = alist # blist is a reference; changing blist affects alist
blist.append('coffee') # alist and blist both point to 
                       # ['eggs', 2, 'juice', 'coffee']

Chúng sẽ được giải thích trong chương tiếp theo về việc xác định và thực hiện các loại đối tượng mới trong C.