Модуль Bigarray

module Bigarray: sig .. end

Типы элементов

Bigarray могут содержать элементы следующих типов:

• числа с плавающей точкой половинной точности IEEE (16 бит) (Bigarray.float16_elt),
• числа с плавающей точкой одинарной точности IEEE (32 бита) (Bigarray.float32_elt),
• числа с плавающей точкой двойной точности IEEE (64 бита) (Bigarray.float64_elt),
• комплексные числа с плавающей точкой одинарной точности IEEE (2 * 32 бита) (Bigarray.complex32_elt),
• комплексные числа с плавающей точкой двойной точности IEEE (2 * 64 бита) (Bigarray.complex64_elt),
• 8-разрядные целые числа (со знаком или без знака) (Bigarray.int8_signed_elt или Bigarray.int8_unsigned_elt),
• 16-разрядные целые числа (со знаком или без знака) (Bigarray.int16_signed_elt или Bigarray.int16_unsigned_elt),
• целые числа OCaml (со знаком, 31 бит на 32-разрядных архитектурах и 63 бита на 64-разрядных архитектурах) (Bigarray.int_elt),
• 32-разрядные целые числа со знаком (Bigarray.int32_elt),
• 64-разрядные целые числа со знаком (Bigarray.int64_elt),
• целые числа со знаком, размер которых зависит от платформы (32 бита на 32-разрядных архитектурах и 64 бита на 64-разрядных архитектурах) (Bigarray.nativeint_elt).

Тип каждого элемента представлен на уровне типов одним из типов *_elt, определённых ниже (они определены с одним конструктором вместо абстрактных типов по техническим причинам, связанным с инъективностью).

type float16_elt = 

type float32_elt = 

type float64_elt = 

type int8_signed_elt = 

type int8_unsigned_elt = 

type int16_signed_elt = 

type int16_unsigned_elt = 

type int32_elt = 

type int64_elt = 

type int_elt = 

type nativeint_elt = 

type complex32_elt = 

type complex64_elt = 

type ('a, 'b) kind = 

  let zero : type a b. (a, b) kind -> a = function
    | Float32 -> 0.0 | Complex32 -> Complex.zero
    | Float64 -> 0.0 | Complex64 -> Complex.zero
    | Float16 -> 0.0
    | Int8_signed -> 0 | Int8_unsigned -> 0
    | Int16_signed -> 0 | Int16_unsigned -> 0
    | Int32 -> 0l | Int64 -> 0L
    | Int -> 0 | Nativeint -> 0n
    | Char -> '\000'

val float16 : (float, float16_elt) kind

val float32 : (float, float32_elt) kind

val float64 : (float, float64_elt) kind

val complex32 : (Complex.t, complex32_elt) kind

val complex64 : (Complex.t, complex64_elt) kind

val int8_signed : (int, int8_signed_elt) kind

val int8_unsigned : (int, int8_unsigned_elt) kind

val int16_signed : (int, int16_signed_elt) kind

val int16_unsigned : (int, int16_unsigned_elt) kind

val int : (int, int_elt) kind

val int32 : (int32, int32_elt) kind

val int64 : (int64, int64_elt) kind

val nativeint : (nativeint, nativeint_elt) kind

val char : (char, int8_unsigned_elt) kind

val kind_size_in_bytes : ('a, 'b) kind -> int

Размещение массивов

type c_layout = 

type fortran_layout = 

Поддерживаемые варианты размещения

Тип GADT 'a layout представляет один из двух поддерживаемых способов размещения в памяти: в стиле C или Fortran. Его конструкторы повторно экспортируются ниже в виде значений для обратной совместимости.

type 'a layout = 

val c_layout : c_layout layout

val fortran_layout : fortran_layout layout

Обобщённые массивы (с произвольным числом измерений)

module Genarray: sig .. end

Нульмерные массивы

module Array0: sig .. end

Одномерные массивы

module Array1: sig .. end

Двумерные массивы

module Array2: sig .. end

Трёхмерные массивы

module Array3: sig .. end

Преобразования между обобщёнными Bigarray и Bigarray фиксированной размерности

