#include <stdio.h>

// need to create specific function versions for the following processors:
__declspec(cpu_dispatch(generic, core_2_duo_ssse3, core_i7_sse4_2, core_2nd_gen_avx))
void dispatch_func() {};      //  stub that will call the appropriate specific function version

__declspec(cpu_specific(generic))
void dispatch_func() {
printf("\nCode for non-Intel processors and generic Intel processors goes here\n");
}

__declspec(cpu_specific(core_2_duo_ssse3))
void dispatch_func() {
printf("\nCode for Intel Core 2 Duo processors with support for SSSE3 goes here\n");
}

__declspec(cpu_specific(core_i7_sse4_2))
void dispatch_func() {
printf("\nCode for Intel Core processors with support for SSE4.2 goes here\n");
}

__declspec(cpu_specific(core_2nd_gen_avx))
void dispatch_func() {
printf("\nCode for 2nd generation Intel Core processors goes here\n");
}

int main() {
dispatch_func();
printf("Return from dispatch_func\n");
return 0;
}

Optimization Notice

Intel's compilers may or may not optimize to the same degree for non-Intel microprocessors for optimizations that are not unique to Intel microprocessors. These optimizations include SSE2, SSE3, and SSSE3 instruction sets and other optimizations. Intel does not guarantee the availability, functionality, or effectiveness of any optimization on microprocessors not manufactured by Intel. Microprocessor-dependent optimizations in this product are intended for use with Intel microprocessors. Certain optimizations not specific to Intel microarchitecture are reserved for Intel microprocessors. Please refer to the applicable product User and Reference Guides for more information regarding the specific instruction sets covered by this notice. Notice revision #20110804

[DISCLAIMER: The information on this web site is intended for hardware system manufacturers and software developers. Intel does not warrant the accuracy, completeness or utility of any information on this site. Intel may make changes to the information or the site at any time without notice. Intel makes no commitment to update the information at this site. ALL INFORMATION PROVIDED ON THIS WEBSITE IS PROVIDED "as is" without any express, implied, or statutory warranty of any kind including but not limited to warranties of merchantability, non-infringement of intellectual property, or fitness for any particular purpose. Independent companies manufacture the third-party products that are mentioned on this site. Intel is not responsible for the quality or performance of third-party products and makes no representation or warranty regarding such products. The third-party supplier remains solely responsible for the design, manufacture, sale and functionality of its products. Intel and the Intel logo are trademarks or registered trademarks of Intel Corporation or its subsidiaries in the United States and other countries. *Other names and brands may be claimed as the property of others.]

1. Build system requirement

Software:
•   Intel Parallel Studio 2011 and Microsoft* Visual Studio 2005 and later
•   (optional)  install static ipp library separately from http://software.intel.com/en-us/articles/intel-ipp-static-libraries/

Hardware:  The latest dual-core/Quad Core machine with Windows xp/Windows Vista/Windows 7

2. Download and Unzip the Resize_Image_PS_VS2005.zip to a directory, let's name <WorkDIR>

3. Go to <WorkDIR> and double click the Resize Image.sln.  The msvc2005 IDE will prompt automatically.

4. From the main toolbar select Project>> Intel Parallel Composer 2011 » Select Build Component.

(or right-click the Project in Solution Explorer) , check Use IPP. click OK

5. Then build the application, from the main toolbar select Build >> Build solution

Please see the build details in  Use Intel IPP in Intel® Parallel Composer

How to run the application 

1. Run the application
From the main toolbar, select Debug >> Start Without Debugging. The application windows start, Click Open File, Select LennaC1.bmp 

2. click menu "Process => Resize image" to Resize the image. 
 Enter the zoom factor in horizontal (x) and vertical (y) directory in Resize dialog box.  Click OK  

3: Click lennC1.bmp and repeat step 2 again, make sure click button USE_IPP. Then get the below image  

