Intel^® Integrated Performance Primitives (Intel^® IPP) v6.0 for Windows*
Getting Started Guide

Contents

Learning About the API
Environment Variables
Header Files
Calling Intel IPP functions
Using the Intel IPP DLLs and Dispatcher
Building a Custom DLL
Using the Intel IPP Static Libraries
Using the Intel IPP DLL-finding Static Libraries
Using the Intel IPP Performance Benchmark Tool

There are many ways to learn more about using Intelｮ Integrated Performance Primitives (Intelｮ IPP) and the functionality that it offers:

• Documentation including in this package - The file ipp_documentation.htm in the doc directory lists all available manuals, tutorial, and other documents provided in this Intel IPP package
• Intel IPP Website - http://www.intel.com/software/products/IPP contains releases information, evaluation release and support resource such as FAQs, technical support and online documentations, etc.
• Intel IPP Samples - There are extensive code samples that show implementation in source code of many functional areas that Intel IPP offers. They are downloadable at http://www.intel.com/software/products/IPP/samples.htm
• Manuals - Extensive API descriptions and several small code examples can be found in the manuals ippiman.pdf, ippsman.pdf, ippmman.pdf and ippcpman.pdf

• IA-32 Intelｮ Architecture: A batch file ippenv.bat
   
• Intelｮ 64 (Intelｮ EM64T) Architecture: A batch file ippenvem64t.bat
   
• Intelｮ Itaniumｮ Architecture: A batch file ippenv64.bat

The Intel IPP functions and structures are defined in several header files in the include directory. The file ipp.h includes all of these. For forward compatibility, include only ipp.h in your program.

Because of the DLL dispatcher and merged static library mechanisms described below, calling Intel IPP functions is as simple as calling any other C function. The multiple versions of optimized code for each function are concealed under a single entry point.

Refer to the manuals for descriptions of Intel IPP functions.

• IA-32 Intelｮ Architecture:
  
  The Intel IPP comes with "stub" static library files that load the Intel IPP DLLs and link to the correct entry points. In order to use the DLLs, link to the files ipp*.lib in the stublib directory. You will either need to set your lib environment variable using the ippenv.bat file or refer to these files using their full path. Including these libraries is all you need to do to dynamically link to the DLL for the appropriate processor.

The DLLs IPP*.dll are "dispatcher" DLLs. These DLLs are in the bin directory. At run time they will detect the processor and load the correct processor-specific DLLs. This allows your code to call Intel IPP functions without worrying about which processor the code will execute on - the appropriate version is automatically used. These processor-specific DLLs are named *px*.dll, *t7*.dll, *w7*.dll, *v8*.dll and  *p8*.dll . The only actions needed to use the Intel IPP DLLs, once the "stub" static libraries are linked, is to insure that the dispatching DLLs and the processor-specific DLLs are on the path.

Processor Codes

• px - C-optimized for all IA-32 processors
• w7 - Optimized for Pentium 4 processors
• t7 - Optimized for Pentium 4 processors with Streaming SIMD Extensions 3 (SSE3)
• v8 - New Optimizations for 32-bit applications on Intelｮ Core・2 and Intelｮ Xeonｮ 5100 Processors
• p8 - New Optimizations for 32-bit applications on 45nm Intelｮ Core・ Duo (Penryn) family processors and Intelｮ Core・ i7 processors
• s8 - New Optimizations for 32-bit applications on Intelｮ Atom・family processors

The Intel IPP comes with "stub" static library files that load the Intel IPP DLLs and link to the correct entry points. In order to use the DLLs, link to the files ipp*em64t.lib in the stublib directory. You will either need to set your lib environment variable using or according to the ippenvem64t.bat file, above; or refer to these files using their full path. Including these libraries is all you need to do to dynamically link to the DLL for the appropriate processor.

The DLLs ipp*em64t.dll are "dispatcher" DLLs. These DLLs are in the bin directory. At run time they will detect the processor and load the correct processor-specific DLLs. This allows your code to call Intelｮ IPP functions without worrying about which processor the code will execute on - the appropriate version is automatically used. These processor-specific DLLs are named *mx*.dll, *m7*.dll , *u8*.dll and *y8*.dll , they are located in the bin directory. The only actions needed to use the Intelｮ IPP DLLs, once the "stub" static libraries are linked, is to insure that the dispatching DLLs are on the path and the processor-specific DLLs are located in the same directory as the dispatching DLLs when your program is executed.

PLEASE NOTE: It is required that the appropriate libiomp5.dll is also included in your PATH environment variable. Include the directory bin when running on a system with Intel 64. There are known incompatibilities with other versions of libiomp5.dll. If you run in to problems, make sure that there are no other versions of libiomp5.dll on your PATH.

Processor Codes

• y8 - New Optimizations for 64-bit applications on 45nm Intelｮ Core・ Duo (Penryn) family processors and Intelｮ Core・ i7 processors
• u8 - New Optimizations for 64-bit applications on Intelｮ Core・2 and Intelｮ Xeonｮ 5100 Processors
• mx - C-optimized for all Intel 64-based Platforms
• m7 - Optimized for Intel 64-Based Platforms