val genarray_of_array0 : ('a, 'b, 'c) Array0.t -> ('a, 'b, 'c) Genarray.t

val genarray_of_array1 : ('a, 'b, 'c) Array1.t -> ('a, 'b, 'c) Genarray.t

val genarray_of_array2 : ('a, 'b, 'c) Array2.t -> ('a, 'b, 'c) Genarray.t

val genarray_of_array3 : ('a, 'b, 'c) Array3.t -> ('a, 'b, 'c) Genarray.t

val array0_of_genarray : ('a, 'b, 'c) Genarray.t -> ('a, 'b, 'c) Array0.t

val array1_of_genarray : ('a, 'b, 'c) Genarray.t -> ('a, 'b, 'c) Array1.t

val array2_of_genarray : ('a, 'b, 'c) Genarray.t -> ('a, 'b, 'c) Array2.t

val array3_of_genarray : ('a, 'b, 'c) Genarray.t -> ('a, 'b, 'c) Array3.t

Изменение формы Bigarray

val reshape : ('a, 'b, 'c) Genarray.t ->       int array -> ('a, 'b, 'c) Genarray.t

val reshape_0 : ('a, 'b, 'c) Genarray.t -> ('a, 'b, 'c) Array0.t

val reshape_1 : ('a, 'b, 'c) Genarray.t -> int -> ('a, 'b, 'c) Array1.t

val reshape_2 : ('a, 'b, 'c) Genarray.t ->       int -> int -> ('a, 'b, 'c) Array2.t

val reshape_3 : ('a, 'b, 'c) Genarray.t ->       int -> int -> int -> ('a, 'b, 'c) Array3.t

Bigarray и безопасность при параллельном выполнении

При одновременном доступе к Bigarray из нескольких доменов следует соблюдать осторожность: доступ к Bigarray никогда не приведёт к аварийному завершению программы, однако несинхронизированный доступ может давать неожиданные результаты, не согласованные с последовательным выполнением.

Атомарность

Операции над Bigarray, обращающиеся более чем к одному элементу массива, не являются атомарными. К ним относятся нарезка, копирование блоков и заполнение Bigarray.

Например, рассмотрим следующую программу:

open Bigarray
let size = 100_000_000
let a = Array1.init Int C_layout size (fun _ -> 1)
let update f a () =
  for i = 0 to size - 1 do a.{i} <- f a.{i} done
let d1 = Domain.spawn (update (fun x -> x + 1) a)
let d2 = Domain.spawn (update (fun x -> 2 * x + 1) a)
let () = Domain.join d1; Domain.join d2

После выполнения этого кода каждое поле Bigarray a будет содержать либо 2, либо 3, либо 4, либо 5. Если требуется атомарность, пользователь должен реализовать собственную синхронизацию (например, с помощью Mutex.t).

Состояния гонки при доступе к данным

Если два домена обращаются только к непересекающимся частям Bigarray, наблюдаемое поведение эквивалентно некоторому последовательному чередованию операций этих двух доменов.

Состояние гонки при доступе к данным возникает, когда два домена без синхронизации обращаются к одному и тому же элементу Bigarray и хотя бы одно из обращений является записью. При отсутствии состояний гонки наблюдаемое поведение эквивалентно некоторому последовательному чередованию операций разных доменов.

По возможности следует избегать состояний гонки при доступе к данным, используя синхронизацию для координации обращений к элементам Bigarray.

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

Разрывы при чтении и записи

При наличии состояний гонки у Bigarray есть особенность, о которой следует помнить: параллельные операции с Bigarray могут из-за разрывов при чтении и записи приводить к неожиданным значениям. Точнее, чередование частичных операций записи и чтения может создавать значения, которые не возникли бы при последовательном выполнении. Например, по завершении

let res = Array1.init Complex64 c_layout size (fun _ -> Complex.zero)
let d1 = Domain.spawn (fun () -> Array1.fill res Complex.one)
let d2 = Domain.spawn (fun () -> Array1.fill res Complex.i)
let () = Domain.join d1; Domain.join d2

Bigarray res может содержать значения, отличные и от Complex.i, и от Complex.one (например, 1 + i).