IPP Function Adoption: 
Assume the sample is the application we want to improve the performance via IPP function.  
1.  Find the c code resize image function in RESIZE.cpp

unsigned long C_Code_Resize(unsigned char * src, int srcWidth, int srcHeight,   int srcStep, unsigned char* dst, int dstWidth, int dstHeight, int dstStep, double m_zoom_x, double m_zoom_y, int interpolation)

 It is called by function ProcessImage(CSampleDoc *pSrc) in ippiAddC.cpp

2. Check ipp manual ippiman.pdf and find the function ippiResizeSqrPixel have same functionality.  Then replace the C function with IPP function.  
Declare a similiar function in RESIZE.cpp
unsigned long IPP_Resize( void* src, int srcWidth, int srcHeight,int srcStep,  void* dst,  int dstWidth, int dstHeight, int dstStep, double m_nzoom_x, double m_nzoom_y, int interpolation)

 And call it in ProcessImage(CSampleDoc *pSrc) in ippiAddC.cpp instead of call C_Code_Resize().  (In order to compare the performance, we keep the c function call here.)

 if (m_USE_IPP)
{
             ippStaticInit();
       //---- perform IPP Funtion Code to rotate a image  -----//
         run_time = IPP_Resize(pSrc->DataPtr(),pSrc->Width(),pSrc->Height(),pSrc->Step(),(Ipp8u*)pDst->DataPtr(),        pDst->Width(),pDst->Height(),pDst->Step(),m_zoom_x,m_zoom_y,m_Interpolation);
}
else{         //---- perform C Code to rotate a image  -----//
         run_time = C_Code_Resize((unsigned char *)pSrc->DataPtr(),pSrc->Width(),
         pSrc->Height(),pSrc->Step(), (unsigned char *)pDst->DataPtr(), pDst->Width(),pDst->Height(),pDst->Step(),m_zoom_x,m_zoom_y,m_Interpolation);
}     

3. Write the IPP code to replace the C code.  The table show the original C code and the IPP code 

Tthe C code

The IPP code

