《ECMAScript 6 入门》SIMD 详解:JavaScript 的单指令多数据并行运算指南

原创2026-09-19 19:26:341,998 阅读
文章标签:教程前端

《ECMAScript 6 入门》SIMD 详解:JavaScript 的单指令多数据并行运算指南

SIMD(Single Instruction/Multiple Data,单指令多数据)是 JavaScript 直接操作 CPU 向量指令的接口,让一条指令同时完成多个数据的运算,是 3D 图形、图像处理、信号处理等运算密集型场景的重要加速手段。本文以《ECMAScript 6 入门》教程的 SIMD 章节 为主体,系统讲解 SIMD 的概念模型、12 种数据类型、五大类静态方法(数学运算、通道处理、比较运算、位运算、类型转换)、实例方法,并给出求平均值的完整实战示例,帮助读者掌握用 SIMD 编写数据并行代码的完整能力。

概述:从 SISD 到 SIMD

SIMD(发音/sim-dee/)是“Single Instruction/Multiple Data”的缩写,意为“单指令,多数据”。它是 JavaScript 操作 CPU 对应指令的接口,你可以将其看作一种不同的运算执行模式。与它相对的是 SISD(“Single Instruction/Single Data”),即“单指令,单数据”——这是 JavaScript 的默认运算模式。

  • SISD:使用一个指令,完成单个数据的运算;
  • SIMD:使用一个指令,完成多个数据的运算。

显而易见,SIMD 的执行效率要高于 SISD,因此被广泛用于 3D 图形运算、物理模拟等运算量超大的项目之中。

为了理解 SIMD,请看下面的例子。

var a = [1, 2, 3, 4];
var b = [5, 6, 7, 8];
var c = [];

c[0] = a[0] + b[0];
c[1] = a[1] + b[1];
c[2] = a[2] + b[2];
c[3] = a[3] + b[3];
c // Array[6, 8, 10, 12]

上面代码中,数组a和b的对应成员相加,结果放入数组c。它的运算模式是依次处理每个数组成员,一共有四个数组成员,所以需要运算 4 次。

如果采用 SIMD 模式,只要运算一次就够了。

var a = SIMD.Float32x4(1, 2, 3, 4);
var b = SIMD.Float32x4(5, 6, 7, 8);
var c = SIMD.Float32x4.add(a, b); // Float32x4[6, 8, 10, 12]

上面代码之中,数组a和b的四个成员的各自相加,只用一条指令就完成了。因此,速度比上一种写法提高了 4 倍。

通道(lane)与矢量运算

一次 SIMD 运算,可以处理多个数据,这些数据被称为“通道”(lane)。上面代码中,一次运算了四个数据,因此就是四个通道。通道是理解 SIMD 一切 API 的核心概念:SIMD 值由若干固定宽度的通道组成,运算时所有通道在一条指令内并行完成。

SIMD 通常用于矢量运算:

v + w = 〈v1, …, vn〉 + 〈w1, …, wn〉
      = 〈v1+w1, …, vn+wn〉

上面代码中,v和w是两个多元矢量。它们的加运算,在 SIMD 下是一个指令、而不是 n 个指令完成的,这就大大提高了效率。这对于 3D 动画、图像处理、信号处理、数值处理、加密等运算是非常重要的。比如,Canvas 的getImageData()会将图像文件读成一个二进制数组,SIMD 就很适合对于这种数组的处理(关于二进制数组,可进一步阅读本仓库的 ArrayBuffer 章节,其中详细介绍了TypedArray视图等与 SIMD 的load/store密切相关的二进制数据接口)。

总的来说,SIMD 是数据并行处理(parallelism)的一种手段,可以加速一些运算密集型操作的速度。将来与 WebAssembly 结合以后,可以让 JavaScript 达到二进制代码的运行速度。从本仓库的参考链接章节可以看到,SIMD 当时以 TC39 的 SIMD.js 提案(Stage 2)形式推进,本文所讲的 API 即基于该提案。

数据类型:12 种 128 位向量

SIMD 提供 12 种数据类型,总长度都是 128 个二进制位:

数据类型 通道构成 说明
Float32x4 四个 32 位浮点数 4 通道单精度浮点
Float64x2 两个 64 位浮点数 2 通道双精度浮点
Int32x4 四个 32 位整数 4 通道带符号 32 位整数
Int16x8 八个 16 位整数 8 通道带符号 16 位整数
Int8x16 十六个 8 位整数 16 通道带符号 8 位整数
Uint32x4 四个无符号的 32 位整数 4 通道无符号 32 位整数
Uint16x8 八个无符号的 16 位整数 8 通道无符号 16 位整数
Uint8x16 十六个无符号的 8 位整数 16 通道无符号 8 位整数
Bool32x4 四个 32 位布尔值 4 通道布尔掩码
Bool16x8 八个 16 位布尔值 8 通道布尔掩码
Bool8x16 十六个 8 位布尔值 16 通道布尔掩码
Bool64x2 两个 64 位布尔值 2 通道布尔掩码

