Question

我需要编写一个程序，将图像读入数组，执行卷积运算（锐化），然后将其保存回文件（ppm）。我写了一个标准算法：

    unsigned char* imgBefore = malloc(height*(3*width)*sizeof(unsigned char));
    assert(fread(imgBefore, 3*width, height, inputFile) == height);
    unsigned char* imgAfter = malloc(height*(3*width)*sizeof(unsigned char));

    short ker[3][3] = {{0, -1, 0}, {-1, 5, -1}, {0, -1, 0}};

    unsigned char r, g, b;

    for(int y = 0; y < height; y++) {
        for(int x = 0; x < width; x++) {
            if(y == 0 || y == height-1 || x == 0 || x == width-1) {
                r = imgBefore[3*(width*y + x) + 0];
                g = imgBefore[3*(width*y + x) + 1];
                b = imgBefore[3*(width*y + x) + 2];
                imgAfter[3*(width*y + x) + 0]  = r;
                imgAfter[3*(width*y + x) + 1]  = g;
                imgAfter[3*(width*y + x) + 2]  = b;
                continue;
            }

            int rSum = 0, gSum = 0, bSum = 0, val;

            for(int dy = 0; dy < 3; dy++) { // kernels height
                int yy = 3*width*(y+dy-1);
                for(int dx = 0; dx < 3; dx++) { // kerenels width
                    int xx = 3*(x+dx-1);
                    val = ker[dy][dx];

                    rSum += val * imgBefore[yy + xx + 0];
                    gSum += val * imgBefore[yy + xx + 1];
                    bSum += val * imgBefore[yy + xx + 2];
                }
            }
            rSum = rSum < 0 ? 0 : (rSum > 255 ? 255 : rSum);
            gSum = gSum < 0 ? 0 : (gSum > 255 ? 255 : gSum);
            bSum = bSum < 0 ? 0 : (bSum > 255 ? 255 : bSum);

            imgAfter[3*(width*y + x) + 0] = rSum;
            imgAfter[3*(width*y + x) + 1] = gSum;
            imgAfter[3*(width*y + x) + 2] = bSum;
        }
    }

    fwrite(imgAfter, 3*width, height, outputFile);

接下来，我需要优化其与缓存交互的有效性。在我看来，问题所在在这段代码中：

for(int dy = 0; dy < 3; dy++) { // kernels height
    int yy = 3*width*(y+dy-1);
    for(int dx = 0; dx < 3; dx++) { // kerenels width
        int xx = 3*(x+dx-1);
        val = ker[dy][dx];

        rSum += val * imgBefore[yy + xx + 0];
        gSum += val * imgBefore[yy + xx + 1];
        bSum += val * imgBefore[yy + xx + 2];
    }
}

因为它首先加载矩阵的一行，仅使用3（9）个元素，然后转到下一行。对于缓存而言，这似乎完全无效。

该如何解决？

我还尝试重用单个像素或整个行。所有这一切只会使结果恶化（我很有可能只是简单地实现了诸如FIFO之类的结构较差的结构，或者在错误的位置添加了它们并从中读取了错误的信息）。如果程序需要它，应该看起来如何？为了进行评估，我使用：valgrind --tool = cachegrind --I1 = 32768,8,64 --D1 = 32768,8,64 --LL = 1048576,16,64 ./a.out

如果有任何建议，我将不胜感激

Answer 1

访问数据的方式不适用于大图像缓存。可以对此进行改进（例如使用平铺）。

请注意，此程序的计算时间不受内存层次结构的限制，而是受效率低下的数据布局导致的基于顺序标量的缓慢计算计算的限制。

以下是使用4608 x 3456 x 3图片在10个模板函数调用中的Valgrind分析结果：

