If you have not yet installed a copy of the 7.0 Intel IPP library on your development system please read How to Install the Intel IPP 7.0 Library on Windows.

With release 7.0 of the Intel IPP library the location and layout of the Intel IPP library files on your development system were changed. Rather than being installed as a standalone product within the "\Program Files\Intel\IPP" directory, the Intel IPP library files are now installed as part of the Intel Composer XE product. This was done to provide closer integration with Microsoft Visual Studio, the Intel C/C++ Compiler and other Intel performance library products (such as Intel MKL and Intel TBB).

The following screen shots are the result of installing Intel IPP 7.0.4 on a Microsoft Windows 64 Server 2008 system that had a prior installation of Intel IPP version 7.0.3 already in place (or an Intel Composer XE, Intel Parallel Studio XE or any other Intel Tool Suite for Windows product that contains the Intel IPP library). The details may vary depending on the specific version of the 7.0 library product (either standalone or as part of a tool suite) you already have installed on your development system – these instructions assume a previous version of the Intel IPP 7.0 standalone library product has already been installed on the target system.

Note: if you have only pre-7.0 versions of the Intel IPP library installed on your system (e.g., version 6.1, 5.3, etc.) the following instructions do not apply; you can consider your initial installation of the 7.0 library to be a "clean install" of the Intel IPP library and should review How to Install the Intel IPP 7.0 Library on Windows.

Not every step in the process is shown below, only those steps that are considered of significance are provided.

Upgrade vs. Side-by-Side Installation

If you already have a 7.0 version of the Intel IPP library installed on your Windows development system, after you start the installer and answer any questions about extracting and licensing, you will see a dialog box similar to that shown below.

Choose the SECOND OPTION in the dialog box below (I want to install this update separate [sic] from the existing version).

If you choose the first option (I want to apply this update to the existing version) shown above you will upgrade your copy of the Intel IPP library. This means that the previous version of the library will be overwritten with the version you are now installing.

Choosing the second option (I want to install this update separate [sic] from the existing version) means you want to perform a side-by-side installation of the Intel IPP library. In other words, the existing copy of the Intel IPP library, that is already installed on your system, will remain in place and a second copy will be installed in a new location on your development system.

Obviously, you cannot build an application using both copies of the library at the same time, your build scripts (makefiles) and/or project files will need to be adjusted to specify which copy of the library you should be linking against ("default" or "side-by-side").

Complete the Side-by-Side Installation

Choose "Custom Installation" in order to see the screens that follow.

Notice the name of the directory into which the Intel IPP library components will be installed. In a "default" installation the .x.yyy part of the directory name (.4.196 in this example) would not be part of the directory name.

The convention followed by the installer and the Visual Studio integration tools is that the "unadorned" install directory (the directory with just "ComposerXE-2011" in the name) is the "default" installation directory. Files stored here are the "default" files and will be overwritten if an upgrade installation was chosen.

Any directory that includes a name that has been "adorned" by version-specific details (such as "ComposerXE-2011.4.196" as shown below) is considered to be an optional "side-by-side" directory and will not be overwritten by any future upgrade installs.

Be sure the components you wish to install on your development system include a green '+' sign, as shown below.

The test system used to obtain these screen shots did not have Microsoft Visual Studio installed. That is why the Visual Studio integration steps are grayed out in the following dialog box.

On a Windows 64 system the Intel IPP library (and other Intel Composer XE components) will be installed in the "\Program Files (x86)\Intel\…" directory, regardless of whether you are installing the 32-bit or the 64-bit version of the Intel IPP library. On a 32-bit Windows system the installer will place files in the "\Program Files\Intel\…" directory.

Following a successful installation it is important to note that the Windows "Start Menu" does not contain an "Intel IPP Library" product shortcut. Instead, you will find Intel IPP product documentation and other shortcuts under the "Intel Parallel Studio XE 2011" program group, as indicated by the closing installation dialog box shown below (Intel IPP is a component of Intel Composer, which is a component of Intel Parallel Studio).