每种数据类型被x符号分隔成两部分,后面的部分表示通道数,前面的部分表示每个通道的宽度和类型。比如,Float32x4就表示这个值有 4 个通道,每个通道是一个 32 位浮点数。

每个通道之中,可以放置四种数据:

  • 浮点数(float,比如 1.0)
  • 带符号的整数(Int,比如 -1)
  • 无符号的整数(Uint,比如 1)
  • 布尔值(Bool,包含true和false两种值)

每种 SIMD 的数据类型都是一个函数方法,可以传入参数,生成对应的值。

var a = SIMD.Float32x4(1.0, 2.0, 3.0, 4.0);

上面代码中,变量a就是一个 128 位、包含四个 32 位浮点数(即四个通道)的值。

注意,这些数据类型方法都不是构造函数,前面不能加new,否则会报错。

var v = new SIMD.Float32x4(0, 1, 2, 3);
// TypeError: SIMD.Float32x4 is not a constructor

在后续所有小节中,%type%表示任意一种数据类型(如Float32x4、Int32x4、Uint16x8等),%FloatType%表示浮点类型,%IntegerType%表示整数类型,%BooleanType%表示布尔类型。需要留意的是:并非所有方法都适用于全部 12 种类型,下文会在每个方法处标注其适用类型范围。

静态方法:数学运算

每种数据类型都有一系列运算符,支持基本的数学运算。这一类方法的共同特点是:以 SIMD 值为参数(部分方法需要两个 SIMD 值),逐通道完成数学运算,返回一个新的 SIMD 值,原始值不被修改。

SIMD.%type%.abs(),SIMD.%type%.neg()

abs方法接受一个 SIMD 值作为参数,将它的每个通道都转成绝对值,作为一个新的 SIMD 值返回。

var a = SIMD.Float32x4(-1, -2, 0, NaN);
SIMD.Float32x4.abs(a)
// Float32x4[1, 2, 0, NaN]

neg方法接受一个 SIMD 值作为参数,将它的每个通道都转成负值,作为一个新的 SIMD 值返回。

var a = SIMD.Float32x4(-1, -2, 3, 0);
SIMD.Float32x4.neg(a)
// Float32x4[1, 2, -3, -0]

var b = SIMD.Float64x2(NaN, Infinity);
SIMD.Float64x2.neg(b)
// Float64x2[NaN, -Infinity]

SIMD.%type%.add(),SIMD.%type%.addSaturate()

add方法接受两个 SIMD 值作为参数,将它们的每个通道相加,作为一个新的 SIMD 值返回。

var a = SIMD.Float32x4(1.0, 2.0, 3.0, 4.0);
var b = SIMD.Float32x4(5.0, 10.0, 15.0, 20.0);
var c = SIMD.Float32x4.add(a, b);

上面代码中,经过加法运算,新的 SIMD 值为(6.0, 12.0, 18.0, 24.0)。

addSaturate方法跟add方法的作用相同,都是两个通道相加,但是溢出的处理不一致。对于add方法,如果两个值相加发生溢出,溢出的二进制位会被丢弃;addSaturate方法则是返回该数据类型的最大值。

var a = SIMD.Uint16x8(65533, 65534, 65535, 65535, 1, 1, 1, 1);
var b = SIMD.Uint16x8(1, 1, 1, 5000, 1, 1, 1, 1);
SIMD.Uint16x8.addSaturate(a, b);
// Uint16x8[65534, 65535, 65535, 65535, 2, 2, 2, 2]

var c = SIMD.Int16x8(32765, 32766, 32767, 32767, 1, 1, 1, 1);
var d = SIMD.Int16x8(1, 1, 1, 5000, 1, 1, 1, 1);
SIMD.Int16x8.addSaturate(c, d);
// Int16x8[32766, 32767, 32767, 32767, 2, 2, 2, 2]

上面代码中,Uint16的最大值是 65535,Int16的最大值是 32767。一旦发生溢出,就返回这两个值。

注意,Uint32x4和Int32x4这两种数据类型没有addSaturate方法。

SIMD.%type%.sub(),SIMD.%type%.subSaturate()

sub方法接受两个 SIMD 值作为参数,将它们的每个通道相减,作为一个新的 SIMD 值返回。

var a = SIMD.Float32x4(-1, -2, 3, 4);
var b = SIMD.Float32x4(3, 3, 3, 3);
SIMD.Float32x4.sub(a, b)
// Float32x4[-4, -5, 0, 1]

