Suppose, that you have installed Intel® Parallel Studio to <install_dir> of your computer. By default, <install_dir> is C:\Program Files (x86)\IntelSWTools directory.

First - the simplest - method is to start command-line window, using menu Start\All Programs\Intel Parallel Studio XE <yyyy>\Compiler and Performance Libraries\Command Prompt with Intel Compiler <vv>\Compiler <vv> for <cpu_arch> Visual Studio <vs_ver> environment.

Here

You will have command-line window with all required evironment prepared.

The second method is to use specialized script to setup environment for Intel® tools from existing command-line window. The script is <install_dir>\parallel_studio_xe\compilers_and_libraries_<yyyy>\windows\bin\compilervars.bat and has two arguments: requred CPU architecture ("ia32" or "intel64") and required Microsoft* Visual Studio* environment ("vs2012", "vs2013", "vs2013shell", or "vs2015").

For example,

The third method is to set separately environment variable for Intel IPP and, if you want, for Intel TBB. For that, two scripts are placed in Parallel Studio directory tree: <install_dir>\parallel_studio_xe_<yyyy>\compilers_and_libraries_<yyyy>\windows\ipp\bin\ippvars.bat and <install_dir>\parallel_studio_xe_<yyyy>\compilers_and_libraries_<yyyy>\windows\tbb\bin\tbbvars.bat.

The fourth method is to set IPPROOT and TBBROOT manually. The main idea is that

For example, to set Microsoft* Visual Studio* 2015 environment and Intel IPP example environment, you need to do

Start terminal window on Linux*. In this system Intel® Parallel Studio tools are installed by default to /opt/intel directory.

So, you can do any of the following steps.

This is to set up both Intel IPP and Intel TBB environment.

Or, you can set Intel IPP and Intel TBB separately

Or, you can export the required environment variables manually

Setting of environment on OS X* system is much the same as on Linux*. The only difference is that you need to use mac subdirectory instead of linux in the paths to environment scripts.

Go to main examples directory examples_core. Load Visual Studio* projects directly to Microsoft* Visual Studio* or build them from command-line:

The <configuration> can be

Go to main examples directory examples_core. Execute GNU* Make as

where ARCH and CONF are optional parameters.

ARCH=ia32 is set, if you want to build 32-bit example on a 64-bit operating system. For that, the Intel IPP environment must be set for 32-bit architecture as

or

and 32-bit GCC libraries must be installed on your system.

CONF=configuration is optional parameter to build release or debug version of example application with or without Intel TBB support. The possible configurations are

The optional parameter clean cleans up the working directory.

You can run make command either from top directory of Intel IPP examples components/examples_core or from example specific sub-directory, for example, components/examples_core/ipp_fft. In the first case all examples will be built, in the second - you will build only the specific example.

On OS X*, load XCode* project directly to XCode* or build it from command-line:

Execute <ISS install dir>\bin\compilervars.bat script for target architecture (ia32 or intel64) to obtain PATH variable update for Intel® C/C++ compiler and IPPROOT environment variable. Set the target environment according to required OS target and toolchain.

Basically, you need to set SYSROOT and GNU_PREFIX environment variables and to update PATH variable to be able to execute bimary tools from the selected toolchain.

Then, execute build script

For example, to build Intel IPP examples for Wind River* Linux* target OS you need to set the following environment variables in your command line window

Execute <ISS install dir>/bin/compilervars.sh script for target architecture (ia32 or intel64) to obtain PATH variable update for Intel® C/C++ compiler and IPPROOT environment variable. Set the target environment according to required OS target and toolchain.

Basically, you need to set SYSROOT and GNU_PREFIX environment variables and to update PATH variable to be able to execute bimary tools from the selected toolchain. For example, for standard installation of Yocto Project v.1.7 on Linux* these environment variables should be

For Wind River* Linux* OS the required environment variables are

Then, execute build script

The ipp_custom_dll example demonstrates how to build the Intel IPP custom dynamic library for an application on Windows* OS.

The ipp_custom_so example demonstrates how to build the Intel IPP custom shared library for an application on Linux* OS.

The ipp_custom_dylib example demonstrates how to build the Intel IPP custom dynamic library for an application on OS X*.

The core of ipp_resize_mt example is CTBBResize class declared as

Actually, this class does nothing, but provides operator() functionality using the blocked_range2d Intel TBB class argument. The operator() function determines the boundaries of image tile assigned to a particual instance of an object, such as r.cols().begin(), r.rows().end(), etc, and call Resize function of CTBBResize::m_pResizer data member. CTBBResize is designed as much simple as possible to hide all Intel IPP specifics in the CResizer class.

