Java修炼终极指南:103. 通过 Vector API 求和两个数组

通过 Vector API 求和两个数组是我们前面两个问题中所学知识的完美起点。假设我们有以下 Java 数组：

int[] x = new int[]{1, 2, 3, 4, 5, 6, 7, 8};  
int[] y = new int[]{4, 5, 2, 5, 1, 3, 8, 7};

为了通过 Vector API 计算 z=x+y，我们需要创建两个 Vector 实例，并依赖 add() 操作，即 z=x.add(y)。由于 Java 数组包含整数标量，我们可以使用 IntVector 专业化版本，如下所示：

IntVector xVector = IntVector.fromArray(  
  IntVector.SPECIES_256, x, 0);  
IntVector yVector = IntVector.fromArray(  
  IntVector.SPECIES_256, y, 0);

在 Java 中，一个整数需要 4 个字节，即 32 位。由于 x 和 y 包含 8 个整数，我们需要 8*32=256 位在向量中表示它们。因此，依赖 SPECIES_256 是正确的选择。接下来，我们可以应用 add() 操作，如下所示：

IntVector zVector = xVector.add(yVector);

完成了！现在是 JVM 生成最优指令集（数据并行加速代码）的时候了，它将计算我们的加法。结果将是一个向量，即 [5, 7, 5, 9, 6, 9, 15, 15]。

这是一个简单的情况，但并不完全现实。谁会为了求和两个只有几个元素的数组而使用并行计算能力呢？！在现实世界中，x 和 y 可能有远超过 8 个元素。很可能，x 和 y 有数百万个项目，并涉及多个计算周期。这正是我们可以利用并行计算能力的时候。

但是，现在，让我们假设 x 和 y 如下：

x = {3, 6, 5, 5, 1, 2, 3, 4, 5, 6, 7, 8, 3, 6, 5, 5, 1, 2, 3,  
     4, 5, 6, 7, 8, 3, 6, 5, 5, 1, 2, 3, 4, 3, 4};  
y = {4, 5, 2, 5, 1, 3, 8, 7, 1, 6, 2, 3, 1, 2, 3, 4, 5, 6, 7,  
     8, 3, 6, 5, 5, 1, 2, 3, 4, 5, 6, 7, 8, 2, 8};

如果我们应用之前的代码（基于 SPECIES_256），结果将是一样的，因为我们的向量只能容纳前 8 个标量，并会忽略其余部分。如果我们应用相同的逻辑但使用 SPECIES_PREFERRED，则结果不可预测，因为向量的形状特定于当前平台。然而，我们可以直观地认为我们将容纳前 n（无论 n 是多少）个标量，但不是全部。

这次，我们需要将数组分块，并使用循环遍历数组并计算 z_chunk = x_chunk + y_chunk。将两个块的求和结果收集到第三个数组（z）中，直到处理完所有块。我们定义一个方法，开始如下：

public static void sum(int x[], int y[], int z[]) {  
  ...

但是，块应该有多大呢？第一个挑战是循环设计。循环应该从 0 开始，但上限和步长是多少呢？通常，上限是 x 的长度，即 34。但是，使用 x.length 并不完全有用，因为它不能保证我们的向量将尽可能多地从数组中容纳标量。我们寻找的是小于或等于 x.length 的 VLENGTH（向量的长度）的最大倍数。在我们的例子中，那是小于 34 的 8 的最大倍数，即 32。这正是 loopBound() 方法返回的内容，因此我们可以编写循环如下：

int upperBound = VS256.loopBound(x.length);         
for (int i = 0; i < upperBound; i += VS256.length()) {  
  ...  
}

循环步长是向量的长度。以下图表预先可视化了代码：

图 5.8 – 以块为单位计算 z = x + y

因此，在第一次迭代中，我们的向量将容纳从索引 0 到 7 的标量。在第二次迭代中，标量来自索引 8 到 15，依此类推。以下是完整代码：

public static void sum(int x[], int y[], int z[]) {  
  int upperBound = VS256.loopBound(x.length);    
  for (int i = 0; i < upperBound; i += VS256.length()) {  
    IntVector xVector = IntVector.fromArray(VS256, x, i);  
    IntVector yVector = IntVector.fromArray(VS256, y, i);  
    IntVector zVector = xVector.add(yVector);  
    zVector.intoArray(z, i);  
  }  
}

intoArray(int[] a, int offset) 将向量中的标量转移到 Java 数组中。这个方法与 intoMemorySegment() 一起有多种变体。

结果数组将是：[7, 11, 7, 10, 2, 5, 11, 11, 6, 12, 9, 11, 4, 8, 8, 9, 6, 8, 10, 12, 8, 12, 12, 13, 4, 8, 8, 9, 6, 8, 10, 12, 0, 0]。检查最后两个项目...它们等于 0。这些项目是 x.length - upperBound = 34 – 32 = 2 的结果。当 VLENGTH（向量的长度）的最大倍数等于 x.length 时，这个差异将为 0，否则我们将有未计算的其余项目。因此，前面的代码仅在 VLENGTH（向量的长度）等于 x.length 的特定情况下按预期工作。

可以通过至少两种方式处理剩余的项目。首先，我们可以依赖 VectorMask，如以下代码所示：

public static void sumMask(int x[], int y[], int z[]) {  
  int upperBound = VS256.loopBound(x.length);  
  int i = 0;  
  for (; i < upperBound; i += VS256.length()) {  
    ... // 同上  
  }  
  if (i <= (x.length - 1)) {             
    VectorMask<Integer> mask  
      = VS256.indexInRange(i, x.length);  
    IntVector zVector = IntVector.fromArray(VS256, x, i, mask)  
          .add(IntVector.fromArray(VS256, y, i, mask));  
    zVector.intoArray(z, i, mask);  
  }  
}

indexInRange() 计算范围 [i, x.length-1] 内的掩码。应用此掩码将产生以下 z 数组：[7, 11, 7, 10, 2, 5, 11, 11, 6, 12, 9, 11, 4, 8, 8, 9, 6, 8, 10, 12, 8, 12, 12, 13, 4, 8, 8, 9, 6, 8, 10, 12, 5, 12]。现在，最后两个项目已按预期计算。

作为一般规则，避免在循环中使用 VectorMask。它们相当昂贵，可能会导致性能显著下降。

处理这些剩余项目的另一种方法是采用传统的 Java 代码片段，如下所示：

public static void sumPlus(int x[], int y[], int z[]) {  
  ... // 同上  
  for (; i < x.length; i++) {  
    z[i] = x[i] + y[i];  
  }  
}

实际上，我们在向量循环之外的 Java 传统循环中累加剩余的项目。