subSaturate方法跟sub方法的作用相同,都是两个通道相减,但是溢出的处理不一致。对于sub方法,如果两个值相减发生溢出,溢出的二进制位会被丢弃;subSaturate方法则是返回该数据类型的最小值。

var a = SIMD.Uint16x8(5, 1, 1, 1, 1, 1, 1, 1);
var b = SIMD.Uint16x8(10, 1, 1, 1, 1, 1, 1, 1);
SIMD.Uint16x8.subSaturate(a, b)
// Uint16x8[0, 0, 0, 0, 0, 0, 0, 0]

var c = SIMD.Int16x8(-100, 0, 0, 0, 0, 0, 0, 0);
var d = SIMD.Int16x8(32767, 0, 0, 0, 0, 0, 0, 0);
SIMD.Int16x8.subSaturate(c, d)
// Int16x8[-32768, 0, 0, 0, 0, 0, 0, 0]

上面代码中,Uint16的最小值是0,Int16的最小值是-32768。一旦运算发生溢出,就返回最小值。

SIMD.%type%.mul(),SIMD.%type%.div(),SIMD.%type%.sqrt()

mul方法接受两个 SIMD 值作为参数,将它们的每个通道相乘,作为一个新的 SIMD 值返回。

var a = SIMD.Float32x4(-1, -2, 3, 4);
var b = SIMD.Float32x4(3, 3, 3, 3);
SIMD.Float32x4.mul(a, b)
// Float32x4[-3, -6, 9, 12]

div方法接受两个 SIMD 值作为参数,将它们的每个通道相除,作为一个新的 SIMD 值返回。

var a = SIMD.Float32x4(2, 2, 2, 2);
var b = SIMD.Float32x4(4, 4, 4, 4);
SIMD.Float32x4.div(a, b)
// Float32x4[0.5, 0.5, 0.5, 0.5]

sqrt方法接受一个 SIMD 值作为参数,求出每个通道的平方根,作为一个新的 SIMD 值返回。

var b = SIMD.Float64x2(4, 8);
SIMD.Float64x2.sqrt(b)
// Float64x2[2, 2.8284271247461903]

SIMD.%FloatType%.reciprocalApproximation(),SIMD.%FloatType%.reciprocalSqrtApproximation()

reciprocalApproximation方法接受一个 SIMD 值作为参数,求出每个通道的倒数(1 / x),作为一个新的 SIMD 值返回。

var a = SIMD.Float32x4(1, 2, 3, 4);
SIMD.Float32x4.reciprocalApproximation(a);
// Float32x4[1, 0.5, 0.3333333432674408, 0.25]

reciprocalSqrtApproximation方法接受一个 SIMD 值作为参数,求出每个通道的平方根的倒数(1 / (x^0.5)),作为一个新的 SIMD 值返回。

var a = SIMD.Float32x4(1, 2, 3, 4);
SIMD.Float32x4.reciprocalSqrtApproximation(a)
// Float32x4[1, 0.7071067690849304, 0.5773502588272095, 0.5]

注意,只有浮点数的数据类型才有这两个方法。从方法名可以看出,它们返回的是“近似值”(Approximation):SIMD 硬件通常以查表等近似算法实现倒数与平方根倒数,比精确除法快得多,适合对精度不敏感、对速度敏感的场景(典型如归一化向量)。

SIMD.%IntegerType%.shiftLeftByScalar()

shiftLeftByScalar方法接受一个 SIMD 值作为参数,然后将每个通道的值左移指定的位数,作为一个新的 SIMD 值返回。

var a = SIMD.Int32x4(1, 2, 4, 8);
SIMD.Int32x4.shiftLeftByScalar(a, 1);
// Int32x4[2, 4, 8, 16]

如果左移后,新的值超出了当前数据类型的位数,溢出的部分会被丢弃。

var ix4 = SIMD.Int32x4(1, 2, 3, 4);
var jx4 = SIMD.Int32x4.shiftLeftByScalar(ix4, 32);
// Int32x4[0, 0, 0, 0]

注意,只有整数的数据类型才有这个方法。

SIMD.%IntegerType%.shiftRightByScalar()

shiftRightByScalar方法接受一个 SIMD 值作为参数,然后将每个通道的值右移指定的位数,返回一个新的 SIMD 值。

var a = SIMD.Int32x4(1, 2, 4, -8);
SIMD.Int32x4.shiftRightByScalar(a, 1);
// Int32x4[0, 1, 2, -4]

如果原来通道的值是带符号的值,则符号位保持不变,不受右移影响。如果是不带符号位的值,则右移后头部会补0。

var a = SIMD.Uint32x4(1, 2, 4, -8);
SIMD.Uint32x4.shiftRightByScalar(a, 1);
// Uint32x4[0, 1, 2, 2147483644]

