Getting Started with the Intel^® Math Kernel Library 8.1.1 for Linux*  

Document Number: 310704-001US

Contents

Overview
Before You Start
    High-Level Directory Structure
    Detailed Directory Structure
Configuring Intel® Math Kernel Library (Intel® MKL)
Linking Your Application with Intel MKL
Threading
Disclaimer and Legal Information

Overview

The guide is intended to help start using the Intel® Math Kernel Library (Intel® MKL) for Linux* by describing the necessary steps you need to perform after the installation of the product and providing a simple usage scenario. The procedures guide you through the steps of how to link your application to the library, how to configure the library, and other essential steps.

It is assumed that you use this document after the installation of Intel MKL is complete on your machine.

If you have not installed the product, use Intel MKL Installation Guide (file Install.txt) for assistance.

Before You Start

Once you complete the installation of Intel MKL, it is useful to perform a basic verification task that confirms proper installation and configuration of the library. 

1. Check that the directory you chose for installation has been created. The default installation directory is /opt/intel/mkl/8.1.1.
2. Update build scripts so that they point to the desired version of Intel MKL if you choose to keep multiple versions installed on your computer. Note that you can have several versions of Intel MKL installed on your computer, but you will be required to remove beta versions of this software.
3. Check that the following three files are placed in the tools/environment directory:
   mklvars32.sh
   mklvarsem64t.sh
   mklvars64.sh
   You can use these files to set environmental variables INCLUDE and LD_LIBRARY_PATH in the current user shell.

High-Level Directory Structure

Below is shown a high-level structure for Intel MKL after installation.

Detailed Directory Structure

Intel® MKL separates IA-32 versions of the library, Intel® Extended Memory 64 Technology (Intel® EM64T), and versions for Intel® Itanium® 2 processor:

• The IA-32 versions are located in the lib/32 directory.
• Intel® EM64T versions are located in the lib/em64t directory.
• Intel® Itanium® 2 processor versions are located in the lib/64 directory.

Intel® MKL consists of two parts:

• high level libraries (ScaLAPACK, LAPACK, sparse solver)
• processor-specific kernels in libmkl_ia32.a, libmkl_em64t.a, and libmkl_ipf.a.

The high level libraries are optimized without regard to the processor and can be used effectively on processors from Intel® Pentium® processor through Intel® Pentium® 4 processor. Processor-specific kernels containing BLAS, Sparse BLAS, cblas, GMP, FFTs, DFTs, VSL, VML, and interval arithmetic routines are optimized for each specific processor.

In addition, threading software is supplied as:

• separate library (libguide.a) for static linking (discouraged - please see "Using Intel® MKL Parallelism" section in the mkluse.htm document)
• dynamic link library (libguide.so) when linking dynamically to Intel® MKL (recommended - please see "Using Intel® MKL Parallelism" section in the mkluse.htm document).

The information below shows detailed directory structure of the library.

The following interface libraries and modules are generated additionally as a result of respective makefiles operation in interfaces folder:

Configuring Intel MKL

If you want to further customize some Intel MKL features, you may use the configuration file mkl.cfg which contains several variables that can be changed. For more information on using the configuration file, refer to Intel MKL Technical User Notes document.

Linking Your Application with Intel MKL

To link with Intel MKL libraries, follow this general form:

<files to link>
-L<MKL path>
[-lmkl_solver] [-lmkl_lapack95] [-lmkl_blas95]
{[-lmkl_lapack] -lmkl_{ia32, em64t, ipf},[-lmkl_lapack{32,64}] -lmkl, -lvml}
-lguide -lpthread

Note that
libmkl_solver.a contains the sparse solver functions,
libmkl_lapack.a, or libmkl_lapack32.so and lib_mkl_lapack64.so have the LAPACK functions.
libmkl_ia32.a, libmkl_em64t.a, and libmkl_ipf.a have the BLAS, Sparse BLAS, GMP, FFT/DFT, VML, VSL, and interval arithmetic functions for IA-32, Intel® EM64T, and Intel Itanium processors respectively.
libmkl_lapack95.a and libmkl_blas95.a contain LAPACK95 and BLAS95 interfaces respectively. They are not included into the original distribution and should be built before using the interface (see Note for usage of Fortran-95 interfaces and wrappers to LAPACK and BLAS after this section for details on building the libraries).

The libmkl.so file contains the dynamically loaded versions of these objects except for VML/VSL, which are contained in libvml.so.

In all cases, appropriate libraries will be loaded at runtime. Below are some specific examples for linking on IA-32 systems with Intel® compilers:

ifort myprog.f -L$MKLPATH -lmkl_lapack -lmkl_ia32 -lguide -lpthread
        static linking of user code myprog.f, LAPACK, and kernels. Processor dispatcher will call the appropriate kernel for the system at runtime.
ifort myprog.f -L$MKLPATH -lmkl_lapack95 -lmkl_lapack -lmkl_ia32 -lguide -lpthread
        static linking of user code myprog.f, Fortran-95 LAPACK interface, and kernels. Processor dispatcher will call the appropriate kernel for the system at runtime.
ifort myprog.f -L$MKLPATH -lmkl_blas95 -lmkl_lapack -lmkl_ia32 -lguide -lpthread
        static linking of user code myprog.f, Fortran-95 BLAS interface, and kernels. Processor dispatcher will call the appropriate kernel for the system at runtime.
icc myprog.c -L$MKLPATH -lmkl_ia32 -lguide -lpthread -lm
        static linking of user code myprog.c, BLAS, Sparse BLAS, GMP, VML/VSL, interval arithmetic, and FFT/DFT. Processor dispatcher will call the appropriate kernel for the system at runtime.
