我有一个表示长方体中的点的数组。它是一维数组，它使用以下索引函数来实现3维：
int getCellIndex(int ix, int iy, int iz) {
return ix + (iy * numCellsX) + (iz * numCellsX * numCellsY);
}
域中的单元格数为：
numCells = (numX + 2) * (numY + 2) * (numZ + 2)
其中numX / numY / numZ是X / Y / Z方向上的单元格数。每个方向的+2是在域的外部创建填充单元。每个方向的细胞数由下式给出：
numX = 5 * numY
numZ = numY/2
numY = userInput
对于每个单元格，我想根据它的邻居值（即模板）计算该单元格的新值，其中它的邻居位于上方，下方，左侧，右侧，前方和前方。背部。但是，我只想对那些不好的单元格进行计算。我有一个布尔数组来跟踪一个单元格是坏的。这就是目前的计算结果：
for(int z = 1; z < numZ+1; z++) {
for(int y = 1; y < numY+1; y++) {
for(int x = 1; x < numX+1; x++) {
if(!isBadCell[ getCellIndex(x,y,z) ] {
// Do stencil Computation
}
}
}
}
这不是很好的表现。我希望能够对循环进行矢量化以提高性能，但是由于if语句，我不能这样做。我知道细胞是否预先坏了，这在整个计算过程中都没有变化。我想将域拆分成块，最好是4x4x4块，这样我就可以计算每个块的先验值，如果它包含坏单元格，如果是这样，就像往常一样处理它，如果没有，则使用优化函数可以利用矢量化，例如
for(block : blocks) {
if(isBadBlock[block]) {
slowProcessBlock(block) // As above
} else {
fastVectorizedProcessBlock(block)
}
}
注意：块不需要物理存在，即这可以通过更改索引功能，并使用不同的索引循环数组来实现。我打算做任何最好的事情。
fastVectorizedProcessBlock（）函数看起来类似于slowProcessBlock（）函数，但if语句删除（因为我们知道它不包含坏单元格）和矢量化编译指示。
如何将我的域拆分为块，以便我可以完成此操作？这似乎很棘手，因为a）每个方向上的单元格数量不相等，b）我们需要考虑填充单元格，因为我们绝不能尝试计算它们的值，因为这会导致内存访问边界。
如何在不使用if语句的情况下处理不包含坏单元格的块？
编辑：
这是我最初的想法：
for(int i = 0; i < numBlocks; i++) { // use blocks of 4x4x4 = 64
if(!isBadBlock[i]) {
// vectorization pragma here
for(int z = 0; z < 4; z++) {
for(int y = 0; y < 4; y++) {
for(int x = 0; x < 4; x++) {
// calculate stencil using getCellIndex(x,y,z)*i
}
}
}
} else {
for(int z = 0; z < 4; z++) {
for(int y = 0; y < 4; y++) {
for(int x = 0; x < 4; x++) {
if(!isBadCell[i*getCellIndex(x,y,z)]) {
// calculate stencil using getCellIndex(x,y,z)*i
}
}
}
}
}
现在，单元格将存储在块中，即第一个4x4x4块中的所有单元格将存储在位置0-63中，然后第二个块中的所有单元格将存储在位置64-127等中。
但是，如果numX / numY / numZ值不合适，我认为不会起作用。例如，如果numY = 2，numZ = 1和numX = 10，该怎么办？ for循环期望z方向至少为4个单元格深。有没有一个很好的方法来解决这个问题？
更新2 - 这是模板计算的样子：
if ( isBadCell[ getCellIndex(x,y,z) ] ) {
double temp = someOtherArray[ getCellIndex(x,y,z) ] +
1.0/CONSTANT/CONSTANT*
(
- 1.0 * cells[ getCellIndex(x-1,y,z) ]
- 1.0 * cells[ getCellIndex(x+1,y,z) ]
- 1.0 * cells[ getCellIndex(x,y-1,z) ]
- 1.0 * cells[ getCellIndex(x,y+1,z) ]
- 1.0 * cells[ getCellIndex(x,y,z-1) ]
- 1.0 * cells[ getCellIndex(x,y,z+1) ]
+ 6.0 * cells[ getCellIndex(x,y,z) ]
);
globalTemp += temp * temp;
cells[ getCellIndex(x,y,z) ] += -omega * temp / 6.0 * CONSTANT * CONSTANT;
}
答案 0 :(得分：7)
getCellIndex()在哪里检索numCellX和numCellY的值？最好将它们作为参数传递而不是依赖于全局变量，并使这个函数static inline允许编译器进行优化。
static line int getCellIndex(int ix, int iy, int iz, int numCellsX, numCellsY) {
return ix + (iy * numCellsX) + (iz * numCellsX * numCellsY);
}
for (int z = 1; z <= numZ; z++) {
for (int y = 1; y <= numY; y++) {
for (int x = 1; x <= numX; x++) {
if (!isBadCell[getCellIndex(x, y, z, numX + 2, numY + 2)] {
// Do stencil Computation
}
}
}
}
您还可以使用一些局部变量删除所有乘法：
int index = (numY + 2) * (numX + 2); // skip top padding plane
for (int z = 1; z <= numZ; z++) {
index += numX + 2; // skip first padding row
for (int y = 1; y <= numY; y++) {
index += 1; // skip first padding col
for (int x = 1; x <= numX; x++, index++) {
if (!isBadCell[index] {
// Do stencil Computation
}
}
index += 1; // skip last padding col
}
index += numX + 2; // skip last padding row
}
这些方向是否正在取决于很大程度上取决于为获得模板值而执行的实际计算。你也应该张贴。
如果您可以更改坏单元格的布尔数组的格式，将线条填充为8的倍数并使用8列的水平填充以改善对齐将非常有用。使布尔数组成为一个位数组，可以通过一次测试一次检查8个，16个，32个甚至64个单元格。
您可以调整数组指针以使用基于0的坐标。
以下是它的工作方式：
int numCellsX = 8 + ((numX + 7) & ~7) + 8;
int numCellsY = 1 + numY + 1;
int numCellsXY = numCellsX * numCellsY;
// adjusted array_pointer
array_pointer = allocated_pointer + 8 + numCellsX + numCellsXY;
// assuming the isBadCell array is 0 based too.
for (int z = 0, indexZ = 0; z < numZ; z++, indexZ += numCellsXY) {
for (int y = 0, indexY = indexZ; y < numY; y++, indexY += numCellsX) {
for (int x = 0, index = indexY; x <= numX - 8; x += 8, index += 8) {
int mask = isBadCell[index >> 3];
if (mask == 0) {
// let the compiler unroll computation for 8 pixels with
for (int i = 0; i < 8; i++) {
// compute stencil value for x+i,y,z at index+i
}
} else {
for (int i = 0; i < 8; i++, mask >>= 1) {
if (!(mask & 1)) {
// compute stencil value for x+i,y,z at index+i
}
}
}
}
int mask = isBadCell[index >> 3];
for (; x < numX; x++, index++, mask >>= 1) {
if (!(mask & 1)) {
// compute stencil value for x,y,z at index
}
}
}
}
修改
模板函数对getCellIndex使用了太多调用。以下是如何使用上面代码中计算的索引值对其进行优化：
// index is the offset of cell x,y,z
// numCellsX, numCellsY are the dimensions of the plane
// numCellsXY is the offset between planes: numCellsX * numCellsY
if (isBadCell[index]) {
double temp = someOtherArray[index] +
1.0 / CONSTANT / CONSTANT *
( - 1.0 * cells[index - 1]
- 1.0 * cells[index + 1]
- 1.0 * cells[index - numCellsX]
- 1.0 * cells[index + numCellsX]
- 1.0 * cells[index - numCellsXY]
- 1.0 * cells[index + numCellsXY]
+ 6.0 * cells[index]
);
cells[index] += -omega * temp / 6.0 * CONSTANT * CONSTANT;
globalTemp += temp * temp;
}
预先计算&cells[index]作为指针可能会改进代码，但编译应该能够检测到这个公共子表达式并生成有效的代码。
<强> EDIT2：
这是一种平铺方法：您可以添加缺少的参数，假设大多数大小是全局的，但您应该将指针传递给具有所有这些值的上下文结构。它使用isBadTile[]和isGoodTile[]：布尔数组，告诉给定的tile是否所有单元格都坏了，所有单元格分别是好的。
void handle_tile(int x, int y, int z, int nx, int ny, int nz) {
int index0 = x + y * numCellsX + z * numCellsXY;
// skipping a tile with all cells bad.
if (isBadTile[index0] && nx == 4 && ny == 4 && nz == 4)
return;
// handling a 4x4x4 tile with all cells OK.
if (isGoodTile[index0] && nx == 4 && ny == 4 && nz == 4) {
for (int iz = 0; iz < 4; iz++) {
for (int iy = 0; iy < 4; iy++) {
for (int ix = 0; ix < 4; ix++) {
int index = index0 + ix + iy * numCellsX + iz + numCellsXY;
// Do stencil computation using `index`
}
}
}
} else {
for (int iz = 0; iz < nz; iz++) {
for (int iy = 0; iy < ny; iy++) {
for (int ix = 0; ix < nx; ix++) {
int index = index0 + ix + iy * numCellsX + iz + numCellsXY;
if (!isBadCell[index] {
// Do stencil computation using `index`
}
}
}
}
}
void handle_cells() {
int x, y, z;
for (z = 1; z <= numZ; z += 4) {
int nz = min(numZ + 1 - z, 4);
for (y = 1; y <= numY; y += 4) {
int ny = min(numY + 1 - y, 4);
for (x = 1; x <= numX; x += 4) {
int nx = min(numX + 1 - x, 4);
handle_tile(x, y, z, nx, ny, nz);
}
}
}
}
这是一个计算isGoodTile[]数组的函数。正确计算的唯一偏移对应于4 + 1，y和z的x倍数，其值最大值小于3。
由于可以计算更少的元素，因此该实现是次优的。不完整的边框拼贴（边缘小于4）可能被标记为不好用单个案例跳过好的情况。如果为边缘图块正确计算了isBadTile数组，则对不良图块的测试可以适用于这些边缘图块，目前情况并非如此。
void computeGoodTiles() {
int start = 1 + numCellsX + numCellsXY;
int stop = numCellsXY * numCellsZ - 1 - numCellsX - numCellsXY;
memset(isGoodTile, 0, sizeof(*isGoodTile) * numCellsXY * numCellsZ);
for (int i = start; i < stop; i += 4) {
isGoodTile[i] = (isBadCell[i + 0] | isBadCell[i + 1] |
isBadCell[i + 2] | isBadCell[i + 3]) ^ 1;
}
for (int i = start; i < stop - 3 * numCellsX; i += 4) {
isGoodTile[i] = isGoodTile[i + 0 * numCellsX] &
isGoodTile[i + 1 * numCellsX] &
isGoodTile[i + 2 * numCellsX] &
isGoodTile[i + 3 * numCellsX];
}
for (int i = start; i < stop - 3 * numCellsXY; i += 4) {
isGoodTile[i] = isGoodTile[i + 0 * numCellsXY] &
isGoodTile[i + 1 * numCellsXY] &
isGoodTile[i + 2 * numCellsXY] &
isGoodTile[i + 3 * numCellsXY];
}
}
void computeBadTiles() {
int start = 1 + numCellsX + numCellsXY;
int stop = numCellsXY * numCellsZ - 1 - numCellsX - numCellsXY;
memset(isBadTile, 0, sizeof(*isBadTile) * numCellsXY * numCellsZ);
for (int i = start; i < stop; i += 4) {
isBadTile[i] = isBadCell[i + 0] & isBadCell[i + 1] &
isBadCell[i + 2] & isBadCell[i + 3];
}
for (int i = start; i < stop - 3 * numCellsX; i += 4) {
isBadTile[i] = isBadTile[i + 0 * numCellsX] &
isBadTile[i + 1 * numCellsX] &
isBadTile[i + 2 * numCellsX] &
isBadTile[i + 3 * numCellsX];
}
for (int i = start; i < stop - 3 * numCellsXY; i += 4) {
isBadTile[i] = isBadTile[i + 0 * numCellsXY] &
isBadTile[i + 1 * numCellsXY] &
isBadTile[i + 2 * numCellsXY] &
isBadTile[i + 3 * numCellsXY];
}
}
答案 1 :(得分：3)
虽然OP要求使用阻止方法，但我建议不要使用阻止。
你看，每个连续的细胞序列（沿着X轴的1D细胞）已经是这样一个块。 阻塞只是将原始问题替换为固定大小的较小副本，而不是使问题更简单，反复重复。
简单地说，阻塞对手头的真正问题毫无帮助。它根本不应该是解决方案的必需功能。
相反，我建议完全避免根本问题 - 只是以不同的方式。
您可以看到，您需要测试每个单元格的“坏单元格”标记（每个单元格一次，不能少），您可以保留坏单元格索引的（已排序）列表。然后，您可以立即处理整个数据集，然后对坏单元格的索引列表中列出的单元格进行修复循环。
另请注意，除非您处理单元格值的副本，否则计算新单元格值的顺序将影响结果。这几乎肯定不是你想要的。
所以，这是我的建议：
#include <stdlib.h>
#include <errno.h>
typedef struct {
/* Core cells in the state, excludes border cells */
size_t xsize;
size_t ysize;
size_t zsize;
/* Index calculation: x + y * ystride + z * zstride */
/* x is always linear in memory; xstride = 1 */
size_t ystride; /* = xsize + 2 */
size_t zstride; /* = ystride * (ysize + 2) */
/* Cell data, points to cell (0,0,0) */
double *current;
double *previous;
/* Bad cells */
size_t fixup_cells; /* Number of bad cells */
size_t *fixup_index; /* Array of bad cells' indexes */
/* Dynamically allocated memory */
void *mem[3];
} lattice;
void lattice_free(lattice *const ref)
{
if (ref) {
/* Free dynamically allocated memory, */
free(ref->mem[0]);
free(ref->mem[1]);
free(ref->mem[2]);
/* then initialize/poison the contents. */
ref->xsize = 0;
ref->ysize = 0;
ref->zsize = 0;
ref->ystride = 0;
ref->zstride = 0;
ref->previous = NULL;
ref->current = NULL;
ref->fixup_cells = 0;
ref->fixup_index = NULL;
ref->mem[0] = NULL;
ref->mem[1] = NULL;
ref->mem[2] = NULL;
}
}
int lattice_init(lattice *const ref, const size_t xsize, const size_t ysize, const size_t zsize)
{
const size_t xtotal = xsize + 2;
const size_t ytotal = ysize + 2;
const size_t ztotal = zsize + 2;
const size_t ntotal = xtotal * ytotal * ztotal;
const size_t double_bytes = ntotal * sizeof (double);
const size_t size_bytes = xsize * ysize * zsize * sizeof (size_t);
/* NULL reference to the variable to initialize? */
if (!ref)
return EINVAL;
/* Initialize/poison the lattice variable. */
ref->xsize = 0;
ref->ysize = 0;
ref->zsize = 0;
ref->ystride = 0;
ref->zstride = 0;
ref->previous = NULL;
ref->current = NULL;
ref->fixup_cells = 0;
ref->fixup_index = NULL;
ref->mem[0] = NULL;
ref->mem[1] = NULL;
ref->mem[2] = NULL;
/* Verify size is nonzero */
if (xsize < 1 || ysize < 1 || zsize < 1)
return EINVAL;
/* Verify size is not too large */
if (xtotal <= xsize || ytotal <= ysize || ztotal <= zsize ||
ntotal / xtotal / ytotal != ztotal ||
ntotal / xtotal / ztotal != ytotal ||
ntotal / ytotal / ztotal != xtotal ||
double_bytes / ntotal != sizeof (double) ||
size_bytes / ntotal != sizeof (size_t))
return ENOMEM;
/* Allocate the dynamic memory needed. */
ref->mem[0] = malloc(double_bytes);
ref->mem[1] = malloc(double_bytes);
ref->mem[2] = malloc(size_bytes);
if (!ref->mem[0] || !ref->mem[1] || !ref->mem[2]) {
free(ref->mem[2]);
ref->mem[2] = NULL;
free(ref->mem[1]);
ref->mem[1] = NULL;
free(ref->mem[0]);
ref->mem[0] = NULL;
return ENOMEM;
}
ref->xsize = xsize;
ref->ysize = ysize;
ref->zsize = zsize;
ref->ystride = xtotal;
ref->zstride = xtotal * ytotal;
ref->current = (double *)ref->mem[0] + 1 + xtotal;
ref->previous = (double *)ref->mem[1] + 1 + xtotal;
ref->fixup_cells = 0;
ref->fixup_index = (size_t *)ref->mem[2];
return 0;
}
请注意，我更喜欢x + ystride * y + zstride * z上的x + xtotal * (y + ytotal * z)索引计算表，因为前者的两次乘法可以并行完成（在超标量流水线中，在可以进行两次无关整数乘法的架构上）同时在单个CPU核心上），而在后者中，乘法必须是连续的。
注意ref->current[-1 - ystride - zstride]是指单元格（-1，-1，-1）处的当前单元格值，即来自原始单元格（0,0,0）的边界单元格对角线。换句话说，如果您在索引i处有一个单元格（ x ， y ， z ），那么
i-1是（ x -1， y ， z ）的单元格
i+1是（ x +1， y ， z ）的单元格
i-ystride是（ x ， y -1， z ）的单元格
i+ystride是（ x ， y +1， z ）的单元格
i-zstride是（ x ， y ， z -1）的单元格
i+zstride是（ x ， y ， z -1）的单元格
i-ystride是（ x ， y -1， z ）的单元格
i-1-ystride-zstride是（ x -1， y -1， z -1）的单元格
i+1+ystride+zstride是（ x +1， y +1， z +1）的单元格
等等。
ref->fixup_index数组足以列出除边框单元格以外的所有单元格。保持排序（或在构建之后对其进行排序）是个好主意，因为这有助于缓存局部性。
如果您的晶格具有周期性边界条件，则可以使用六个2D循环，十二个1D循环和八个副本将第一个和最后一个有效单元格复制到边框，然后再开始新的更新。
因此，您的更新周期基本上是：
在->current。
交换->current和->previous。
使用->current中的数据计算->previous的所有单元格。
循环->fixup_cells中的->fixup_index索引，并重新计算相应的->current单元格。
请注意，在第3步中，您可以对0和xsize-1 + (ysize-1)*ystride + (zsize-1)*zstride之间的所有索引进行线性处理;也就是说，包括约67％的边界细胞。与整个体积相比，它们相对较少，并且具有单个线性环可能比跳过边界单元更快 - 特别是如果您可以向量化计算。 （在这种情况下，这是非常重要的。）
您甚至可以通过为每个线程提供一组连续的索引来分割多个线程的工作。因为你从->previous读取并写入->current，所以线程不会互相践踏，尽管如果一个线程到达其区域的末尾而另一个线程位于其中，则可能存在一些高速缓存线乒乓。该地区的起点;由于数据的定向方式（缓存行只有几个 - 通常是2个，4个或8个单元格），乒乓球在实践中不应成为问题。 （显然，不需要锁。）
这个特殊问题并不是什么新鲜事。建模Conway's Game of Life或square- or cubic-lattice Ising model以及实现许多其他格子模型都涉及相同的问题（但通常使用布尔数据而不是双精度，并且没有“坏单元”）。
答案 2 :(得分：2)
我认为你可能会嵌套一些类似的循环。像这样：
for(int z = 1; z < numZ+1; z+=4) {
for(int y = 1; y < numY+1; y+=4) {
for(int x = 1; x < numX+1; x+=4) {
if(!isBadBlock[ getBlockIndex(x>>2,y>>2,z>>2) ]) {
for(int zz = z; zz < z + 4 && zz < numZ+1; zz++) {
for(int yy = y; yy < y + 4 && yy < numY+1; yy++) {
for(int xx = z; xx < x + 4 && xx < numX+1; xx++) {
if(!isBadCell[ getCellIndex(xx,yy,zz) ]) {
// Do stencil Computation
}
}
}
}
}
}
}
}
答案 3 :(得分：2)
您目前设置的方式，您只需使用3d数组获取索引，如下所示：
#include <sys/types.h>
#define numX 256
#define numY 128
#define numZ 64
//Note the use of powers of 2 - it will simplify things a lot
int cells[numX][numY][numZ];
size_t getindex(size_t x, size_t y,size_t z){
return (int*)&cells[x][y][z]-(int*)&cells[0][0][0];
}
这将列出如下单元格：
[0,0,0][0,0,1][0,0,2]...[0,0,numZ-1]
[0,1,0][0,1,1][0,1,2]...[0,1,numZ-1]
...
[0,numY-1,0][0,numY-1,1]...[0,1,numZ-1]
...
[1,0,0][1,0,1][0,0,2]...[1,0,numZ-1]
[1,1,0][1,1,1][1,1,2]...[1,1,numZ-1]
...
[numX-1,numY-1,0][numX-1,numY-1,1]...[numX-1,numY-1,numZ-1]
So efficient loops would look like:
for(size_t x=0;x<numX;x++)
for(size_t y=0;y<numY;y++)
for(size_t z=0;z<numZ;z++)
//vector operations on z values
但是，如果你想将它分成4x4x4块，你可以使用4x4x4块的3d数组：
#include <sys/types.h>
#define numX 256
#define numY 128
#define numZ 64
typedef int block[4][4][4];
block blocks[numX][numY][numZ];
//add a compiler specific 64 byte alignment to help with cache misses?
size_t getblockindex(size_t x, size_t y,size_t z){
return (block *)&blocks[x][y][z]-(block *)&blocks[0][0][0];
}
我将索引重新排序为x，y，z，所以我可以将它们直接放在我的脑海中，但要确保你订购它们，以便最后一个是你在一个最内层的系列中操作的那个循环