Intel® IPP - Intel® IPP linkage models - quick reference guide

Contents of quick reference guide


Intel® Integrated Performance Primitives (Intel® IPP) is distributed as:

  • Static library: static linking results in a standalone executable
  • Dynamic library: dynamic linking defers function resolution until run-time and requires that you bundle the redistributable libraries with your application

The following table provides description of libraries available for linking:

Library types Description Folder location Example


Static linking results in a standalone executable.
Contains processor dispatchers and implementation for all functions. No internal threading

<ipp directory>\lib\<arch>



Dynamic linking defers function resolution until runtime. 
Include both processor dispatchers and function implementations.
Include import library and dynamic library, no internal threading.

<ipp directory>\lib\<arch>(import)
Multi-threaded  Deprecated,  include both static and dynamic library, Keep in current version for legacy applications. It is strongly recommended to use single-threaded version. <ipp directory>\lib\<arch>\threaded(import)

* The multi-threaded libraries are deprecated and moving to external threading is recommended. User has the option to use different threading models like Intel® TBB, OpenMP and Intel® Cilk Plus etc. You could learn more from following articles for using threading IPP:
Threading Your Application
​OpenMP* and the Intel® IPP Library
Threading Intel® Integrated Performance Primitives Image Resize with Intel® Threading Building Blocks
Appendix B: Intel® IPP Threading and OpenMP* Support
Please also view Finding Intel® IPP on Your System to see the folder location for IPP in different operating system.

These libraries offer various linkage models for different needs. The following are the four linkage models supported by the Intel® IPP:

  • Dynamic linkage
  • Static linkage
  • Custom dynamic linkage
  • Single processor static linkage

Steps to quickly demonstrate each linkage model are listed below. This code is used to illustrate the different linkage models:

#include "ipp.h" 
int main( ) 
const int SIZE = 256; 
Ipp8u pSrc[SIZE],pDst[SIZE]; 
int i; 
for (i=0; i<SIZE; i++) 
pSrc[i] = (Ipp8u)i; 
ippsCopy_8u(pSrc, pDst, SIZE); 
return 0; 

Dynamic linkage

  1. Include "ipp.h" which contains Intel IPP header files with the exception of cryptography and generated functions in your code;
  2. Use the normal IPP function names when calling IPP functions;
  3. Link corresponding domain import libraries. For example, if you use the ippsCopy_8u function, link against "ipps.lib" from directory ipp\lib\<arch>.
  4. Make sure that run-time libraries, for example ipps*.dll, are on the executable search path at run time. Run the ippvars.bat [ia32|intel64] from directory \ipp\bin to ensure this application built with the Intel IPP dynamic libraries will load the appropriate processor-specific DLL.

Static Linkage

  1. Include "ipp.h" which contains Intel IPP header files with the exception of cryptography and generated functions in your code;
  2. Use the normal IPP function names to call IPP functions;
  3. Link corresponding static libraries. For example, if the function ippsCopy_8u() is used, the linked libraries are ippsmt.lib, ippcoremt.lib.

* This dispatcher automatically executes the optimal version of each IPP function at run time, thus it is inherent part of dynamic library. Since Intel IPP 9.0, there is no requirement to initialize the dispatcher by calling ippInit() for static linkage anymore. for ippInit() function, please view IPP Dispatcher Control Functions to get more information.

Custom dynamic linkage

  1. Copy the function names of all Intel® IPP functions used from the Intel® IPP files into the file export.def. For our code example the content of this file is:
  2. Write a DLL initialization function called DllMain in mydll.c, and call the function ippInit inside of DllMain to initialize the dispatching mechanism
  3. Compile mydll.c as a dynamic link library and link it against ippsmt.lib  and ippcoremt.lib . The import library mydll.lib will be generated automatically.
//=========== mydll.c====================== 

#define WIN32_LEAN_AND_MEAN 
#include <windows.h> 
#include <ipp.h> 

DWORD fdwReason, LPVOID lpvReserved) 
switch( fdwReason ) 
return TRUE; 

Moreover, Intel® IPP provide a Building Custom DLLs tool to create a custom DLL in early version. It is available in legacy sample
<ipp directory>\examples\components_and_examples_win_ps\components\examples_core\ipp_custom_dll

Single Processor Static Linkage 

  1. Add the file ippsmt.lib to your project and its source tree.
  2. Include the header ipp_g9.h (In case of Processor with Intel® Advanced Vector Extension Instructions). before the other Intel IPP header files. Learn more about processor specific codes IPP uses, please view Dispatching.
  3. Add the file ippcoremt.lib to your project and its source tree;
  4. Include Intel IPP head file as normal;
  5. Call Intel IPP functions normally from your application.

* See Understanding CPU Dispatching in the Intel® IPP Libraries for more information about dispatching.
Also see Static linking to Intel® IPP Functions for One Processor in

C:\Program Files(x86)\IntelSWTools\parallel_studio_xe_2017.0.024\compilers_and_libraries_2017\windows\ipp\tools\ia32\staticlib\readme.htm

Quick comparison of the four linkage models

Features Dynamic linkage Custom dynamic linkage Single processor static linkage Static linkage
Processor update Automatic Recompile and redistribute Release new processor-specific application Recompile and redistribute
Optimization All processors All processors One processors All processors
Build Link to dynamic libraries Build separate DLL Link to processor-specific libraries Link to static libraries 
Calling Regular names Regular names Regular names Regular names
Distribution Distribute Linked IPP dll Distribute custom DLLs No extra distribution No extra distribution
Total Binary Size Large Small Small Small
Executable Size Smallest Smallest Small Small
Kernel Mode No No Yes Yes
Multi-Threading Support Yes Yes No Yes, when linking with the threaded static libraries

Note: All Intel® Integrated Performance Primitives functions are thread-safe. They support multi-threading in both dynamic and static libraries and can be used in multi-threaded applications. However, if an application has its own threading model or if other threaded applications are expected to run at the same time on the system, it is strongly recommended to use non-threaded/single-threaded libraries. Since Intel® IPP 8.2, multi-threading (internal threading) libraries are deprecated due to issues with performance and interoperability with other threading models, but made available for legacy applications.

For more information about external threading, please refer following documents:

Appendix B: Intel® IPP Threading and OpenMP* Support
Intel® IPP - Threading / OpenMP* FAQ 
Threading Intel® Integrated Performance Primitives Image Resize with Intel® Threading Building Blocks

For more information about the above linkage models, please refer to the Intel® IPP User Guide under IPP install directory or on-line articles: 

Intel® IPP New User's Guide
Compiling and Linking Intel® Primitive Performance Libraries with Microsoft* Visual C++* and Intel® C++ Compiler
Intel® Integrated Performance Primitives Domain Details

Supported Operating System

Windows 7*, Windows 8*, Windows 8.1*, Windows 10*,Windows Embedded 7*, Windows Embedded 8*, Windows Server*; Red Hat* Enterprise Linux* 6 and 7, Fedora* 20, and 21, SUSE* Linux* Enterprise Server (SLES) 11 and 12, Ubuntu* 12.04, 13.04, and 14.04 LTS, Debian* 7.0, Wind River* Linux* 6, and 7, Yocto Project* 1.5, 1.6, and 1.7, Tizen* 2.0, Glibc version: 2.4 or higher; OS X* 10.10, 10.11, XCode 6.x, XCode 7.x, Android* 4.4, 5.0...

For more supported configurations and system requirement of Intel IPP, please view the Intel® Integrated Performance Primitives (Intel® IPP) 9.0 Release Notes

For more complete information about compiler optimizations, see our Optimization Notice.