Intel® Integrated Performance Primitives (Intel® IPP) v6.1  for Linux* OS  
Getting Started Guide

Contents

Learning About the API
 Environment Variables
Header Files
Calling Intel IPP functions
Using the Intel IPP Shared Libraries and Dispatcher
Using the Intel IPP Static Libraries
 Using the Intel IPP Shared Object Finding Libraries
 Using the Intel IPP Performance Benchmark Tool

Learning About the API

There are many ways to learn more about using Intel IPP and the functionality that it offers:

Environment Variables

You will need to add the path to the shared library to the LD_LIBRARY_PATH variable (see below). You will also need to specify the location for the Intel® IPP include and lib files. Each package offers a shell script in the tools/env directory sets your lib, include, and path environment variables for Intel IPP

Header Files

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.

Calling IPP Functions

Because of the shared library 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.

Using the Intel® IPP Shared Libraries and Dispatchers

Before using the Intel IPP shared libraries, you should add a path to the libraries to the system variable LD_LIBRARY_PATH. For example, if the libraries are in the /opt/intel/ipp/6.1.x.xxx/ia32(em64t or itanium or lp32)/sharedlib folder, then the following command line should be entered:
  • IA-32 Intel® Architecture:

On a IA-32 based system:
export LD_LIBRARY_PATH=/opt/intel/ipp/6.1.x.xxx/ia32/sharedlib:$LD_LIBRARY_PATH

The shared libraries libipp*.so are "dispatcher" dynamic libraries. At run time they will detect the processor and load the correct processor-specific shared libraries. This allows your code to call Intel® IPP functions without worrying about which processor the code will execute on - the appropriate version is automatically loaded and used. These processor-specific libraries are named *px.so, *t7.so, *w7.so, *v8.so , *p8.so and *s8.so.  All of these libraries are in the sharedlib directory.

PLEASE NOTE: It is required that the appropriate libguide.so is also included in your PATH environment variable. Include the directory sharedlib when running on a IA-32 system. There are known incompatibilities with other versions of libguide.so. If you run in to problems, make sure that there are no other versions of libguide.so on your PATH.

Processor Codes