上面代码中,-8右移一位变成了2147483644,是因为对于 32 位无符号整数来说,-8的二进制形式是11111111111111111111111111111000,右移一位就变成了01111111111111111111111111111100,相当于2147483644。

注意,只有整数的数据类型才有这个方法。

静态方法:通道处理

通道处理类方法用于类型检查、读取/替换指定通道、与二进制数组之间批量读写数据,以及重排通道顺序。

SIMD.%type%.check()

check方法用于检查一个值是否为当前类型的 SIMD 值。如果是的,就返回这个值,否则就报错。

var a = SIMD.Float32x4(1, 2, 3, 9);

SIMD.Float32x4.check(a);
// Float32x4[1, 2, 3, 9]

SIMD.Float32x4.check([1,2,3,4]) // 报错
SIMD.Int32x4.check(a) // 报错
SIMD.Int32x4.check('hello world') // 报错

它相当于一个“类型守卫”:既可以验证传入参数确实是指定类型的 SIMD 值,也可以在类型不匹配时立即抛出错误,避免后续运算产生难以排查的隐患。

SIMD.%type%.extractLane(),SIMD.%type%.replaceLane()

extractLane方法用于返回给定通道的值。它接受两个参数,分别是 SIMD 值和通道编号。

var t = SIMD.Float32x4(1, 2, 3, 4);
SIMD.Float32x4.extractLane(t, 2) // 3

replaceLane方法用于替换指定通道的值,并返回一个新的 SIMD 值。它接受三个参数,分别是原来的 SIMD 值、通道编号和新的通道值。

var t = SIMD.Float32x4(1, 2, 3, 4);
SIMD.Float32x4.replaceLane(t, 2, 42)
// Float32x4[1, 2, 42, 4]

通道编号从0开始计数。extractLane用于“取出”某通道的值(常用于把 SIMD 运算结果写回普通 JavaScript 数据),replaceLane用于“修改”某通道的值,且不改变原 SIMD 值。

SIMD.%type%.load()

load方法用于从二进制数组读入数据,生成一个新的 SIMD 值。

var a = new Int32Array([1,2,3,4,5,6,7,8]);
SIMD.Int32x4.load(a, 0);
// Int32x4[1, 2, 3, 4]

var b = new Int32Array([1,2,3,4,5,6,7,8]);
SIMD.Int32x4.load(a, 2);
// Int32x4[3, 4, 5, 6]

load方法接受两个参数:一个二进制数组和开始读取的位置(从 0 开始)。如果位置不合法(比如-1或者超出二进制数组的大小),就会抛出一个错误。

这个方法还有三个变种load1()、load2()、load3(),表示从指定位置开始,只加载一个通道、二个通道、三个通道的值。

// 格式
SIMD.Int32x4.load(tarray, index)
SIMD.Int32x4.load1(tarray, index)
SIMD.Int32x4.load2(tarray, index)
SIMD.Int32x4.load3(tarray, index)

// 实例
var a = new Int32Array([1,2,3,4,5,6,7,8]);
SIMD.Int32x4.load1(a, 0);
// Int32x4[1, 0, 0, 0]
SIMD.Int32x4.load2(a, 0);
// Int32x4[1, 2, 0, 0]
SIMD.Int32x4.load3(a, 0);
// Int32x4[1, 2, 3, 0]

这里加载的“二进制数组”即 ES6 的TypedArray视图(如Int32Array、Float32Array、Uint8Array等),它们的具体规格可参考本仓库的 ArrayBuffer 章节。load族方法正是把 SIMD 与传统 JavaScript 内存数据衔接起来的关键入口:从内存批量读入数据、放入向量寄存器中并行运算。

SIMD.%type%.store()

store方法用于将一个 SIMD 值,写入一个二进制数组。它接受三个参数,分别是二进制数组、开始写入的数组位置、SIMD 值。它返回写入值以后的二进制数组。

var t1 = new Int32Array(8);
var v1 = SIMD.Int32x4(1, 2, 3, 4);
SIMD.Int32x4.store(t1, 0, v1)
// Int32Array[1, 2, 3, 4, 0, 0, 0, 0]

var t2 = new Int32Array(8);
var v2 = SIMD.Int32x4(1, 2, 3, 4);
SIMD.Int32x4.store(t2, 2, v2)
// Int32Array[0, 0, 1, 2, 3, 4, 0, 0]

上面代码中,t1是一个二进制数组,v1是一个 SIMD 值,只有四个通道。所以写入t1以后,只有前四个位置有值,后四个位置都是 0。而t2是从 2 号位置开始写入,所以前两个位置和后两个位置都是 0。

