Great questions! Let's tackle them one by one with practical, actionable advice.

First off, you might not need to roll your own threading for filter2D—OpenCV has built-in parallelization support that’s enabled by default if the library was compiled with a parallel backend (like OpenMP, TBB, or pthreads). Here’s how to work with it:

• Check if parallelization is active: Use cv::getNumberOfThreads() to see how many threads OpenCV is configured to use. By default, it’ll match your CPU’s core count.
• Adjust thread count: If you want to control the number of threads explicitly (e.g., for fair performance comparisons), use cv::setNumberOfThreads(N) where N is your desired thread count. For example:

  cv::setNumberOfThreads(4); // Limit to 4 threads
  cv::filter2D(src, dst, -1, kernel); // Automatically uses parallel execution
  

• Verify OpenCV build configuration: If parallelization isn’t working, check if your OpenCV build includes parallel backends. Run cv::getBuildInformation() and look for entries like WITH_OPENMP=ON or WITH_TBB=ON. If not, you’ll need to recompile OpenCV with these flags enabled.

Your manual AVX2 + OpenMP implementation is a great way to dive into low-level optimization, but comparing it fairly with filter2D requires some careful setup:

Step 1: Ensure a Level Playing Field #

• Control variables: Use identical input images (same size, depth, channel count), identical convolution kernels, and set the same thread count for both your implementation and OpenCV (via cv::setNumberOfThreads()).
• Accurate timing: Use high-precision timers to avoid skewed results. OpenCV’s cv::TickMeter is perfect for this, or you can use C++ <chrono>:

  cv::TickMeter tm;
  tm.start();
  for (int i = 0; i < 100; ++i) { // Run multiple times to average out noise
      cv::filter2D(src, dst, -1, kernel);
  }
  tm.stop();
  std::cout << "filter2D average time: " << tm.getTimeMilli() / 100 << " ms" << std::endl;
  

  Do the same for your AVX2 implementation to get a fair comparison.

Step 2: Why filter2D Might Outperform (or Underperform) Your Code #

OpenCV’s filter2D isn’t just a black box—it’s heavily optimized:

• It uses SIMD instructions (AVX, SSE, NEON) under the hood, just like your implementation, but with hand-tuned assembly for different architectures.
• It includes cache optimization strategies (like blocking) to minimize memory access latency.
• Its parallelization is fine-tuned to balance workload across threads, avoiding overhead from uneven task distribution.

Step 3: A More Elegant Alternative to Pthreads for Manual Parallel filter2D #

If you still want to manually parallelize filter2D (e.g., for custom workload partitioning), skip pthreads and use OpenMP’s region-based parallelism to split the image into vertical or horizontal ROIs (regions of interest). This is far cleaner than managing thread creation/joining manually:

#pragma omp parallel num_threads(4)
{
    int thread_id = omp_get_thread_num();
    int num_threads = omp_get_num_threads();
    int rows_per_thread = src.rows / num_threads;
    int start_row = thread_id * rows_per_thread;
    int end_row = (thread_id == num_threads - 1) ? src.rows : start_row + rows_per_thread;

    cv::Mat src_roi = src(cv::Range(start_row, end_row), cv::Range::all());
    cv::Mat dst_roi = dst(cv::Range(start_row, end_row), cv::Range::all());

    cv::filter2D(src_roi, dst_roi, -1, kernel);
}

This way, each thread handles a contiguous chunk of the image, and OpenMP manages thread lifecycle automatically—no messy pthread boilerplate.

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