• Intelｮ Itaniumｮ Architecture:

The Intel IPP comes with "stub" static library files that load the Intel IPP DLLs and link to the correct entry points. In order to use the DLLs, link to the files ipp*64.lib (for Itaniumｮ-based applications) in the stublib directory. You will either need to set your lib environment variable using the ippenv64.bat file or refer to these files using their full path. Including these libraries is all you need to do to dynamically link to the DLL for the appropriate processor.

The DLLs ipp*64.dll are "dispatcher" DLLs. These DLLs are in the bin directory. At run time they will detect the processor and load the correct processor-specific DLLs. This allows your code to call Intel IPP functions without worrying about which processor the code will execute on - the appropriate version is automatically used. The only actions needed to use the Intel IPP DLLs, once the "stub" static libraries are linked, is to insure that the dispatching DLLs and the processor-specific DLLs are on the path.

PLEASE NOTE: Starting with Intel IPP 4.0, it is required that the appropriate libguide40.dll is also included in your PATH environment variable. Include the directory bin when running on an Itaniumｮ architecture-based system. There are known incompatibilities with other versions of libguide40.dll. If you run in to problems, make sure that there are no other versions of libguide40.dll on your PATH.

Intel IPP 6.0 uses OpenMP* 2.0 to implement it's threading. To control the # of threads and thread behavior, use the OpenMP environment variables and API's. Some examples are OMP_NUM_THREADS, omp_set_num_threads(int num_threads), or OMP_SET_NESTED. The relevant OpenMP* function calls and environment variables are described in sections 3 and 4 of: http://www.openmp.org/drupal/mp-documents/cspec20.pdf  .

Processor Codes

• i7 - Optimized for Intel Itanium processor family

Building a Custom DLL

The Building Custom DLLs tool is used create a custom DLL that contains only the required Intel IPP functions needed by a given application. See the Intel IPP Linkage Samples for details. Currently it is available for IA-32 Intelｮ Architecture and Intelｮ 64 (Intelｮ EM64T) Architecture. You may check the customDLL sample located in directory ..\ipp-samples\advanced-usage\linkage\customdll after sample installation.

The Intel IPP also comes with "merged" static library files that contain every processor version of each function. Just as with the DLL dispatcher, the appropriate version of a function is executed when the function is called.  This mechanism is not as convenient as the DLL mechanism, but can result in a smaller total code size.

For example, for IA-32 Intelｮ Architecture, In order to use these static libraries, link to the files ipp*merged.lib in the lib directory. You will either need to set your lib environment variable using the ippenv.bat file or refer to these files using their full path.  See the Intel IPP Samples for details.

If you desire to link to a single processor specific static library only, please see the tool Using Intel IPP to create a Single Processor Application included in this package.

Overview

The DLL-finding libraries are dispatchers for the merged libraries described in the previous section. They provide a way of applying Intel IPP functions so that you do not need to create special definitions of the entry points for the Intel IPP functions you call as you would using the merged libraries. All that is required is to include the DLL-finding libraries into your project and call the Intel IPP functions from your source code.

Another feature of the DLL-finding libraries is that they allow automatic updating of a end-user application with new versions of Intel IPP functions. The dispatcher searches the PATH for the Intel IPP DLL dispatchers (ex. ipps.dll). If the dispatcher finds a newer version of the code in the Intel IPP DLL(s), the code from the newer DLL(s) is used in place of the code built-in to the application. So, there is no development needed to take advantage of the latest Intel IPP optimizations or new Intel processors!

There are some disadvantages in using the DLL-finding libraries as compared to the merged libraries. When using the DLL-finding libraries, it is not possible to exclude any cpu-specific code; all processor versions (IA-32 only) of each function will be linked into your application. Also, you cannot use the DLL-finding libraries in kernel mode.

Building Procedures

Follow the steps below to build your application using the Intel IPP DLL-finding libraries:

• IA-32 Intelｮ Architecture:
  • Include ipp.h, ippcorel.lib, and the appropriate ipp**emerged.lib file(s) to your project and build tree.
    • Note: You must link the IPPcore functions statically (using ippcorel.lib)
  • Make sure the appropriate ipp**merged.lib file(s) are in your build tree
  • Call ippStaticInit() before calling other Intel IPP functions
  • Call the Intel IPP functions required in your application source code 
     
• Intelｮ 64 (Intelｮ EM64T) Architecture
  • Include ipp.h, ippcoreem64tl.lib, and the appropriate ipp*emergedem64t.lib file(s) to your project and build tree.
    • Note: You must link the ippcore functions statically (using ippcoreem64tl.lib)
  • Make sure the appropriate ipp*mergedem64t.lib file(s) are in your build tree
  • Call ippStaticInit() before calling other Intel^ｮ IPP functions
  • Call the Intel IPP functions required in your application source code