这个方法还有三个变种store1()、store2()和store3(),表示只写入一个通道、二个通道和三个通道的值。

var tarray = new Int32Array(8);
var value = SIMD.Int32x4(1, 2, 3, 4);
SIMD.Int32x4.store1(tarray, 0, value);
// Int32Array[1, 0, 0, 0, 0, 0, 0, 0]

load与store成对出现,构成了“内存 ↔ 向量”的完整数据通路:load把数据读入 SIMD 值参与并行计算,store把结果写回二进制数组。

SIMD.%type%.splat()

splat方法返回一个新的 SIMD 值,该值的所有通道都会设成同一个预先给定的值。

SIMD.Float32x4.splat(3);
// Float32x4[3, 3, 3, 3]
SIMD.Float64x2.splat(3);
// Float64x2[3, 3]

如果省略参数,所有整数型的 SIMD 值都会设定0,浮点型的 SIMD 值都会设成NaN。splat常用于生成“广播值”,例如在向量加标量、向量与常量比较等场景中,先把标量广播到所有通道,再参与 SIMD 运算。

SIMD.%type%.swizzle()

swizzle方法返回一个新的 SIMD 值,重新排列原有的 SIMD 值的通道顺序。

var t = SIMD.Float32x4(1, 2, 3, 4);
SIMD.Float32x4.swizzle(t, 1, 2, 0, 3);
// Float32x4[2, 3, 1, 4]

上面代码中,swizzle方法的第一个参数是原有的 SIMD 值,后面的参数对应将要返回的 SIMD 值的四个通道。它的意思是新的 SIMD 的四个通道,依次是原来 SIMD 值的 1 号通道、2 号通道、0 号通道、3 号通道。由于 SIMD 值最多可以有 16 个通道,所以swizzle方法除了第一个参数以外,最多还可以接受 16 个参数。

下面是另一个例子。

var a = SIMD.Float32x4(1.0, 2.0, 3.0, 4.0);
// Float32x4[1.0, 2.0, 3.0, 4.0]

var b = SIMD.Float32x4.swizzle(a, 0, 0, 1, 1);
// Float32x4[1.0, 1.0, 2.0, 2.0]

var c = SIMD.Float32x4.swizzle(a, 3, 3, 3, 3);
// Float32x4[4.0, 4.0, 4.0, 4.0]

var d = SIMD.Float32x4.swizzle(a, 3, 2, 1, 0);
// Float32x4[4.0, 3.0, 2.0, 1.0]

swizzle只在一个 SIMD 值内部重排通道,常用于实现向量分量交换、复制等操作。

SIMD.%type%.shuffle()

shuffle方法从两个 SIMD 值之中取出指定通道,返回一个新的 SIMD 值。

var a = SIMD.Float32x4(1, 2, 3, 4);
var b = SIMD.Float32x4(5, 6, 7, 8);

SIMD.Float32x4.shuffle(a, b, 1, 5, 7, 2);
// Float32x4[2, 6, 8, 3]

上面代码中,a和b一共有 8 个通道,依次编号为 0 到 7。shuffle根据编号,取出相应的通道,返回一个新的 SIMD 值。

与swizzle不同,shuffle可以从两个 SIMD 值中混合选取通道(两个值合并后通道统一从 0 编号),是实现向量拼接、交叉存取等操作的工具。

静态方法:比较运算

比较运算类方法逐通道比较两个 SIMD 值,结果为布尔类型 SIMD 值(作为掩码),可以进一步交给select等方法做条件选择。

SIMD.%type%.equal(),SIMD.%type%.notEqual()

equal方法用来比较两个 SIMD 值a和b的每一个通道,根据两者是否精确相等(a === b),得到一个布尔值。最后,所有通道的比较结果,组成一个新的 SIMD 值,作为掩码返回。notEqual方法则是比较两个通道是否不相等(a !== b)。

var a = SIMD.Float32x4(1, 2, 3, 9);
var b = SIMD.Float32x4(1, 4, 7, 9);

SIMD.Float32x4.equal(a,b)
// Bool32x4[true, false, false, true]

SIMD.Float32x4.notEqual(a,b);
// Bool32x4[false, true, true, false]

SIMD.%type%.greaterThan(),SIMD.%type%.greaterThanOrEqual()

greaterThan方法用来比较两个 SIMD 值a和b的每一个通道,如果在该通道中,a较大就得到true,否则得到false。最后,所有通道的比较结果,组成一个新的 SIMD 值,作为掩码返回。greaterThanOrEqual则是比较a是否大于等于b。

var a = SIMD.Float32x4(1, 6, 3, 11);
var b = SIMD.Float32x4(1, 4, 7, 9);

SIMD.Float32x4.greaterThan(a, b)
// Bool32x4[false, true, false, true]

