Showing results for 
Search instead for 
Did you mean: 

Shipping our product with the IPP dlls

We are moving on shipping our product with IPP. It is my understanding that we need to ship all of the DLLs that come with IPP for all of the different CPU profiles.
Is there a way to override this behavior? We are trying to be space conscious, and all of those DLLs contribute to over 200 megs of space. Is there a way to just say use one profile of DLLs, regardless if it may not be the most optimized?
Thank you,
0 Kudos
2 Replies

Hi Eric,

Please check this article out.

Intel IPP linkage models - quick reference guide

Best regards,

Tamer Assad


Hello Eric,

As Tamer points out with the link he provided, you can build a custom DLL that contains only the functions you are using withing your apps, without having to give up the optimum performance for the target systems.

If you are only distributing a single application, you might also try using the static link option, which will automatically pull in only the functions your application requires and bind them directly into your exe file, further simplifying distribution of the library; just remember to include an ippInit() call at the beginning of your application to insure the dispatcher is initialized.

If you prefer to use the standard DLLs that are provided with the library, you need to first identify which DLLs are required for the given set of functions you are using; this will be the "ippcore" DLL plus the domain-specific library files you need. Precisely which list of domain-specific libraries you need to distribute depends upon the functions you have used. To get a first pass estimate look inside the include file for each domain you are using (the include files can be identified in the documentation for each function). Within the domain-specific include files you'll see any dependencies for the static libraries listed. For example, these pragmasfrom the ch domain:

#if !defined( _IPP_NO_DEFAULT_LIB )
#if defined( _IPP_PARALLEL_DYNAMIC )
#pragma comment( lib, "ippch" )
#pragma comment( lib, "ippcore" )
#elif defined( _IPP_PARALLEL_STATIC )
#pragma comment( lib, "ippch_t" )
#pragma comment( lib, "ipps_t" )
#pragma comment( lib, "ippcore_t" )
#elif defined( _IPP_SEQUENTIAL_STATIC )
#pragma comment( lib, "ippch_l" )
#pragma comment( lib, "ipps_l" )
#pragma comment( lib, "ippcore_l" )

The pragmas above indicate that if you are using the "ch" domain you may also need the "s" domain. Whether or not you actually need the "s" domain depends on the specific functions within the "ch" domain you are using.

If you want to whittle the list down further, you could limit the specific processor SIMD architectures you distribute. At minimum, you should include the SSE2 (for IA-32) or SSE3 (for Intel64). Thus on IA-32 you'd include the "w7" DLL file and for Intel64 you'd include the "m7" DLL files. You also need the generic file. Again, if you were using functions from the "ch" domain, and you are distributing only a 32-bit version, and you want to only distribute the minimum level of SIMD that is supported by the version 7.0 library, you'd probably need to provide at least these DLL files with your application:


It's a lot of work and you are compromising the performance of your app by using this approach. Even though you can redistribute those prebuilt DLL files, they reallywork better as a convenience to the developer than as a redistribution mechanism.Irecommend you build a custom DLL or link statically with the library, that way you will minimize the size of your distribution and maximimize the performance on all of your target processors.

In addition to the article Tamer pointed out, please see the following articles for more information: