title: Parallel Image Processing in OpenMP - Splitting Image
body: <p>I have a function defined by Intel IPP to operate on an Image / Region of Image.<br>
  The input to the image are the pointer to the image, parameters to define the size to process and parameters of the filter.<br>
  The IPP function is single threaded.  </p>
  
  <p>Now, I have an image of size M x N.<br>
  I want to apply the filter on it in parallel.<br>
  The main idea is simple, break the image into 4 sub images which are independent of each other.<br>
  Apply the filter to each sub image and write the result to a sub block of an empty image where each thread write to a distinct set of pixels.<br>
  It's really like processing 4 images each on it own core.  </p>
  
  <p>This is the program I'm doing it with:</p>
  
  <pre><code>void OpenMpTest()
  {
      const int width  = 1920;
      const int height = 1080;
  
      Ipp32f input_image[width * height];
      Ipp32f output_image[width * height];
  
      IppiSize size = { width, height };
  
      int step = width * sizeof(Ipp32f);
  
      /* Splitting the image */
      IppiSize section_size = { width / 2, height / 2};
  
      Ipp32f* input_upper_left  = input_image;
      Ipp32f* input_upper_right = input_image + width / 2;
      Ipp32f* input_lower_left  = input_image + (height / 2) * width;
      Ipp32f* input_lower_right = input_image + (height / 2) * width + width / 2;
  
      Ipp32f* output_upper_left  = input_image;
      Ipp32f* output_upper_right = input_image + width / 2;
      Ipp32f* output_lower_left  = input_image + (height / 2) * width;
      Ipp32f* output_lower_right = input_image + (height / 2) * width + width / 2;
  
      Ipp32f* input_sections[4] = { input_upper_left, input_upper_right, input_lower_left, input_lower_right };
      Ipp32f* output_sections[4] = { output_upper_left, output_upper_right, output_lower_left, output_lower_right };
  
      /* Filter Params */
      Ipp32f pKernel[7] = { 1, 2, 3, 4, 3, 2, 1 };
  
      omp_set_num_threads(4);
      #pragma omp parallel for
      for (int i = 0; i &lt; 4; i++)
          ippiFilterRow_32f_C1R(
                                input_sections[i], step,
                                output_sections[i], step,
                                section_size, pKernel, 7, 3);
  }
  </code></pre>
  
  <p>Now, the issues is I see no gain versus working Single Threaded mode on all image.<br>
  I tried to change the image size or filter size and nothing will the change the picture.<br>
  The most I could gain was nothing significant (10-20%).</p>
  
  <p>I thought it might have something to do with that I can't "Promise" each thread the zone it received is "Read Only".<br>
  Moreover to let it know the memory location it writes to is also belongs only to himself.<br>
  I read about defining variables as private and share, yet I couldn't find a guide to deal with arrays and pointers.</p>
  
  <p>What would be the proper way to deal with pointers and sub arrays in OpenMP?</p>