SIMD.Float32x4.greaterThanOrEqual(a, b)
// Bool32x4[true, true, false, true]

SIMD.%type%.lessThan(),SIMD.%type%.lessThanOrEqual()

lessThan方法用来比较两个 SIMD 值a和b的每一个通道,如果在该通道中,a较小就得到true,否则得到false。最后,所有通道的比较结果,会组成一个新的 SIMD 值,作为掩码返回。lessThanOrEqual方法则是比较a是否小于等于b。

var a = SIMD.Float32x4(1, 2, 3, 11);
var b = SIMD.Float32x4(1, 4, 7, 9);

SIMD.Float32x4.lessThan(a, b)
// Bool32x4[false, true, true, false]

SIMD.Float32x4.lessThanOrEqual(a, b)
// Bool32x4[true, true, true, false]

SIMD.%type%.select()

select方法通过掩码生成一个新的 SIMD 值。它接受三个参数,分别是掩码和两个 SIMD 值。

var a = SIMD.Float32x4(1, 2, 3, 4);
var b = SIMD.Float32x4(5, 6, 7, 8);

var mask = SIMD.Bool32x4(true, false, false, true);

SIMD.Float32x4.select(mask, a, b);
// Float32x4[1, 6, 7, 4]

上面代码中,select方法接受掩码和两个 SIMD 值作为参数。当某个通道对应的掩码为true时,会选择第一个 SIMD 值的对应通道,否则选择第二个 SIMD 值的对应通道。

这个方法通常与比较运算符结合使用。

var a = SIMD.Float32x4(0, 12, 3, 4);
var b = SIMD.Float32x4(0, 6, 7, 50);

var mask = SIMD.Float32x4.lessThan(a,b);
// Bool32x4[false, false, true, true]

var result = SIMD.Float32x4.select(mask, a, b);
// Float32x4[0, 6, 3, 4]

上面代码中,先通过lessThan方法生成一个掩码,然后通过select方法生成一个由每个通道的较小值组成的新的 SIMD 值。这相当于把“if-else 分支”向量化:SIMD 不适合做分支跳转,而适合用掩码 + 选择的方式在一条指令内完成条件取值。

SIMD.%BooleanType%.allTrue(),SIMD.%BooleanType%.anyTrue()

allTrue方法接受一个 SIMD 值作为参数,然后返回一个布尔值,表示该 SIMD 值的所有通道是否都为true。

var a = SIMD.Bool32x4(true, true, true, true);
var b = SIMD.Bool32x4(true, false, true, true);

SIMD.Bool32x4.allTrue(a); // true
SIMD.Bool32x4.allTrue(b); // false

anyTrue方法则是只要有一个通道为true,就返回true,否则返回false。

var a = SIMD.Bool32x4(false, false, false, false);
var b = SIMD.Bool32x4(false, false, true, false);

SIMD.Bool32x4.anyTrue(a); // false
SIMD.Bool32x4.anyTrue(b); // true

注意,只有四种布尔值数据类型(Bool32x4、Bool16x8、Bool8x16、Bool64x2)才有这两个方法。

这两个方法通常与比较运算符结合使用,把向量化的比较结果“归约”成单个布尔值:

var ax4    = SIMD.Float32x4(1.0, 2.0, 3.0, 4.0);
var bx4    = SIMD.Float32x4(0.0, 6.0, 7.0, 8.0);
var ix4    = SIMD.Float32x4.lessThan(ax4, bx4);
var b1     = SIMD.Int32x4.allTrue(ix4); // false
var b2     = SIMD.Int32x4.anyTrue(ix4); // true

SIMD.%type%.min(),SIMD.%type%.minNum()

min方法接受两个 SIMD 值作为参数,将两者的对应通道的较小值,组成一个新的 SIMD 值返回。

var a = SIMD.Float32x4(-1, -2, 3, 5.2);
var b = SIMD.Float32x4(0, -4, 6, 5.5);
SIMD.Float32x4.min(a, b);
// Float32x4[-1, -4, 3, 5.2]

如果有一个通道的值是NaN,则会优先返回NaN。

var c = SIMD.Float64x2(NaN, Infinity)
var d = SIMD.Float64x2(1337, 42);
SIMD.Float64x2.min(c, d);
// Float64x2[NaN, 42]

minNum方法与min的作用一模一样,唯一的区别是如果有一个通道的值是NaN,则会优先返回另一个通道的值。

var ax4 = SIMD.Float32x4(1.0, 2.0, NaN, NaN);
var bx4 = SIMD.Float32x4(2.0, 1.0, 3.0, NaN);
var cx4 = SIMD.Float32x4.min(ax4, bx4);
// Float32x4[1.0, 1.0, NaN, NaN]
var dx4 = SIMD.Float32x4.minNum(ax4, bx4);
// Float32x4[1.0, 1.0, 3.0, NaN]