ifort myprog.f -L$MKLPATH -lmkl_solver -lmkl_lapack -lmkl_ia32 -lguide -lpthread
        static linking of user code myprog.f, the sparse solver, and possibly other routines within Intel MKL (including the kernels needed to support the sparse solver).
icc myprog.c -L$MKLPATH -lmkl -lguide -lpthread
        dynamic linking of user code myprog.c, the BLAS or FFTs within Intel MKL.

Note: If you link libguide statically (discouraged) and

• use the Intel compilers, then link in the libguide version that comes with the compiler, that is, use -openmp option.
• do not use the Intel compiler, then link in the libguide version that comes with Intel MKL.

If you use dynamic linking (libguide.so) of Intel MKL (recommended), make sure the LD_LIBRARY_PATH is defined so that exactly this version of libguide is found and used at runtime.

For more information on linking and running applications with Intel MKL, refer to Intel MKL Technical User Notes document (mkluse.htm).

Fortran-95 interfaces and wrappers are delivered as sources. The simplest way to use them is building corresponding libraries and linking them as user's libraries. To do this, the user is supposed to have administrator rights. Provided the product directory is open for writing, the procedure is simple: go to the respective directory mkl/8.1.1/interfaces/blas95 or mkl/8.1.1/interfaces/lapack95 and type one of the corresponding commands:

make PLAT=lnx32 lib       - for IA32
make PLAT=lnx32e lib     - for Intel® EM64T
make PLAT=lnx64 lib       - for Intel® Itanium® 2 processor platform.

As a result, the required library and a respective .mod file will be built and installed in the standard catalog of the release. The .mod files can also be obtained from files of interfaces ifort -c mkl_lapack.f90 or ifort -c mkl_blas.f90. These files are in the include directory.
If you do not have administrator rights, do the following:

1. copy the whole directory (mkl/8.1.1/interfaces/blas95 or mkl/8.1.1/interfaces/lapack95) into user defined directory <user_dir>
2. copy the corresponding file (mkl_blas.f90 or mkl_lapack.f90) from mkl/8.1.1/include into user defined directory <user_dir>/blas95 or <user_dir>/lapack95 respectively
3. run one of the above commands in <user_dir>/blas95 or <user_dir>/lapack95 with an additional variable, for instance:
   make PLAT=lnx32 INTERFACE=mkl_blas.f90 lib
make PLAT=lnx32 INTERFACE=mkl_lapack.f90 lib.

Now the required library and the .mod file will be built and installed in the <user_dir>/blas95 or <user_dir>/lapack95 directory respectively.

By default using ifort compiler is assumed. You may change it with an additional parameter of make FC=<compiler>, for instance:
make PLAT=lnx64 FC=<compiler> lib

An advanced user can use interfaces without building the libraries.

To delete library from the building directory, use the following commands:
make PLAT=lnx32 clean       - for IA32
make PLAT=lnx32e clean     - for Intel® EM64T
make PLAT=lnx64 clean       - for Intel® Itanium® 2 processor platform.

Threading

Intel® MKL is threaded in a number of places and uses OpenMP* threading software.

The OpenMP* software responds to the environmental variable OMP_NUM_THREADS which sets the number of threads to use. The number of threads can be set in the shell the program is running in.

If the variable OMP_NUM_THREADS is not set, Intel® MKL software will run on the number of threads equal to 1 (except for the sparse solver where the default number of threads is the number of processors in the system). It is recommended that you always set OMP_NUM_THREADS to the number of processors you wish to use in your application.

To change the number of threads, enter:

export OMP_NUM_THREADS=<number of threads to use>

in the command shell in which the program is going to run.

For more information on technical details of Intel MKL, see Intel MKL Technical User Notes (mkluse.htm) document.

Disclaimer and Legal Information

The information in this manual is subject to change without notice and Intel Corporation assumes no responsibility or liability for any errors or inaccuracies that may appear in this document or any software that may be provided in association with this document. This document and the software described in it are furnished under license and may only be used or copied in accordance with the terms of the license. No license, express or implied, by estoppel or otherwise, to any intellectual property rights is granted by this document. The information in this document is provided in connection with Intel products and should not be construed as a commitment by Intel Corporation.

EXCEPT AS PROVIDED IN INTEL'S TERMS AND CONDITIONS OF SALE FOR SUCH PRODUCTS, INTEL ASSUMES NO LIABILITY WHATSOEVER, AND INTEL DISCLAIMS ANY EXPRESS OR IMPLIED WARRANTY, RELATING TO SALE AND/OR USE OF INTEL PRODUCTS INCLUDING LIABILITY OR WARRANTIES RELATING TO FITNESS FOR A PARTICULAR PURPOSE, MERCHANTABILITY, OR INFRINGEMENT OF ANY PATENT, COPYRIGHT OR OTHER INTELLECTUAL PROPERTY RIGHT. Intel products are not intended for use in medical, life saving, life sustaining, critical control or safety systems, or in nuclear facility applications.

Designers must not rely on the absence or characteristics of any features or instructions marked "reserved" or "undefined." Intel reserves these for future definition and shall have no responsibility whatsoever for conflicts or incompatibilities arising from future changes to them.

The software described in this document may contain software defects which may cause the product to deviate from published specifications. Current characterized software defects are available on request.

Intel, the Intel logo, Intel SpeedStep, Intel NetBurst, Intel NetStructure, MMX, Intel386, Intel486, 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 © 2005-2006, Intel Corporation.