px - C-optimized for all IA-32 processors
w7 - Optimized for Pentium 4 processors with Streaming SIMD Extensions 2 (SSE2)
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™2 Duo (Penryn) family processors
s8 - New Optimizations for 32-bit applications on Intel® Atom™ family processors

  • Intel® 64 (Intel® EM64T):

    Before using the Intel IPP shared libraries, you should add a path to the libraries to the system variable LD_LIBRARY_PATH. For example, if the libraries are in the /opt/intel/ipp/6.1.x.xxx/em64t/sharedlib folder, then the following command line should be entered:
    On an Intel 64 Architecture based system:
    export LD_LIBRARY_PATH=/opt/intel/ipp/6.1.x.xxx/em64t/sharedlib:$LD_LIBRARY_PATH

    The shared libraries libipp*em64t.so are "dispatcher" dynamic libraries. At run time they will detect the processor and load the correct processor-specific shared libraries. This allows your code to call Intel® IPP functions without worrying about which processor the code will execute on - the appropriate version is automatically loaded and used. These processor-specific libraries are named *mx.so, *m7.so, *u8.so, *y8.so and *n8.so. All of these libraries are in the sharedlib directory.

    PLEASE NOTE: It is required that the appropriate libguide.so is also included in your PATH environment variable. Include the directory sharedlib when running on a IA-32 system. There are known incompatibilities with other versions of libguide.so. If you run in to problems, make sure that there are no other versions of libguide.so on your PATH.

    Processor Codes

    y8 - New Optimizations for 64-bit applications on 45nm Intel® Core™2 Duo (Penryn) family processors
    u8 - New Optimizations for 64-bit applications on Intel® Core™ 2 and Intel® Xeon® 5100 Processors
    mx - C-optimized for all Intel 64 Architecture based Platforms
    m7 - Optimized for Intel 64 Architecture based Platforms
    n8 - New Optimizations for 64-bit applications on Intel® Atom™ family processors
  • Intel® Itanium® Architecture:

    Before using the Intel IPP shared libraries, you should add a path to the libraries to the system variable LD_LIBRARY_PATH. For example, if the libraries are in the /opt/intel/ipp/6.1.x.xxx/itanium/sharedlib folder, then the following command line should be entered:

    On an Intel Itanium Architecture based system:
    export LD_LIBRARY_PATH=/opt/intel/ipp/6.1.x.xxx/itanium/sharedlib:$LD_LIBRARY_PATH

    The shared libraries libipp*64.so are "dispatcher" dynamic libraries. At run time they will detect the processor and load the correct processor-specific shared libraries. This allows your code to call Intel® IPP functions without worrying about which processor the code will execute on - the appropriate version is automatically loaded and used. These processor-specific libraries are named *i7.so.  All of these libraries are in the sharedlib directory.

    PLEASE NOTE: It is required that the appropriate libguide.so is also included in your PATH environment variable. Include the directory sharedlib when running on a IA-32 system. There are known incompatibilities with other versions of libguide.so. If you run in to problems, make sure that there are no other versions of libguide.so on your PATH.

    Processor Codes

    i7 - Optimized for Intel Itanium processor family
     

  • Intel® Atom™ Processor:

    Before using the Intel IPP shared libraries, you should add a path to the libraries to the system variable LD_LIBRARY_PATH. For example, if the libraries are in the /opt/intel/ipp/6.1.x.xxx/lp32/sharedlib folder, then the following command line should be entered:

    On a IA-32 based system:
    export LD_LIBRARY_PATH=/opt/intel/ipp/6.1.x.xxx/lp32/sharedlib:$LD_LIBRARY_PATH

    The shared libraries libipp*.so are "dispatcher" dynamic libraries. At run time they will detect the processor and load the correct processor-specific shared libraries. This allows your code to call Intel® IPP functions without worrying about which processor the code will execute on - the appropriate version is automatically loaded and used. These processor-specific libraries are named *px.so, *t7.so, *w7.so, *v8.so and *p8.so.  All of these libraries are in the sharedlib directory.

    PLEASE NOTE: It is required that the appropriate libguide.so is also included in your PATH environment variable. Include the directory sharedlib when running on a IA-32 system. There are known incompatibilities with other versions of libguide.so. If you run in to problems, make sure that there are no other versions of libguide.so on your PATH.

    Processor Codes

    px - C-optimized for all IA-32 processors
    s8 - New Optimizations for 32-bit applications on Intel® Atom™ family processors

Using the Intel IPP Static Libraries

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

In order to use these static libraries, link to the files libipp*merged.a in the lib directory. Then follow the directions in Intel IPP Linkage Samples and create the dispatching stubs for just the functions that you need.

If you desire to link to a single processor specific static library only, please check the Intel IPP Linkage Samples to find details.

IPP Shared Object Finding Libraries

Overview

The shared object 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 shared object finding libraries into your project and call the Intel IPP functions from your source code.

Another feature of the shared object 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 shared object dispatchers (ex. libipps.so). If the dispatcher finds a newer version of the code in the Intel IPP shared object(s), the code from the newer shared object(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 shared object finding libraries as compared to the merged libraries. When using the shared object 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 shared object finding libraries in kernel mode.

Building Procedures

Follow the steps below to build your application using the Intel IPP shared object finding libraries:

IA-32 and Intel® Atom Architectures:
  • Include ipp.h, libippcore.a, and the appropriate libipp**emerged.a file(s) to your project and build tree.
    • Note: You must link the ippcore functions statically (using libippcore.a)
  • Make sure the appropriate libipp**merged.a 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):
  • Include ipp.h, libippcoreem64t.a, and the appropriate libipp**emergedem64t.a file(s) to your project and build tree.
    • Note: You must link the ippcore functions statically (using libippcore.a)
  • Make sure the appropriate libipp**mergedem64t.a 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


Using the Intel IPP Performance Benchmark Tool

The Intel IPP Package provides a tool "perfsys" to test the performance of each Intel IPP function in the API. For more details on running the performance test tool, please check the readme.htm under directory .\tools\perfsys\.

Intel, the Intel logo, Intel SpeedStep, Intel NetBurst, Intel NetStructure, MMX, i386, i486, Intel386, Intel486, Intel740, IntelDX2, IntelDX4, IntelSX2,Celeron, Intel Centrino, Intel Xeon, Intel XScale, Itanium, Pentium, Pentium II Xeon, Pentium III Xeon, Pentium M, and VTune 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.
 
Copyright © 2002-2009 Intel Corporation.