SIMD.%type%.max(),SIMD.%type%.maxNum()

max方法接受两个 SIMD 值作为参数,将两者的对应通道的较大值,组成一个新的 SIMD 值返回。

var a = SIMD.Float32x4(-1, -2, 3, 5.2);
var b = SIMD.Float32x4(0, -4, 6, 5.5);
SIMD.Float32x4.max(a, b);
// Float32x4[0, -2, 6, 5.5]

如果有一个通道的值是NaN,则会优先返回NaN。

var c = SIMD.Float64x2(NaN, Infinity)
var d = SIMD.Float64x2(1337, 42);
SIMD.Float64x2.max(c, d)
// Float64x2[NaN, Infinity]

maxNum方法与max的作用一模一样,唯一的区别是如果有一个通道的值是NaN,则会优先返回另一个通道的值。

var c = SIMD.Float64x2(NaN, Infinity)
var d = SIMD.Float64x2(1337, 42);
SIMD.Float64x2.maxNum(c, d)
// Float64x2[1337, Infinity]

min/minNum与max/maxNum两组方法的区别在于对NaN的处理策略:前者“宁可返回 NaN”,后者“尽量避开 NaN”。在实际数据处理中,如果输入数据可能包含NaN,通常使用minNum/maxNum更符合直觉。

静态方法:位运算

SIMD.%type%.and(),SIMD.%type%.or(),SIMD.%type%.xor(),SIMD.%type%.not()

and方法接受两个 SIMD 值作为参数,返回两者对应的通道进行二进制AND运算(&)后得到的新的 SIMD 值。

var a = SIMD.Int32x4(1, 2, 4, 8);
var b = SIMD.Int32x4(5, 5, 5, 5);
SIMD.Int32x4.and(a, b)
// Int32x4[1, 0, 4, 0]

上面代码中,以通道0为例,1的二进制形式是0001,5的二进制形式是0101,所以进行AND运算以后,得到0001。

or方法接受两个 SIMD 值作为参数,返回两者对应的通道进行二进制OR运算(|)后得到的新的 SIMD 值。

var a = SIMD.Int32x4(1, 2, 4, 8);
var b = SIMD.Int32x4(5, 5, 5, 5);
SIMD.Int32x4.or(a, b)
// Int32x4[5, 7, 5, 13]

xor方法接受两个 SIMD 值作为参数,返回两者对应的通道进行二进制“异或”运算(^)后得到的新的 SIMD 值。

var a = SIMD.Int32x4(1, 2, 4, 8);
var b = SIMD.Int32x4(5, 5, 5, 5);
SIMD.Int32x4.xor(a, b)
// Int32x4[4, 7, 1, 13]

not方法接受一个 SIMD 值作为参数,返回每个通道进行二进制“否”运算(~)后得到的新的 SIMD 值。

var a = SIMD.Int32x4(1, 2, 4, 8);
SIMD.Int32x4.not(a)
// Int32x4[-2, -3, -5, -9]

上面代码中,1的否运算之所以得到-2,是因为在计算机内部,负数采用“2 的补码”这种形式进行表示。也就是说,整数n的负数形式-n,是对每一个二进制位取反以后,再加上 1。因此,直接取反就相当于负数形式再减去 1,比如1的负数形式是-1,再减去 1,就得到了-2。

位运算在图像处理(位掩码提取)、数据打包/解包、颜色通道分离与合并等场景中非常常用,逐通道的位运算同样可以被 SIMD 并行化。

静态方法:数据类型转换

SIMD 提供以下方法,用来将一种数据类型转为另一种数据类型。

  • SIMD.%type%.fromFloat32x4()
  • SIMD.%type%.fromFloat32x4Bits()
  • SIMD.%type%.fromFloat64x2Bits()
  • SIMD.%type%.fromInt32x4()
  • SIMD.%type%.fromInt32x4Bits()
  • SIMD.%type%.fromInt16x8Bits()
  • SIMD.%type%.fromInt8x16Bits()
  • SIMD.%type%.fromUint32x4()
  • SIMD.%type%.fromUint32x4Bits()
  • SIMD.%type%.fromUint16x8Bits()
  • SIMD.%type%.fromUint8x16Bits()

带有Bits后缀的方法,会原封不动地将二进制位拷贝到新的数据类型;不带后缀的方法,则会进行数据类型转换。

var t = SIMD.Float32x4(1.0, 2.0, 3.0, 4.0);
SIMD.Int32x4.fromFloat32x4(t);
// Int32x4[1, 2, 3, 4]

SIMD.Int32x4.fromFloat32x4Bits(t);
// Int32x4[1065353216, 1073741824, 1077936128, 1082130432]

