Выравнивание памяти

Цели выравнивания в Numpy

Существует три варианта использования, связанных с выравниванием памяти в numpy (начиная с версии 1.14):

1. Создание структурированных типов данных с полями, выровненными как в C-структуре.
2. Ускорение операций копирования, используя присваивание uint вместо memcpy
3. Обеспечение безопасного выровненного доступа для ufunc/setitem/кода преобразования

Numpy использует две формы выравнивания для достижения этих целей: «истинное выравнивание» и «выравнивание по uint».

«Истинное» выравнивание относится к архитектурно-зависимому выравниванию эквивалентного C-типа в C. Например, в системах x64 numpy.float64 эквивалентно double в C. В большинстве систем это либо выравнивание 4, либо 8 байт (и это можно контролировать в gcc с помощью параметра malign-double). Переменная выровнена в памяти, если её смещение в памяти кратно её выравниванию. В некоторых системах (например, sparc) выравнивание памяти требуется, в других оно ускоряет работу.

«Выравнивание по uint» зависит от размера типа данных. Оно определяется как «истинное выравнивание» uint, используемого кодом копирования numpy для копирования типа данных, или как неопределённое/невыровненное, если нет эквивалентного uint. В настоящее время numpy использует uint8, uint16, uint32, uint64 и uint64 для копирования данных размером 1, 2, 4, 8, 16 байтов соответственно, и все типы данных других размеров не могут быть выровнены по uint.

Например, в системе (типичный Linux x64 gcc) тип данных numpy complex64 реализован как struct { float real, imag; }. У него «истинное» выравнивание 4 и «выравнивание по uint» 8 (равное истинному выравниванию uint64).

Примеры случаев, когда выравнивание по uint и истинное выравнивание отличаются (по умолчанию gcc linux):

тип архитектуры истинное_выравнивание uint-выравнивание —- —- ——– ——– x86_64 complex64 4 8 x86_64 float128 16 8 x86 float96 4 -

Переменные в Numpy, которые контролируют и описывают выравнивание

В numpy используются 4 релевантных случая слова align:

• Атрибут dtype.alignment (descr->alignment в C). Он призван отражать «истинное выравнивание» типа. Для всех типов данных есть зависимые от архитектуры значения по умолчанию, за исключением структурированных типов, созданных с помощью align=True, как описано ниже.
• Флаг ALIGNED массива ndarray, вычисленный в IsAligned и проверенный PyArray_ISALIGNED. Он вычисляется из dtype.alignment. Он устанавливается в True, если каждый элемент массива находится в местоположении памяти, согласованном с dtype.alignment, что имеет место, если указатель данных и все шаги массива являются кратными этому выравниванию.
• Ключевое слово align конструктора dtype, которое влияет только на структурированные массивы. Если смещения полей структуры не указаны вручную, numpy определяет их автоматически. В этом случае align=True добавляет дополнение к структуре, чтобы каждое поле было «истинно» выровнено в памяти, и устанавливает dtype.alignment в максимальное из «истинных» выравниваний полей. Это похоже на то, что обычно делают C-структуры. В противном случае, если смещения или размер элемента были заданы вручную, align=True просто проверяет, что все поля «истинно» выровнены, и что общий размер элемента кратен наибольшему выравниванию поля. В любом случае dtype.isalignedstruct также устанавливается в True.
• IsUintAligned используется для определения, является ли ndarray «выровненным по uint», аналогично тому, как IsAligned проверяет истинное выравнивание.

Последствия выравнивания

Вот как вышеперечисленные переменные используются:

1. Создание выровненных структур: для того, чтобы знать, как сместить поле при align=True, numpy обращается к field.dtype.alignment. Это включает поля, которые являются вложенными структурированными массивами.
2. Ufuncs: Если флаг ALIGNED массива равен False, ufuncs будут буферизовать/преобразовывать массив перед вычислением. Это необходимо, так как внутренние циклы ufunc обращаются к элементам напрямую, что может привести к ошибкам на некоторых архитектурах, если элементы не выровнены «истинно».
3. Функции getitem/setitem/copyswap: Подобно ufuncs, эти функции, как правило, имеют два пути кода. Если ALIGNED равен False, они будут использовать путь кода, который буферизует аргументы, чтобы они были «истинно» выровнены.
4. Код копирования с шагами: Здесь используется «выравнивание по uint». Если размер элемента массива равен 1, 2, 4, 8 или 16 байтам и массив выровнен по uint, тогда вместо этого numpy выполнит *(uintN*)dst) = *(uintN*)src) для соответствующего N. В противном случае numpy копирует, выполняя memcpy(dst, src, N).
5. Код Nditer: Поскольку он часто вызывает код копирования с шагами, он должен проверять «выравнивание по uint».
6. Код преобразования: Он проверяет «истинное» выравнивание, поскольку выполняет *dst = CASTFUNC(*src) при выравнивании. В противном случае выполняется memmove(srcval, src); dstval = CASTFUNC(srcval); memmove(dst, dstval), где dstval/srcval выровнены.

Обратите внимание, что код копирования с шагами и преобразования с шагами тесно связаны, и поэтому все обрабатываемые ими массивы должны быть и выровнены по uint, и по истинному выравниванию, хотя коду копирования требуется только выравнивание по uint, а коду преобразования — только истинное выравнивание. Если когда-либо произойдет большая переработка этого кода, было бы неплохо позволить им использовать различные выравнивания.