模块 Stdlib.Bigarray

module Bigarray: Bigarray

元素种类

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 整数（有符号，在 32 位架构上为 31 位，在 64 位架构上为 63 位）(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 和并发安全性

当从多个域并发访问大数组时，必须小心：访问大数组永远不会导致程序崩溃，但未同步的访问可能会产生令人惊讶的（非顺序一致的）结果。

原子性

每个访问多个数组元素的大数组操作都不是原子的。这包括切片、blitting 和填充大数组。

例如，考虑以下程序

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

执行此代码后，大数组 a 的每个字段都为 2、3、4 或 5。如果需要原子性，则用户必须实现自己的同步（例如，使用 Mutex.t）。

数据竞争

如果两个域仅访问大数组的不同部分，则观察到的行为等效于这两个域的操作的某些顺序交错。

当两个域访问同一个大数组元素且没有同步，并且至少一个访问是写入操作时，就会发生数据竞争。在没有数据竞争的情况下，观察到的行为等效于来自不同域的操作的某些顺序交错。

在任何可能的情况下，都应通过使用同步来协调对大数组元素的访问，从而避免数据竞争。

实际上，在存在数据竞争的情况下，程序不会崩溃，但观察到的行为可能不等于来自不同域的操作的任何顺序交错。

撕裂

大数组在存在数据竞争的情况下有一个明显的警告：并发大数组操作可能会产生令人惊讶的值，因为存在撕裂现象。更准确地说，部分写入和读取的交错可能会创建在顺序执行中不存在的值。例如，在

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）。