上面代码中,fromFloat32x4是将浮点数转为整数,然后存入新的数据类型;fromFloat32x4Bits则是将二进制位原封不动地拷贝进入新的数据类型,然后进行解读。前者得到的是数值 1、2、3、4,后者得到的是浮点数 1.0、2.0、3.0、4.0 在 IEEE 754 格式下的位模式整数。

Bits后缀的方法,还可以用于通道数目不对等的拷贝。

var t = SIMD.Float32x4(1.0, 2.0, 3.0, 4.0);
SIMD.Int16x8.fromFloat32x4Bits(t);
// Int16x8[0, 16256, 0, 16384, 0, 16448, 0, 16512]

上面代码中,原始 SIMD 值t是 4 通道的,而目标值是 8 通道的。这之所以可行,是因为两边都是 128 位,位拷贝只关心总位数是否一致(4×32 = 8×16 = 128)。

如果数据转换时,原通道的数据大小,超过了目标通道的最大宽度,就会报错。

实例方法

SIMD.%type%.prototype.toString()

toString方法返回一个 SIMD 值的字符串形式。

var a = SIMD.Float32x4(11, 22, 33, 44);
a.toString() // "SIMD.Float32x4(11, 22, 33, 44)"

实战:用 SIMD 求平均值

理解完上述 API 后,下面用“求平均值”这个经典问题,把 SIMD 的核心流程串起来:splat 初始化累加器 → load 批量载入数据 → add 并行累加 → extractLane 汇总结果。

正常模式下,计算n个值的平均值,需要运算n次。

function average(list) {
  var n = list.length;
  var sum = 0.0;
  for (var i = 0; i < n; i++) {
    sum += list[i];
  }
  return sum / n;
}

使用 SIMD,可以将计算次数减少到n次的四分之一。

function average(list) {
  var n = list.length;
  var sum = SIMD.Float32x4.splat(0.0);
  for (var i = 0; i < n; i += 4) {
    sum = SIMD.Float32x4.add(
      sum,
      SIMD.Float32x4.load(list, i)
    );
  }
  var total = SIMD.Float32x4.extractLane(sum, 0) +
              SIMD.Float32x4.extractLane(sum, 1) +
              SIMD.Float32x4.extractLane(sum, 2) +
              SIMD.Float32x4.extractLane(sum, 3);
  return total / n;
}

上面代码先是每隔四位,将所有的值读入一个 SIMD,然后立刻累加。然后,得到累加值四个通道的总和,再除以n就可以了。

这段代码体现了 SIMD 编程的标准范式:

  1. 初始化:SIMD.Float32x4.splat(0.0) 把累加器四个通道全部置零;
  2. 并行累加:循环步长为 4,每次用load从二进制数组读入 4 个值,用add一次性完成 4 次加法;
  3. 归约汇总:循环结束后,用extractLane把 4 个通道的累加结果取出来相加,得到总和,再除以总数。

需要注意,load要求list是二进制数组(TypedArray,如Float32Array),而不是普通数组。如果数据长度不是 4 的倍数,还需要处理尾部的剩余元素(例如用load1/load2/load3补齐,或者单独处理剩余部分)。

小结

SIMD 为 JavaScript 带来了真正的数据并行能力:它以 128 位向量为载体,通过 12 种数据类型覆盖浮点、整数、布尔三种通道语义,并以数学运算、通道处理、比较运算、位运算、类型转换五大类静态方法提供了一套完整的向量计算 API。

回顾本文要点:

  • 概念:SIMD 用一条指令完成多个数据的运算,与默认的 SISD 模式相比,最高可将运算次数降到原来的通道数分之一(如Float32x4为四分之一);
  • 数据模型:12 种 128 位数据类型,命名规则为“类型 + x + 通道数”,通过x分隔;
  • 运算方法:数学运算(abs、neg、add/addSaturate、sub/subSaturate、mul、div、sqrt、倒数近似、移位)、通道处理(check、extractLane、replaceLane、load/store族、splat、swizzle、shuffle)、比较运算(equal、greaterThan、lessThan、select、allTrue/anyTrue、min/max族)、位运算(and、or、xor、not)与类型转换(fromXxx / fromXxxBits);
  • 关键约定:数据类型方法不能加new;addSaturate/subSaturate仅限部分整数类型;倒数近似与移位方法有浮点/整数之分;Bits转换是纯位拷贝,可用于通道数不对等的重解读。

对于希望在项目中进一步了解相关二进制数据处理能力的读者,可以继续阅读本仓库的 ArrayBuffer 与二进制数组 章节,以及查看 SIMD 相关的参考资料列表 获取提案演进线索。

登录后查看全文
es6tutorial