Using Windows File Explorer, you can see that the The Intel IPP 7.0 library "side-by-side" binaries are located within the "adorned" Intel Composer XE 2011 directory (see the image below). Notice that the original "default" installation is still present on the development system and is identified by the "unadorned" Intel Composer XE 2011 directory.

Unlike prior versions of the product, the Intel IPP library files are no longer located in a dedicated directory structure. This will impact how you specify your IPPROOT environment variable, if you use this mechanism to locate the library within your project files or build scripts, and where you will find any shared library components (such as the Intel OpenMP library files and the Intel Compiler C runtime library files) that your application might require.

What to do!?

The biggest problems, in this case, are modifications to the PATH environment variable. In particular, if you installed both the 32-bit and the 64-bit shared libraries (DLLs) that comprise the Intel IPP library, the Intel TBB library, the Intel MKL library and the Intel Compiler common library components you'll find both are now part of your PATH specification. In most cases you probably want to have just one architecture (32-bit or 64-bit) referenced in your default path.

Sometimes the PATH modifications result in such a long PATH variable definition that it causes strange behavior when you try to run the Intel® Parallel Studio XE "Command Prompt" scripts from the Windows start menu (or the Microsoft Visual Studio "Command Prompt" scripts). It isn't always obvious that you are having trouble with these, but you may experience incomplete system configuration after running these scripts.

Following is the net PATH that resulted from installing Intel® Composer XE update 2 on my system. From a DOS (cmd.exe) prompt I typed the command "path" and piped it through the old UNIX "tr" command to make it easier to read:

You can get a Windows version of the UNIX "tr" utility by installing the "GnuWin32 CoreUtils" on your system.

