Модуль Bigarray

module Bigarray: sig .. end

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

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

• Числа с плавающей точкой с полувысокой точностью 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

Преобразования между общими 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.

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

Разрыв

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

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

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