Модуль Bigarray

module Bigarray: sig .. end

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

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

• Числа с плавающей точкой одинарной точности 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 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
    | Int8_signed -> 0 | Int8_unsigned -> 0
    | Int16_signed -> 0 | Int16_unsigned -> 0
    | Int32 -> 0l | Int64 -> 0L
    | Int -> 0 | Nativeint -> 0n
    | Char -> '\000'

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

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

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

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

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

Bigarrays и безопасность в многопоточном доступе

Необходимо проявлять осторожность при одновременном доступе к Bigarrays из нескольких областей: доступ к Bigarray никогда не приведет к сбою программы, но несинхронизированные обращения могут привести к неожиданным (непоследовательным) результатам.

Атомарность

Каждая операция с Bigarray, которая обращается более чем к одному элементу массива, не является атомарной. Это включает в себя операции слайсинга, копирования и заполнения Bigarrays.

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

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.

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

Разрывы данных

Bigarrays имеют отличительную особенность в случае конфликтов данных: одновременные операции с 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).