It's easy to see what the installation added to my system PATH variable, all those extra directories at the beginning. If you're like me, you may have several editions of the libraries installed on your system (I work with the Intel® IPP library, so I'll use it as an example) and I really don't want my PATH setup this way. Instead, I prefer to specify these variable using one of the "Command Prompt" scripts that are installed by Composer XE and/or Microsoft Visual Studio and then amend my build environment using the supplied ippvars.bat file supplied in the %ipproot%\bin directory. (See the getting started guide for more info.)

These extra directories are included in the PATH environment to make it easier to locate the library DLL files at run time. So they are convenient if you are building an application that will use the standard distribution DLL files. You can still have some default directories placed in your PATH, but I recommend they be defined in your user's PATH, not the system PATH. This way, they'll be defined at the end of the PATH environment and any scripts you run will normally override the defaults by inserting additional definitions at the front of the PATH.

So, find the "System Properties" page on your system (there are multiple ways to get there, precise instructions vary as a function of the version of Windows you are using) and click the "Environment Variables.." button at the bottom of that dialog box, as shown below on a Windows 7 system:

From here, find the system PATH environment variable and remove all those extra directories that were inserted at the beginning of your PATH, which is the PATH environment variable definition located in the lower scroll box labeled "System variables":

Put the ones you want to keep, as part of your default build environment, in the PATH environment variable defined in the upper scroll box, labeled "User variables for <%USERNAME%>" – as shown above. And only insert the ones you want to use as your default, for example, only the 32-bit or only the 64-bit defintions, not both. Then, when you save the changes and open a new DOS prompt (cmd.exe) you'll see something more like the following:

You may not see the changes in all application until you logout and log back into Windows.

The following instructions assume you have already configured your development system's environment to compile and link applications that will use the Intel IPP library. Please see the Intel® IPP 7.0 Library Getting Started guide For more information on setting up your environment. This KB article only applies to version 7.0 of the Intel IPP library.

Dynamic Linking

The default linkage model used by most of the Intel IPP samples is dynamic (aka linking with shared objects). Dynamic linking against the prebuilt Intel IPP dynamic libraries involves linking with a "stub library" (Windows) or directly with the shared library objects (Linux). The dynamic linking method described here is "implicit linking," meaning that the libraries will be automatically loaded by the operating system at application run-time. (Ignore these instructions if you intend to use "explicit dynamic linking, in which case you probably already know all this and don't need to be reading this article.)

When you link against dynamic libraries the linker's search for external Intel IPP function names (e.g., the names of the Intel IPP function you are calling from within your application) is satisfied without actually including the Intel IPP function code in your application. In this case, the functions you are calling reside within the dynamic link library (DLL) or shared object (SO) files that you must distribute along with your application executable(s).

You can build and distribute a custom shared library (built from the Intel IPP static libraries) or you can distribute the prebuilt shared libraries that are provided with the Intel IPP library. Custom shared libraries are generally much smaller than the prebuilt shared libraries, because you can limit the number of functions included in the shared library file to only those required by your application. If you distribute the standard prebuilt shared libraries you will be including many functions that your application will never use; doing this does not impact the functionality or performance of your application (ignoring memory and/or paging requirements for the larger dynamic library), but it may substantially increase the number and size of the files you distribute to your customer(s).

The instructions for dynamic linking that follow assume you will use the default prebuilt shared library files with your application.

Note: the prebuilt dynamic libraries are multi-threaded using the Intel OpenMP threading library. If this threading technique is incompatible with your application or runtime environment you should use the single-threaded static libraries. If your application requires a dynamic library, you can build a custom dynamic library from the single-threaded static libraries. Please read this Intel IPP FAQ regarding threading and the OpenMP library for more information.

Windows Dynamic Linking

With the release of Intel IPP 7.0 the method by which you specify linkage dependencies has been significantly simplified. All that is required is to include the ipp.h header file in your source files (only those source files that reference Intel IPP functions or data structures need to include the ipp.h header file) and then define a special preprocessor label that will automatically instruct the linker as to which library files need to be linked against your application. In summary:

#include "ipp.h"

goes in your source files that reference Intel IPP functions and data structures and:

/D_IPP_PARALLEL_DYNAMIC

needs to be part of your compiler command line.

This technique works with either the MIcrosoft* Visual Studio* compiler (including the Visual Studio Express compiler) or with the Intel compiler. If you inspect the Intel IPP header files you'll see how this works. It uses a special "#pragma comment( lib, "libfilename" )" feature of these compilers. More information regarding this special pragma can be found here: http://msdn.microsoft.com/en-us/library/7f0aews7(v=vs.71).aspx.

Linux Dynamic Linking

Unfortunately, dynamic linking on the Linux platform requires slightly more effort than the Windows solution shown above. You must determine the names of the libraries you need to link against and include them in your link list. This article, Selecting the Intel® Integrated Performance Primitives (Intel® IPP) libraries needed by your application, can help you identify which library files you depend upon, if you know which domains the functions you are using belong to.

Once you've assembled the list of libraries (or domains) specify the names of the library files that correspond to those names and include the core library at the end of that list. For example, assume your application requires functions from the audio coding and the signal processing domains. Your link list would look like this:

-lippac –lipps –lippcore

The ippcore library is normally located last in the link list. If you inspect the makefiles distributed with the Intel IPP samples you will typically find this list defined as follows:

IPPLIB = -lippac -lipps –lippcore

with subsequent references to the macro $(IPPLIB) within the makefile.

Note that the simplest way to determine which Intel IPP libraries your domain may be dependent upon is to inspect the #pragma definitions used in the include files to direct the Windows* linker (for example, the image compression domain – ippj.h – depends on the image processing and signal processing domains, as well as the core library). These pragma statements are included in the Linux* include files even though they are only used by the Windows* build environments. Not every function within a given domain is dependent upon the other domain libraries listed in the pragma lists!

Static Linking

Static linking requires that you choose between one of two static library solutions: the single-threaded or the multi-threaded static library. Which library you choose to link against depends upon the needs of your application and your runtime environment. If you choose the multi-threaded static library you should understand that you will also need to include the Intel OpenMP library with your application.

Working with static libraries is generally much simpler than dynamic libraries. When you link against an Intel IPP static library the function code is included as part of your application executable. So you only need to distribute your application executable(s) and, optionally, the Intel OpenMP dynamic library if you are using the multi-threaded static library.

Note that when using static linking only the code required by those functions that you call from within your application are included with your executable. In other words, if you call ten Intel IPP functions from within your application then only the code for those ten functions (and any additional functions those ten functions reference) will be included in the final executable. The entire Intel IPP library is not included with your application when you link statically, only those functions that your application requires.

Because the multi-threaded static libraries depend on the Intel OpenMP library, you will also have to link against that library. You can use either the dynamic edition of the Intel Intel OpenMP library or the static edition, regardless of the fact that you are linking against a static version of the Intel IPP library. Linking against the dynamic Intel OpenMP library is shown below, since this is the recommended solution. Likewise, linking statically against the Intel IPP library does not require that you also link statically against other system libraries, such as the C runtime library.

Keep in mind that when you link against the dynamic version of the Intel OpenMP library you will need to distribute that library file along with your executable to your customer(s). Linking statically with the Intel OpenMP library eliminates that requirement but presents the possibility of a resource conflict with other OpenMP libraries that may be used by other applications on the customer's runtime system.

Windows Static Linking

As above, the release of Intel IPP 7.0 simplifies the method by which you specify linkage dependencies on a Windows system. All that is required is to include the ipp.h header file in your source files and define the appropriate preprocessor label that specifies which static library option will be linked against your application. In summary:

#include "ipp.h"

goes in your source files that reference Intel IPP functions and data structures and either:

/D_IPP_PARALLEL_STATIC

or:

/D_IPP_SEQUENTIAL_STATIC

needs to be part of your compiler command line.

This technique works with either the MIcrosoft* Visual Studio* compiler (including the Visual Studio Express compiler) or with the Intel compiler. If you inspect the Intel IPP header files you'll see how it works. This technique uses a special "#pragma comment( lib, "libfilename" )" feature of these compilers. More information regarding this special pragma can be found here: http://msdn.microsoft.com/en-us/library/7f0aews7(v=vs.71).aspx.

The "_IPP_PARALLEL_STATIC" preprocessor label indicates that you want to use the multi-threaded static library. And using the "_IPP_SEQUENTIAL_STATIC" preprocessor label means that you wish to use the single-threaded static library.

Linux Static Linking

Static linking on the Linux platform requires slightly more effort than the Windows solution shown above but is simpler than the Linux dynamic linking solution. Unlike the Linux dynamic linking process, you do not need to determine the names of the libraries against which you need to link before including them in your link list. Instead, you can simply list all the Intel IPP static libraries in your link list and let the linker do the work for you.

If you want to use the multi-threaded libraries your link list macro definition in your makefile should look something like this:

IPPLIB = -lippac_t -lippdc_t -lippcc_t -lippcv_t -lippj_t -lippdi_t -lippch_t -lippm_t -lippr_t -lippsc_t -lippvm_t -lippvc_t -lippi_t -lipps_t -lippcore_t -liomp5 -lpthread

If you use the single-threaded libraries, your link list macro definition in your makefile should look something like this:

IPPLIB = -lippac_l -lippdc_l -lippcc_l -lippcv_l -lippj_l -lippdi_l -lippch_l -lippm_l -lippr_l -lippsc_l -lippvm_l -lippvc_l -lippi_l -lipps_l -lippcore_l

The ippcore library is always located last in the link list of Intel IPP library files, due to the default single-pass nature of the standard Linux linker. The lists shown above should take care of any inter-library dependencies. however, if you have interdependencies between libraries that cause link errors you may need to use the -( and -) options (or equivalent --start-group and --end-group options) around the list of libraries you are linking against to force the linker into multi-pass behavior, at the expense of slightly reduced linker performance. Or, you can repeat the name of a library on the link list to resolve circular dependencies, without resorting to the -( and -) options; by listing a library file a second time after the library or object code files that depends on that key library. The nm and/or ldd commands can be used to help determine external references and dependencies.

Additional Information

Using Intel® IPP Threaded Static Libraries
Building a Windows* Application Using Intel® IPP
Compiling and Linking with Microsoft* Visual C++* and Intel® C++ Compiler
Error LNK2001: Unresolved External Symbol _ipp*
How to Build an Intel IPP Application
Intel® IPP - Intel® IPP Linkage Models - Quick Reference Guide
Intel® IPP- Library Dependencies by Domain
Intel® IPP - Threading / OpenMP* FAQ

{
      Ipp32f tmpMinS,tmpMaxS;

      Ipp32f m_PeakAmpdB;

       ippsMinMax_32f(fileData, sizeSamples, &tmpMinS, &tmpMaxS);

      Ipp32f maxAbsSample = IPP_MAX(fabs(tmpMinS),fabs(tmpMaxS));

      if(maxAbsSample > 0) {

            m_PeakAmpdB = 20.f * log10(maxAbsSample / 32768.f);

      } else {

      m_PeakAmpdB = -91.f;

      }

}

In this code, Amp(dB) = 20 lg(S/N), where S- random signal, N - noise. If S=1 then Amp(dB) = 20 lg(1/N) = -91 – this is silence.

You can download and view a recording of the webinar as well as a PDF file of the slides.

20 sep 2011 – article update – the ZIP file has been updated to include a missing DLL and it also now contains both AWK and GAWK executables. If you already have the necessary UNIX utilities on your Windows system (e.g., Cygwin or MinGW) you may not need the contents of the ZIP file. In any case please download the "ipp-fn-survey.awk" script file, it is required regardless of the UNIX utilities you use to run the script! On Windows, this AWK script has only been verified against the old GnuWin32 utils provided here. The GnuWin32 utils distributed in the attached ZIP file can be found here: http://gnuwin32.sourceforge.net/packages.html.

In the interest of developing a list of "most frequently used" functions by customers of the Intel IPP library, we have created a simple AWK script that can be used on either a Windows or Linux system to extract the names of the Intel IPP functions used in your application, without having to reveal any of your application source.

The number of Intel IPP functions present in the library is quite large; as a result, optimizing the entire library for new SIMD architectures must be performed in phases. In general, we would like to optimize first those functions that are most popular and relevant to our customers, in order to insure that your applications receive the maximum benefit as new SIMD architectures and/or extensions to those architectures are introduced.

Attached to this KB article are two files:

• ipp-fn-survey.awk
• GnuWin32-utils.zip

The AWK script scans C/C++ source code to identify any function that conforms to the standard naming scheme used by the Intel IPP library. This AWK script is provided in source format, so you can inspect the script to determine exactly what it does.

In essence, this script:

1. removes /* */ and // style comments to avoid false detects within comments
2. removes " " string constants to avoid false detects within strings
3. searches for and lists the names of all Intel IPP "core" functions
4. searches for and lists the names of all Intel IPP "administrative" functions

The script is not perfect and may miss a few Intel IPP functions. Please see the comments inside the AWK script for more details on known or suspected issues.

If the source tree you scan includes the IPP header files (ippac.h, ippcc.h, ippch.h, etc.) be sure to exclude those files from the search; otherwise, you will include every IPP function listed in those headers, even if you are not using them in your source code.

Basic Operation on Windows:

To run this script on a Windows machine you will need a copy of the GnuWin32 GAWK application (or a compatible AWK). In order to build a concise and sorted list of the Intel IPP functions used within your application it is also helpful to utilize the UNIX-compatible find, sort and uniq functions. All of these functions are provided in the GnuWin32-utils.zip attachment to this KB article. With the GnuWin32 applications installed on your Windows system, use the following command line:

>find src_dir -regex ".+\.[ch]p*" -exec gawk -f ipp-fn-survey.awk {} ; | sort | uniq >ipp-survey.txt

where "src_dir" is the root of the directory you wish to scan source for names of IPP functions -- simplest way to do this is to copy the AWK file and the contents of the ZIP file (GnuWin32-utils-zip) to "src_dir" and type:

>find . -regex ".+\.[ch]p*" -exec gawk -f ipp-fn-survey.awk {} ; | sort | uniq >ipp-survey.txt

Note: on a Windows system "find" needs to be a UNIX compatible version of find, not the Microsoft find. To avoid name conflicts with the Microsoft find.exe you might need to rename the GnuWin32 "find.exe" file to "uxfind.exe" and then run the samples above by referencing "uxfind" rather than "find" at the beginning of each script execution command.

If you used the command line above, the results of the scan will be found in the file named "ipp-survey.txt" in the starting directory.

Basic Operation on Linux:

To run this script on a Linux machine you will need the standard Gnu AWK, find, sort, uniq and xargs utilities that are normally present on your Linux system. Use the following command line:

$find src_dir -iregex ".+\.[ch]p*" | xargs ./ipp-fn-survey.awk | sort | uniq >ipp-survey.txt

where "src_dir" is the root of the directory you wish to scan source for names of IPP functions -- simplest way to do this is to copy this AWK file to the "src_dir" and type:

$find . -regextype posix-awk -iregex ".+\.[ch]p*" | xargs ./ipp-fn-survey.awk | sort | uniq >ipp-survey.txt

Note: GAWK on some Linux systems may not honor IGNORECASE -- resulting in a few false finds. Also, make sure the "executable" bits are set properly on the AWK script.

If you used the command line above, the results of the scan will be found in the file named "ipp-survey.txt" in the starting directory.

On some Linux systems you may not have gawk but awk installed on your system. The first line of the ipp-fun-survey.awk file references /usr/bin/gawk as the script interpreter. If your system instead only contains /usr/bin/awk you need to change that first line. To determine which application is on your system type "which gawk" at a command prompt. If nothing is returned type "which awk" at the command line. If your system only contains awk, or the application is located someplace other than /usr/bin, you will have to edit the first line of the ipp-fn-survey.awk script.

Terms and Conditions

This script will not reveal any source code or parameter names, only the names of the IPP functions referenced in the source code that it scans.

Note that this script is being provided under the terms and conditions of the Intel IPP EULA. Please insure you agree to those terms before using the script to provide us with a list of the Intel IPP primitives you are using.

If you are able to run this script (or something similar) on your application source code and generate a list of IPP functions that you would like to share with us, please reply to this posting (using the private option, if you prefer) with some information about your company and your application, as well as the list of Intel IPP functions created by the script or an email address you may use to contact you directly. Your input is very valuable for the prioritization of future optimizations within the Intel IPP library.

Optimization Notice

The Intel® Integrated Performance Primitives (Intel® IPP) library contains functions that are more highly optimized for Intel microprocessors than for other microprocessors. While the functions in the Intel® IPP library offer optimizations for both Intel and Intel-compatible microprocessors, depending on your code and other factors, you will likely get extra performance on Intel microprocessors. While the paragraph above describes the basic optimization approach for the Intel® IPP library as a whole, the library may or may not be optimized to the same degree for non-Intel microprocessors for optimizations that are not unique to Intel microprocessors. These optimizations include Intel® Streaming SIMD Extensions 2 (Intel® SSE2), Intel® Streaming SIMD Extensions 3 (Intel® SSE3), and Supplemental Streaming SIMD Extensions 3 (Intel® 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. Intel recommends that you evaluate other library products to determine which best meets your requirements.

Step 2 . Link IPP library in your application
From the Menu >> project (or right-click the Project in Solution Explorer) select Intel Parallel Composer 2011 » Select Build Components, Check the box Use IPP. The setting will link IPP dynamic library atomatically.  If your application is build sucessfully, you can run the exe. 

Note
1. If you'd like link the IPP static library, please download and install IPP static library first.  See Download IPP Static Libraries for Intel Parallel Studio. 
2. If you'd like link the IPP library and set IPP library path manually,  you may follow the steps on Compiling and Linking Intel® IPP with latest Intel® C++ Compilers
3. If you run into any IPP issues, please refer to the KB How to Build an Intel IPP Application => Troubleshooting - Compile and Linking Errors or report your issue to IPP forum.