--171871-- warning: L3 cache found, using its data for the LL simulation.
--171871-- warning: specified LL cache: line_size 64  assoc 12  total_size 9,437,184
--171871-- warning: simulated LL cache: line_size 64  assoc 18  total_size 9,437,184
==171871== 
==171871== I   refs:      30,437,416,378
==171871== I1  misses:               944
==171871== LLi misses:               938
==171871== I1  miss rate:           0.00%
==171871== LLi miss rate:           0.00%
==171871== 
==171871== D   refs:       7,526,412,742  (7,000,797,573 rd   + 525,615,169 wr)
==171871== D1  misses:        30,599,898  (   22,387,768 rd   +   8,212,130 wr)
==171871== LLd misses:        15,679,220  (    7,467,138 rd   +   8,212,082 wr)
==171871== D1  miss rate:            0.4% (          0.3%     +         1.6%  )
==171871== LLd miss rate:            0.2% (          0.1%     +         1.6%  )
==171871== 
==171871== LL refs:           30,600,842  (   22,388,712 rd   +   8,212,130 wr)
==171871== LL misses:         15,680,158  (    7,468,076 rd   +   8,212,082 wr)
==171871== LL miss rate:             0.0% (          0.0%     +         1.6%  )

首先，我们可以看到有很多D1 cache reference（由于标量访问，每个写入像素为47个）。

D1 misses和D1 miss rate的数量似乎很小，因此我们可以认为缓存访问是好的。但事实并非如此。 Valgrind的结果极具误导性，因为D1 cache reference使用1字节标量粒度，而D1 misses使用64字节缓存行粒度。

如果我们仔细分析一下分析，我们可以看到几乎所有写入的数据都导致D1高速缓存未命中。而且，从L1读取的数据的20％需要从LLC（重新）加载（对于从D1缓存读取的7 GB，从LLC加载1.43 GB）。

问题来自图像的大线条。实际上，1条图像行占用4608 * 3 = 13824字节，写3行需要3行。因此，从D1高速缓存中读取41472字节以写入13824字节。从理论上讲，如果D1缓存足够大，则应从D1缓存中重新使用27648。但是，D1缓存太小，无法容纳所有读取/写入的数据（大致是因为41472+13824 > 32768）。

我们可以使用两种方法来改善这种情况：

平铺：想法是将x循环边界设置为较小的固定大小（例如1024），以便它将计算图像的垂直块，然后添加新的包围xBlock循环（包括y和x循环），该循环遍历垂直块。这种方法的好处是可以提高D1缓存的重用性，但仍可能导致现代处理器上出现一些不必要的缓存丢失（因为加载的行不再是连续的）。您可以通过在y维上进行平铺或调整数据布局来减轻这种情况。这是一个示例：

const int blockSize = 1024;
for(int xBlock = 0; xBlock < width; xBlock+=blockSize) {
    for(int y = 0; y < height; y++) {
        int xMax = xBlock + blockSize;
        if(xMax > width)
            xMax = width;
        for(int x = xBlock; x < xMax; x++) {
            // Unchanged part of the code
        }
    }
}

非临时存储：将数据写入高速缓存层次结构会导致高速缓存污染，从而导致额外的高速缓存未命中（因为写入的数据需要驱逐先前读取的高速缓存行）。它还可能在某些架构上（例如，在Intel处理器上）引起更多负载。我们可以告诉处理器将数据直接写入内存。一些编译器提供了#pragma指令来执行此操作（手动执行此操作在您的代码中有些棘手）。仅当图像太大而无法放入LLC缓存中或以后不重用时，这才是好方法。有关更多信息，请参见here。

以下是应用切片方法后的Valgrind结果：

==183432== D   refs:       7,527,450,132  (7,001,731,093 rd   + 525,719,039 wr)
==183432== D1  misses:        16,025,288  (    7,640,368 rd   +   8,384,920 wr)
==183432== LLd misses:        16,024,790  (    7,639,918 rd   +   8,384,872 wr)

我们可以看到，现在D1缓存未命中的次数减少了2倍（读取次数减少了3倍）。

在C语言中处理图像时算法的优化（图像卷积）

1 个答案: