快速交错数据

Question

我正在处理某些硬件（硬件本身并不重要），我需要将一些块数据拆分为单独的部分，以使事情运行得更快。

所以我有，例如一个连续的内存块X字长。对于可视化，我将其排列在下面的50个字行中：

001  002  003  004  005 006 007 ...
051  052  053  054  055 056 057 ...
101  102  103  104  105 106 107 ...
151  152  153  154  155 156 157 ...

我需要一种快速的方法将它们分成四个独立的块：

块1

001  003  005 007 ...
101  103  105 107 ...

块2

002  004  006 ...
102  104  106 ...

块3

051  053  055 057 ...
151  153  155 157 ...

块4

052  054  056 ...
152  154  156 ...

或者，基本上：

Block1   Block2   Block1   Block2 ...
Block3   Block4   Block3   Block4 ...
Block1   Block2   Block1   Block2 ...
Block3   Block4   Block3   Block4 ...

现在这样做就像使用for循环一样简单。但是这样做的更优化/并行方式是什么？ （没有MPI的东西，这发生在桌面上运行的应用程序上。）

所以总结一下，只是为了清楚：

1. 我的数据如上所示。

2. 我将这些数据发送到多个设备（PC外）。这些数据需要作为4个独立的块（到单独的设备）在线路上发送。

Answer 1

这是SSE可以帮助您的一个主要示例。它非常擅长数据混洗以及来自内存和后端的流数据。在一些非x86架构上，有类似的ISA扩展可用（例如AltiVec）

Answer 2

编辑：听起来你正在将数据传递给外部接口。如果这与千兆位以太网接口一样慢，那么瓶颈就在线上，而不是组合数据的速度。只需迭代数据即可以任何方式构建您的块，这对您的代码来说非常方便。

---

也许您想要做的是使用偏移/步幅符号传递块。本质上，每个块都是从它的起始地址，第一个元素出现的块，元素之间的字节数和行之间的字节数来描述的。所以，像：

       Block
         1    2    3    4
base     0    0    50   50
first    0    1    0    1
offset   2    2    2    2
stride   100  100  100  100

所以你可以并行处理数据（假设你不必担心写入）这样的事情

struct Block {
    int base;
    int first;
    int offset;
    int stride;
    int cols; rows;
};

/* given some reasonable block[n] and buffer */

for ( int row = 0; col < block[n].rows; ++row)
    for (int col = 0; row < block[n].cols; ++col)
    {
        int cell = buffer[
                      block[n].base + 
                      block[n].first +
                      row*block[n].stride + 
                      col*block[n].offset]
        doSomething(cell);
    }