unsigned long C_Code_Resize(unsigned char * src, int srcWidth, int srcHeight,int srcStep, unsigned char* dst, int dstWidth, int dstHeight, int dstStep, double m_zoom_x, double m_zoom_y, int interpolation) {//---------- Perform 1 order linear ---      //define record time variable      unsigned long start_clock,stop_clock;    start_clock = RUNTIME;      const unsigned char *tmpSrc;     unsigned char *tmpRef;     int width = srcWidth;     int height = srcHeight;     double xInv = 1.0 /  m_zoom_x;     double yInv = 1.0 /  m_zoom_y;     int colInd, rowInd;     int i, j, xSrc0, xSrc1, ySrc0, ySrc1, wdroi, hdroi;     int idxl, idyt, icol, jrow;     double row, col;     double y1, y2, y3, y4, v, v1, v2, tempV,tempV2;      idxl=0;      idyt=0;      wdroi = dstWidth;     hdroi = dstHeight;      tmpSrc = src; for(int kloop=0;kloop<LOOP;kloop++)  {     tmpRef = dst ;     for (j = 0, jrow = idyt; j < hdroi; j++, jrow++) {         row = (jrow + 0.5) * yInv - 0.5;         rowInd = (int)floor(row);         ySrc0 = ts_iGetCoord_vs(rowInd, rowInd,  0, srcHeight, srcHeight);         ySrc1 = ts_iGetCoord_vs(rowInd, rowInd + 1, 0, srcHeight, srcHeight);         for (i = 0, icol = idxl; i < wdroi; i++, icol++) {              col = (icol + 0.5) * xInv - 0.5;             colInd = (int)floor(col);             xSrc0 = ts_iGetCoord_vs(colInd, colInd,   0, srcWidth, srcWidth);             xSrc1 = ts_iGetCoord_vs(colInd, colInd + 1, 0, srcWidth, srcWidth);             y1 = (double)tmpSrc[ySrc0 * srcStep + xSrc0];             y2 = (double)tmpSrc[ySrc0 * srcStep + xSrc1];             y3 = (double)tmpSrc[ySrc1 * srcStep + xSrc0];             y4 = (double)tmpSrc[ySrc1 * srcStep + xSrc1];    ts_iLinearCalcSP_vs(col + 0.5, colInd + 0.5, colInd + 1.5, y1, y2, &v1);            ts_iLinearCalcSP_vs(col + 0.5, colInd + 0.5, colInd + 1.5, y3, y4, &v2); ts_iLinearCalcSP_vs(row + 0.5, rowInd + 0.5, rowInd + 1.5, v1, v2, &v);               //(ts_isaturate_vs(v);             tempV = (int)(v + EXP + 0.5);             tmpRef[i] =(unsigned char)((tempV > 255) ? 255 : (tempV < 0) ? 0 : tempV);         }         tmpRef += dstStep;   }   }      stop_clock = RUNTIME;      int mhz;     ippGetCpuFreqMhz(&mhz);      return (stop_clock - start_clock)/mhz/LOOP; }

unsigned long IPP_Resize(void* src, int srcWidth, int srcHeight,int srcStep,  void* dst,  int dstWidth, int dstHeight, int dstStep,   double m_nzoom_x, double m_nzoom_y, int interpolation)   {       //   define record time variable     unsigned long start_clock,stop_clock;     start_clock= RUNTIME;  // define IPP function parameter      IppiRect srcRoi = {0,0, srcWidth, srcHeight};      IppiRect dstRoi={0,0, dstWidth,dstHeight};        IppiSize srcSize = {srcWidth, srcHeight};     IppiSize dstSize = {dstWidth, dstHeight};        int BufferSize;      ippiResizeGetBufSize(srcRoi, dstRoi, 1, interpolation, &BufferSize);      Ipp8u* pBuffer=ippsMalloc_8u(BufferSize);        for(int i=0;i<LOOP;i++)          //---------- Perform IPP function:ippiResizeSqrPixel_8u_C1R  -------------------------------------------//      ippiResizeSqrPixel_8u_C1R((Ipp8u*)src, srcSize, srcStep, srcRoi, (Ipp8u*)dst, dstStep, dstRoi, m_nzoom_x,m_nzoom_y,0, 0, interpolation, pBuffer);     ippsFree(pBuffer);     stop_clock = RUNTIME;       int mhz;     ippGetCpuFreqMhz(&mhz);      return (stop_clock - start_clock)/mhz/LOOP;

Performance Gain 

On one test machine (core 2 Quad 2.66GHz), as the result image show that the performance gain is 15654/353=44x.

The test is linking serial IPP static library.  As the ippiResize is threaded in dynamic library and threaded IPP static library. If enable the multithread, the performance gain will be more than 50x (depends on the core numbers and image size).

Conclusion
Intel® Parallel Studio 2011 provide developer a first suit of tool for easy developing parallel application on multi-core platform. IPP is part of key component of Intel® Parallel Studio. It provide over thousands highly-optimizated functions that offer the support for for developing high performance digital media application. This article describes a brief way to adopt IPP function instead of source code via Parallel Studio Project and gain over 40x performance speed up outright.  

Optimization Notice

Intel's compilers may or may not optimize to the same degree for non-Intel microprocessors for optimizations that are not unique to Intel microprocessors. These optimizations include SSE2, SSE3, and SSSE3 instruction sets and other optimizations. Intel does not guarantee the availability, functionality, or effectiveness of any optimization on microprocessors not manufactured by Intel. Microprocessor-dependent optimizations in this product are intended for use with Intel microprocessors. Certain optimizations not specific to Intel microarchitecture are reserved for Intel microprocessors. Please refer to the applicable product User and Reference Guides for more information regarding the specific instruction sets covered by this notice. Notice revision #20110804

Figure 1:  Convert to using Intel compiler project.


Running Guided Auto Parallel (GAP)
There are several ways to invoke Guided Auto Parallel (GAP) in the IDE, depending on whether you want analysis for the whole solution, the project, a single file, a function, or a range of lines source code. For the purpose of this tutorial, we will use single file analysis.

1) Select scalar_dep.cpp right click -> Intel C++ Composer XE -> Guide Auto Parallel -> Run Analysis on file “scalar_dep.cpp”
a. Click Run Analysis in the Configure Analysis dialog box.





Figure 2:  Run Guided Auto-Parallel Analysis





Figure 3:  Configuring Analysis


Viewing the results from Guided Auto Parallel (GAP)
The output generated by GAP analysis can be view in the standard Output Window of the IDE, or in the “Error List” window filtered by “Messages”.  Note that GAP message in the standard Output Window are encapsulated between “GAP REPORT LOG OPENED” and “END OF GAP REPORT LOG”.




Figure 4 GAP messages in IDE standard Output Window.





Figure 5 GAP message in Error List window filtered by Messages.


User can also redirect GAP output to a file. To output GAP messages to a file by check the box “Send remarks to a file”



Figure 6 Add option to output GAP messages to a file.

Note that GAP messages will not be available in the IDE standard Output Window or Error List Window if this option is enabled.

1>GAP REPORT LOG OPENED ON Tue May 18 11:42:58 2010
1>
1>C:\test\scalar_dep.cpp(49): remark #30521: (PAR) Loop at line 49 cannot be parallelized due to conditional assignment(s) into the following variable(s): b. This loop will be parallelized if the
variable(s) become unconditionally initialized at the top of every iteration. [VERIFY] Make sure that the value(s) of the variable(s) read in any iteration of the loop must have been written earlier in
the same iteration.
1>C:\test\scalar_dep.cpp(49): remark #30525: (PAR) If the trip count of the loop at line 49 is greater than 188, then use "#pragma loop count min(188)" to parallelize this loop. [VERIFY] Make
sure that the loop has a minimum of 188 iterations.
1>Number of advice-messages emitted for this compilation session: 2.
1>END OF GAP REPORT LOG

The remark #30521 indicates that loop at line 49 cannot parallelize because the variable b is conditionally assigned, and remark #30525 indicates that the loop trip count must be greater than 188 for the compiler to parallelize the loop.

The user needs to verify if the changes recommend by GAP are appropriate and do not change the semantics of the program.  Apply the necessary change(s) and re-compile the source file.  For this loop, we made the following changes to enable parallelization and vectorization of the loop as recommended by GAP:

#pragma loop count min (188)

for (i=0; i<n; i++) {
b = A[i];
if (A[i] > 0) {A[i] = 1 / A[i];}
if (A[i] > 1) {A[i] += b;} 
}

To verify that the loop was parallelize and vectorized:

1)   For the code that GAP provides a message(s), verify with the vectorizer report or parallel report after applying the change(s) provided by GAP.
2)   Add the option /Qvec-report1  /Qpar-report1 to the Additional Linker command line options dialog box.  (Note that in Visual Studio /GL is on by default which will enable /Qipo if you are using Intel compiler.  If /Qipo is not enable, the option should be added to the C/C++ Additional Options).
3)   Recompile without Guided Auto Parallel.




Figure 8 Add /Qvec-report1 /Qpar-report1 to get parallelization and vectorization reports.


The output window will report that a function call at line 23 in main.cpp was vectorized and parallelized.  The reason is because /Qipo (inlining across multiple file) was enabled, and the function with the loop in scalar_dep.cpp was inline at the call in main.cpp, resulting in the report that line 23 was vectorize and parallelize automatically by the compiler.

Conclusion
Adding parallelism to serial application can be difficult. Intel compiler with Guide Auto-Parallel feature provides a low cost and effective tool to add parallelism to your application.