Как разбить массив на блоки

хотя OP требует подхода с использованием блокировки, я бы предложил против этого.

вы видите, что каждая последовательная последовательность ячеек (1D ячеек вдоль оси X) уже является таким блоком. вместо того, чтобы сделать проблему проще, блокировка просто заменяет исходную проблему меньшими копиями фиксированного размера, повторяемыми снова и снова.

проще говоря, блокировка не помогает вообще с реальной проблемой. Это не должно быть реквизит особенность решения вообще.

вместо этого я бы предложил вообще избегать корневой проблемы-просто по-другому.

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

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

Итак, вот мое предложение:

#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), потому что два умножения в первом могут выполняться параллельно (в суперскалярном конвейере, на архитектурах, которые могут делать два несвязанные целочисленные умножения одновременно на одном ядре процессора), тогда как в последнем умножения должны быть последовательными.

отметим, что ref->current[-1 - ystride - zstride] относится к текущему значению ячейки в ячейке (-1, -1, -1), т. е. диагонали ячейки границы от исходной ячейки (0, 0, 0). Другими словами, если у вас есть сотовый (x, y, z) по индексу i, тогда
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-петель и восемь копий для копирования первой и последней допустимых ячеек на границу перед началом нового обновления.

поэтому ваш цикл обновления по существу:

1. вычислить или заполнить границы в ->current.

2. обмен ->current и ->previous.

3. вычислить все ячейки для ->current использование данных из ->previous.

4. петли над ->fixup_cells индексы в ->fixup_index, и пересчитать соответствующие ->current клетки.

обратите внимание, что на Шаге 3, Вы можете сделать это линейно для всех индексов между 0 и xsize-1 + (ysize-1)*ystride + (zsize-1)*zstride, включительно; то есть, включая около 67% границы ячейки. Их относительно мало по сравнению со всем объемом, и наличие одного линейного цикла, вероятно, быстрее, чем пропуск через пограничные ячейки, особенно если вы можете векторизовать вычисления. (Что в данном случае нетривиально.)

вы даже можете разделить работу для нескольких потоков, предоставляя каждому потоку непрерывный набор индексов для работы. Потому что Вы читаете из ->previous и писать ->current потоки не затоптали друг друга, хотя могут быть некоторые если поток достигает конца своей области, в то время как другой находится в начале своей области; из-за того, как данные ориентированы (а строк кэша всего несколько-обычно 2, 4 или 8-ячеек), этот пинг-понг не должен быть проблемой на практике. (Очевидно, никакие замки не нужны.)

эта проблема является не Новой в любом случае. Моделирование Игра жизни Конвея или квадратная или кубическая решетчатая модель Изинга, а также реализация многих других решеточных моделей связана с той же проблемой (но часто с булевыми данными, а не двойниками, и без "плохих ячеек").

Я думаю, вы можете вложить пару подобных наборов петель. Что-то вроде этого:--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
                            }
                        }
                    }
                }
            }
        }
    }
}

способ, которым вы в настоящее время его настроили, вы можете просто получить индекс, используя 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, вы можете просто использовать 3D-массив из блоков 4x4x4 что-то вроде:

#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, чтобы я мог держать их прямо в голове, но убедитесь, что вы заказываете их так, чтобы последний из них был тем, который вы оперируете на серия в ваших сокровенных петлях.