CResizer is an auxiliary class declared as

Prior to actual work, you need to initialize the CResizer object by calling the CResizer::Init function. Within Init function the ippiResize context structure (IppiResizeSpec_32f *CResize::m_pSpec) is allocated and initialized. This structure is used further in CResizer::Resize function. The space allocation is done with respect to image size and resizing algorithm.

The command line options for ipp_resize_mt are:

Currently ipp_resize_mt example works only with bitmap (BMP) files.

The options are as follows:

The output messages during example execution show the number of resizing threads used, source and destination image resolutions, the number of loops executed, and execution time in seconds and CPE (CPU clocks per image element) like in the example below:

The example contains 3 classes - FFT, DFT and DCT - inherited from the base class Transform. Each class implements its own, specific Init, Forward, and Inverse methods with corresponding functionalities.

Additionally, the ipp_fft example has source code for performance mesurement and performance statistics output.

To display help for the ipp_fft command line options, call the example with "-h" option.

All command line switches except source image file name are optional.

The options are as follows:

In general, the ipp_thread example consists of main function and three processing functions - HarmonizeSerial, HarmonizeNativeParallel, and HarmonizeTBBParallel.

Before the source image gets to filtering, the source data is copied into a bigger image to set up border around source image data (necessary for ippiFilterBox_8u_C1R function).

Command line options can be obtained by "-h" option as follows:

The options are as follows:

The process of building Intel® MIC Architecture application is similar to building ordinary Intel® IPP-based applications. The differences are in additional compiler options ("-mmic" for Linux* OS and "-Qmic" for Windows*) and in Intel IPP libraries used during linking phase.

In Intel® C++ Compiler the required directories with Intel® MIC Architecture-specific libraries are included automatically with Intel® MIC-specific compiler options. For example, suppose that we have the test.c C-source code file with Intel IPP functions calls. With "-mmic" and "-ipp=common" options the final Linux* compiler options are:

Here,

The linker options correspond to x86_64-k1om-linux-ld cross-linker, one of the Intel® MPSS cross-compilation tools. Your Intel® Parallel Studio XE Composer Edition install directory may differ from the one mentioned in the example above.

There is another Intel® MIC Architecture programming technique based on Intel® C/C++ Compiler offload feature (see Intel® Many Integrated Core Architecture (Intel® MIC Architecture) chapter).

From the user point of view, the offload compilation and execution means that you can declare a part of your application as offload, i.e. oriented for execution off the central CPU, build the corresponding application and start it for execution on computer "host" system.

The offload run-time system and compiler pragma provide automatic methods to transfer Intel® MIC Architecture-targeted executable parts of binary code and related data to/from Intel® Xeon Phi™ coprocessor. Basically, you only need to specify which parts of your application (including data) are targeted for Intel® Xeon Phi™.

In practice, however, it is more complicated. The main problem is that offload data transferring interface is intended for simple, ordinal objects (scalar ordinal variables, plain arrays and so on). This means that the variables used to transfer data between host CPU (memory) and Intel® Xeon Phi™ should be simple, countable, understandable for compiler and bitwise-copyable (i.e. should be treated equally on both sides of CPU-Intel® Xeon Phi™ interconnection).

This means that in general you cannot have, for example, C++ class in which the part of function/data members are offload and the rest of class is not.

Currently, the above class is impossible in offload environment because you cannot describe the necessary data transfers in terms of compiler "#pragma offload" clauses. If you want to have C++ classes in offload application, you need to place the corresponding objects either on host (CPU) side of application or on Intel® Xeon Phi™ side.

To adjust the example provided in External Threading Example (ipp_thread) for use in offload mode, complete the following steps:

Remember that offload compiler performs two source file compilation passes:

In our example we are going to have all Intel IPP functions and data on Intel® Xeon Phi™ side, so we need to declare Intel IPP specifics as offload. It can be done in the following way:

Then, we want to put the example classes Harmonize and HarmonizeVM to Intel® Xeon Phi™ side by

These classes should not be visible from host side of application, otherwise you can face problems with offload compiler behavior.

If so, we need to move

variable from main() local storage to static variable space of coprocessor.

Then we will need the functions to:

All these functions have simple C-like parameters like ordinal variables and plain arrays.

To build the Intel® MIC Architecture example, you need to execute build script as described in Build Procedure chapter with the following specifics.

To execute the example, place a source bitmap file in the directory where ipp_thread_mic resides and execute the command specified in Command Line Options. The following has been changed in the command-line options:

The default number of threads on Intel® Xeon Phi™ is 32.