如何用Pthreads直接在原图像矩阵上实现5x5卷积滤波

问题背景 #

现有一个M×N的图像矩阵，添加2层边界后存储在image[N+4][M+4]中，使用Pthreads并行执行5×5卷积滤波。当前实现依赖filteredImage存储结果，希望修改代码，直接在image矩阵上完成计算，无需额外结果矩阵。

当前核心代码（原threadTask及相关函数）：

int operation(int x_coord, int y_coord) {
    int res = 0;
    int offset = n / 2;

    for (int x = 0; x < n; x++) {
        for (int y = 0; y < m; y++) {
            res += image[x_coord - offset + x][y_coord - offset + y] * filter[x][y];
        }
    }
    return res;
}

void threadTask(int start, int end) {
    if (M > N) {
        for (int j = start; j < end; j++) {
            for (int i = 2; i < N + 2; i++) {
                filteredImage[i][j] = operation(i, j);
            }
        }
    }
    else
    {
        for (int i = start; i < end; i++) {
            for (int j = 2; j < M + 2; j++) {
                filteredImage[i][j] = operation(i, j);
            }
        }
    }
}

解决方案：基于屏障同步的原地修改 #

核心思路：先基于原始图像数据计算所有线程负责区域的新值（暂存到局部缓冲区），等待所有线程完成计算后，再统一将新值写回原图像矩阵。既避免计算过程中原始数据被覆盖的错误，又无需全局的filteredImage。

步骤1：添加全局屏障变量 #

在全局作用域声明Pthreads屏障（确保所有线程可见）：

#include <pthread.h>

// 全局屏障，初始化时设置为线程数p
pthread_barrier_t conv_barrier;

同时在paralel()函数中初始化/销毁屏障：

void paralel() {
    thread threads[16]; //max nr of p
    int start = 2;
    int end;
    int nrMax;
    int operationsPerThread;
    int rest;
    nrMax = max(N, M);
    operationsPerThread = nrMax / p;
    rest = nrMax % p;

    // 初始化屏障，等待p个线程到达
    pthread_barrier_init(&conv_barrier, NULL, p);

    for (int i = 0; i < p; i++)
    {
        end = start + operationsPerThread;
        if (rest > 0) {
            rest--;
            end++;
        }
        threads[i] = thread(threadTask, start, end);
        start = end;
    }
    for (int i = 0; i < p; i++) {
        threads[i].join();
    }

    // 销毁屏障
    pthread_barrier_destroy(&conv_barrier);
}

步骤2：修改threadTask函数 #

修改后的函数会先计算并暂存新值，等待屏障同步后再写回原矩阵：

void threadTask(int start, int end) {
    int** temp_buffer = NULL;
    int buf_rows, buf_cols;
    const int orig_start_i = 2, orig_end_i = N + 2;
    const int orig_start_j = 2, orig_end_j = M + 2;

    if (M > N) {
        // 线程负责j范围[start, end)，i固定为[2, N+2)
        buf_rows = N;
        buf_cols = end - start;
        temp_buffer = (int**)malloc(buf_rows * sizeof(int*));
        for (int i = 0; i < buf_rows; i++) {
            temp_buffer[i] = (int*)malloc(buf_cols * sizeof(int));
        }

        // 第一步：基于原始image计算新值，存入局部缓冲区
        int buf_j = 0;
        for (int j = start; j < end; j++) {
            for (int i = orig_start_i; i < orig_end_i; i++) {
                temp_buffer[i - orig_start_i][buf_j] = operation(i, j);
            }
            buf_j++;
        }
    } else {
        // 线程负责i范围[start, end)，j固定为[2, M+2)
        buf_rows = end - start;
        buf_cols = M;
        temp_buffer = (int**)malloc(buf_rows * sizeof(int*));
        for (int i = 0; i < buf_rows; i++) {
            temp_buffer[i] = (int*)malloc(buf_cols * sizeof(int));
        }

        // 第一步：基于原始image计算新值，存入局部缓冲区
        int buf_i = 0;
        for (int i = start; i < end; i++) {
            for (int j = orig_start_j; j < orig_end_j; j++) {
                temp_buffer[buf_i][j - orig_start_j] = operation(i, j);
            }
            buf_i++;
        }
    }

    // 等待所有线程完成计算，确保原始数据未被修改
    pthread_barrier_wait(&conv_barrier);

    // 第二步：将局部缓冲区的新值写回原image矩阵
    if (M > N) {
        int buf_j = 0;
        for (int j = start; j < end; j++) {
            for (int i = orig_start_i; i < orig_end_i; i++) {
                image[i][j] = temp_buffer[i - orig_start_i][buf_j];
            }
            buf_j++;
        }
    } else {
        int buf_i = 0;
        for (int i = start; i < end; i++) {
            for (int j = orig_start_j; j < orig_end_j; j++) {
                image[i][j] = temp_buffer[buf_i][j - orig_start_j];
            }
            buf_i++;
        }
    }

    // 释放局部缓冲区内存
    const int row_count = M > N ? N : end - start;
    for (int i = 0; i < row_count; i++) {
        free(temp_buffer[i]);
    }
    free(temp_buffer);
}

方案优势 #

• 内存高效：每个线程仅分配负责区域大小的局部缓冲区，比全局filteredImage占用内存更少。
• 无数据竞争：屏障确保所有线程都基于原始数据完成计算后才写回，避免原始数据被覆盖导致的计算错误。
• 低侵入性：无需修改原有的operation函数和边界处理逻辑，仅调整threadTask和添加屏障同步。

注意事项 #

1. 屏障初始化的线程数必须与实际创建的线程数p一致，否则会导致死锁。
2. 局部缓冲区的内存分配需根据线程负责区域动态调整，避免内存浪费。
3. 若图像尺寸极大，可进一步优化为仅复制线程计算所需的原始边界数据，但实现复杂度会更高，当前方案在大多数场景下已足够高效。

内容的提问来源于stack exchange，提问作者user16679629