Forthcoming Intel® MKL 11.0 (Expected date of release: Autumn 2012)

•  Intel® MKL 11.0 will have backward incompatibility with Intel® MKL 10.2 update 3

•  Open MP static library on Microsoft* Windows

•  GMP* Arithmetic functions

•  Intel® MKL Reference Manual will be removed from product package

•  Intel® Pentium III will no longer be supported

•  Red Hat* EL4 and PGI* Fortran 10.x support will be dropped

•  PGI* Fortran 77 support will be removed

• a powerful N-dimensional array object
• sophisticated (broadcasting) functions
• tools for integrating C/C++ and Fortran code
• useful linear algebra, Fourier transform, and random number capabilities.

Besides its obvious scientific uses, NumPy can also be used as an efficient multi-dimensional container of generic data.

For more information on NumPy, please visit http://NumPy.scipy.org/

Version Information

This application note was created to help NumPy users to make use of the latest versions of Intel MKL on Linux platforms.

The instructions given in this articles apply to Intel MKL 10.3 and above and Intel Compiler 11.0 and above.

 
Step 2 - Downloading NumPy Source Code

The NumPy source code can be downloaded from:

http://NumPy.scipy.org/

Prerequisites

Intel MKL can be obtained from the following options:

Download a FREE evaluation version of the Intel MKL product.
Download the FREE non-commercial* version of the Intel MKL product.

All of these can be obtained at: Intel® Math Kernel Library product web page.

Intel® MKL is also bundled with the following products

Intel® Parallel Studio XE 2011
Intel Parallel Composer XE 2011
Intel Cluster Studio 2011

Step 3 - Configuration

Use the following commands to extract the NumPy tar files from the downloaded NumPy-x.x.x.tar.gz.

1.	$gunzip numpy-x.x.x.tar.gz 
2.	$tar -xvf numpy-x.x.x.tar 

 
The above will create a directory named numpy-x.x.x

Make sure that C++ and FORTRAN compilers are installed and they are in PATH. Also set LD_LIBRARY_PATH to your compiler (C++ and FORTRAN), and MKL libraries.

Step 4 - Building NumPy

Change directory to numpy-x.x.x
Create a site.cfg from the existing one
 
Edit site.cfg as follows:

Add the following lines to site.cfg in your top level NumPy directory to use Intel® MKL, if you are building on Intel 64 platform:

[mkl]
library_dirs = /opt/intel/composer_xe_2011_sp1.6.233/mkl/lib/intel64
include_dirs = /opt/intel/composer_xe_2011.sp1.6.233/mkl/include
mkl_libs = mkl_rt
lapack_libs =

If you are building NumPy for 32 bit, please add as the following

[mkl]
library_dirs = /opt/intel/composer_xe_2011_sp1.6.233/mkl/lib/ia32
include_dirs = /opt/intel/composer_xe_2011_sp1.6.233/mkl/include
mkl_libs = mkl_rt
lapack_libs = 

Modify cc_exe in numpy/distutils/intelccompiler.py to be something like:

self.cc_exe = 'icc -O3 -g -fPIC -fp-model strict -fomit-frame-pointer -openmp -xhost'

Here we use, -O3, optimizations for speed and enables more aggressive loop transformations such as Fusion, Block-Unroll-and-Jam, and collapsing IF statements, -openmp for OpenMP threading and -xhost option tells the compiler to generate instructions for the highest instruction set available on the compilation host processor. If you are using the ILP64 interface, please add -DMKL_ILP64 compiler flag.

Run icc --help for more information on processor-specific options, and refer Intel Compiler documentation for more details on the various compiler flags.

Compile and install NumPy with the Intel compiler: (on 64-bit platforms replace "intel" with "intelem")

python setup.py config --compiler=intel build_clib --compiler=intel build_ext --compiler=intel install

If you build NumPY for Intel64 bit platforms:

$export LD_LIBRARY_PATH=/opt/intel/composer_xe_2011_sp1.6.233/mkl/lib/intel64:/opt/intel/composer_xe_2011_sp1.6.233/compiler/lib/intel64:$LD_LIBRARY_PATH

If you build NumPY for ia32 bit platforms:

$export LD_LIBRARY_PATH=/opt/intel/composer_xe_2011_sp1.6.233/mkl/lib/ia32:/opt/intel/composer_xe_2011_sp1.6.233/compiler/lib/ia32:$LD_LIBRARY_PATH

It is possible that LD_LIBRARY_PATH causes a problem, if you have installed MKL and Composer XE in other directories than the standard ones. The only solution I've found that always works is to build Python, NumPy and SciPy inside an environment where you've set the LD_RUN_PATH variable, e.g:

$export LD_RUN_PATH=~/opt/lib:~/intel/composer_xe_2011_sp1.6.233/compiler/lib:~/intel/composer_xe_2011_sp1.6.233/mkl/lib/ia32

Note: We recommend users to use arrays with 'C' ordering style which is row-major, which is default than Fortran Style which is column-major, and this is because NumPy uses CBLAS and also to get better performance.

Appendex A: Example:

Please see below an example Python script for matrix multiplication that you can use Numply installed with Intel MKL which has been provided for illustration purpose.

import numpy as np
import time

N = 6000
M = 10000

k_list = [64, 80, 96, 104, 112, 120, 128, 144, 160, 176, 192, 200, 208, 224, 240, 256, 384]

def get_gflops(M, N, K):
	return M*N*(2.0*K-1.0) / 1000**3

np.show_config()

for K in k_list:
	a = np.array(np.random.random((M, N)), dtype=np.double, order='C', copy=False)
	b = np.array(np.random.random((N, K)), dtype=np.double, order='C', copy=False)
	A = np.matrix(a, dtype=np.double, copy=False)
	B = np.matrix(b, dtype=np.double, copy=False)

	C = A*B

	start = time.time()

	C = A*B
	C = A*B
	C = A*B
	C = A*B
	C = A*B

	end = time.time()

	tm = (end-start) / 5.0

	print "{0:4}, {1:9.7}, {2:9.7}".format(K, tm, get_gflops(M, N, K) / tm)

Appendix B: Performance Comparison

Please click Examples.py to download the examples for LU, Cholesky and SVD.



 

Navigation:

Introduction:

Please see your ReleaseNotes document with your compiler to find the supported Linux distributions and versions.  These instructions are merely to help install the compiler, keep in mind that versions of this distribution NOT in the ReleaseNotes document are NOT tested nor supported.  You are on your own here.

Using Intel® Compilers under RHEL 6 by Ron W. Green.  For older RHEL distributions, skip below to information on those older distros.

In order to use Intel(R) Compilers (C++  or  Fortran) under RHEL 6, you will need the latest 12.0 version or 11.1 version of the Intel compiler(s) in products named "Intel Composer XE 2011", "Intel Parallel Studio XE 2011", "Intel C++ Studio XE 2011", or "Intel Compiler Professional version 11.1".   Do NOT try to install older Intel Compilers such as 11.0, 10.x, 9.x or 8.x under RHEL 6: they will not install easily and probably will not work - and they are NOT supported.  If you need an older Intel Compiler version, please read their ReleaseNotes and obtain an older, supported RHEL distribution.

Also, determine your needs and get the right installation tarball.  Most linux users are on 64bit systems with x86_64 versions of linux installed.  Do you need to create older 32bit applications?  If not, download the Intel 64 ONLY tarball, the *_intel64.tgz file.  Not only does this save download time, this will eliminate your need to install 32bit libraries on the development system.  If you have active support for your compiler, you can download the latest Intel compiler version from the Intel Registration Center at:

https://registrationcenter.intel.com

BEFORE YOU INSTALL the Intel(R) Compiler for Linux on your RHEL 6 installation you will need to disable SELinux OR set SELinux to "Permissive".  As root, edit /etc/sysconfig/selinux and either disable SELinux or set it "Permissive" - then reboot.

Hopefully, during the installation of the OS you selected a profile for a "Software Development" configuration.  This installs the proper gcc/g++/binutils and other necessary development packages.  If not, set it up as a development platform.  You will first need to install several packages that are prerequisites to preparing the system to serve as a development platform:

1. Check that GNU gcc and g++ are installed on the system. By default you can simply check by executing the
command:

gcc --version

If for some reason, you do not have gcc installed, then go ahead
and install gcc and g++ on your system. You can use the software package manager “yum” to do the install. Refer
to http://fedoraproject.org/wiki/Tools/yum to learn more on yum.

As root user, in a terminal window:
yum install gcc
yum install gcc-c++

If you want to link statically, that is with -static or -fast (which contains -static), you will need the static versions of glibc.  Keep in mind that static linking is being discouraged by the larger linux community.  You may, of course, use -static-intel to statically link the Intel libraries.  However, if you want to also statically link the system libraries in glibc you will need the static versions of glibc.

x86_64:
yum install glibc-static.x86_64

IA32 (only if you want to install the 32bit compiler):
yum install glibc-static.i686

(if yum cannot find the static 32bit versions of glibc-static you will need to find an rpm source.  Use rpmfind or some other web search to find an appropriate 32bit version of glibc-static that matches the 64bit version you installed above with yum).

4. Finally, there is an optional package to consider: The 11.x version of the Intel Compiler for Linux has a graphical
debugger, a new graphical interface for the IDB debugger. If you want to use this debugger, please make sure to
install the JAVA JRE version 1.5 or higher.

check that java JRE is installed:
java -version
or
java --version

(note: compilers older than 11.1.064 had issues finding installed java JREs.  Please upgrade to new compiler OR ignore the 'missing java' prerequisite check)

If java is missing, you may get the latest JRE from:

http://java.com/en/download/manual.jsp

For Intel Compiler Professional Edition v11.1 ONLY:

In addition to the above, if you have an older v11.1 version of the Intel Compilers for Linux, you need to do the following:

You will need to ensure that the 32-bit version of the standard C++ library, libstdc++.so.5 (typically found
in /usr/lib/ directory) is installed on the system. The Intel® C++ and Fortran compilers for Linux installation require
the linkage to the 32-bit version of libstdc++.so.5 library on all Linux distributions. Failure to do so will result in 
installation failure on library dependencies not met. For more details, refer to the article at:

If you have problem even after following this guide, DO NOT leave comments - instead, go to our User Forum and submit a problem report:  For Fortran, http://software.intel.com/en-us/forums/intel-fortran-compiler-for-linux-and-mac-os-x/ and for C++, http://software.intel.com/en-us/forums/intel-c-compiler/ .

Please follow the link, you can find the online documentations and C LAPACK examples.

For version 11.1, please see Intel Fortran Compiler 11.1 Release Notes

To get product updates, log in to the Intel® Software Development Products Registration Center.

For questions or technical support, visit Intel® Software Developer Support

Update 8 - December 2011
Intel® Fortran Composer XE 2011 for Linux*

• English

Intel® Fortran Composer XE 2011 for Mac OS X*

• English

Intel® Visual Fortran Composer XE 2011 for Windows*

• English

Update 7 - October 2011
Intel® Fortran Composer XE 2011 for Linux*

• English
• Japanese

Intel® Fortran Composer XE 2011 for Mac OS X*

• English

Intel® Visual Fortran Composer XE 2011 for Windows*

• English
• Japanese

Update 6 - September 2011
Intel® Fortran Composer XE 2011 for Linux*

• English

Intel® Fortran Composer XE 2011 for Mac OS X*

• English

Intel® Visual Fortran Composer XE 2011 for Windows*

• English

Update 5 - July 2011
Intel® Fortran Composer XE 2011 for Linux*

• English

Intel® Fortran Composer XE 2011 for Mac OS X*

• English

Intel® Visual Fortran Composer XE 2011 for Windows*

• English

Update 4 - May 2011
Intel® Fortran Composer XE 2011 for Linux*

• English

Intel® Fortran Composer XE 2011 for Mac OS X*

• English

Intel® Visual Fortran Composer XE 2011 for Windows*

• English

Update 3 - March 2011
Intel® Fortran Composer XE 2011 for Linux*

• English
• Japanese

Intel® Fortran Composer XE 2011 for Mac OS X*

• English

Intel® Visual Fortran Composer XE 2011 for Windows*

• English
• Japanese

Update 2 - January 2011
Intel ® Fortran Composer XE 2011 for Linux*

• English

Intel® Fortran Composer XE 2011 for Mac OS X*

• English

Intel® Visual Fortran Composer XE 2011 for Windows*

• English

Update 1 - December 2010
Intel® Fortran Composer XE 2011 for Linux*

• English
• Japanese

Intel® Fortran Composer XE 2011 for Mac OS X*

• English

Intel® Visual Fortran Composer XE 2011 for Windows*

• English
• Japanese

Initial Product Release - November 2010
Intel® Fortran Composer XE 2011 for Linux*

• English

Intel® Fortran Composer XE 2011 for Mac OS X*

• English

Intel® Visual Fortran Composer XE 2011 for Windows*

• English

The release of PARDISO 4.0.0 from the University of Basel is not backward compatible and thus introduces some incompatibilities with the implementation of PARDISO that is available with the Intel® Math Kernel Library. This article outlines those places where the two interfaces have diverged.

The names of routines have the following structure:
vsl[datatype]{Conv|Corr}<base name> for C-interface
The field [datatype] is optional. If present, the symbol specifies the type of the input and
output data and can be
s (for single precision real type),
d (for double precision real type),
c(for single precision complex type), or
z (for double precision complex type).

The current implementation provides:

· Fourier algorithms for one-dimensional single and double precision real and complex data
· Fourier algorithms for multi-dimensional single and double precision real and complex data
· Direct algorithms for one-dimensional single and double precision real and complex data
•  Direct algorithms for multi-dimensional single and double precision real and complex data

Sample Code

    printf("EXAMPLE executing a convolution task\n");
    rank = 1;
    mode = VSL_CONV_MODE_DIRECT;
    vslcConvNewTask(&task,mode,rank,&xshape,&yshape,&zshape);
    status = vslcConvExec(task,x,&xstride,y,&ystride,z,&zstride);

For simple sample c or fortran code, please see
${MKL Install Dir}\examples\vslc\source\vslcconvexec.c
${MKL Install Dir}\examples\vslf\source\vslcconvexec.f

Compatiblity with IBM* ESSL library
One-dimensional algorithms cover the following functions from the IBM* ESSL library:
SCONF, SCORF
SCOND, SCORD
SDCON, SDCOR
DDCON, DDCOR
SDDCON, SDDCOR.
Special wrappers are designed to simulate these ESSL functions. The wrappers are provided
as sample sources for FORTRAN and C. To reuse them, use the following directories:
${MKL install Dir}/examples/vslc/essl/vsl_wrappers
${MKL install Dir}/examples/vslf/essl/vsl_wrappers

Performance issue
One issue is reported in MKL forum Speed of vslsconv in 10.1. The speed of vslsconv for 1000x1000 and 10x10 is far slower than FFT evaluated.

MKL really seems to have problem with choosing the optimal algorithm in this situation. It erroneously favors the overlap-add method and ends up performing a series of small 2D FFTs.

This issue will be fixed in one of our future releases.

It is also the general rule that an executable or shared library built with one version of the Intel Fortran compiler can run on a system where shared libraries from a newer version have been installed.

While it is Intel's goal to maintain this "upwards compatibility", there are some cases where a recompile is required - usually due to an error in the earlier version.  This article lists and explains the known cross-version compatibility issues for the Intel Fortran compiler.

Note: Object code compiled with an Intel Fortran compiler version earlier than 8.0, or with any non-Intel Fortran compiler, cannot be mixed with code compiled with Intel Fortran 8.0 or later.

Version where behavior changed: 11.1
Operating System: Windows

In a mixed-version application, allocatable or pointer arrays that are allocated in code compiled by pre-11.1 compilers or by 11.1 and later compilers, must be deallocated in code compiled by the same version that allocated the array.  For example, consider the following main program:

program main
real(8), allocatable :: array(:)

interface
subroutine sub (a)
real(8), allocatable :: a(:)
end subroutine sub
end interface

allocate (array(100))

call sub(array)

print *, "Current size of array is ", SIZE(array)

deallocate (array)

end

and the following subroutine:

subroutine sub(a)
real(8), allocatable :: a(:)

if (allocated(a)) deallocate (a)

allocate (a(200))

a = 0

return

end subroutine sub

If the subroutine is compiled with version 11.0 and the main program is compiled with 11.1, when the program is run the result may be one of the following:

• An error message "Microsoft Visual C++ Debug Library - Debug Error! The block at [address] was allocated by aligned routines, use _aligned_free()"
  

• The application exits with no error message

• No error message is displayed, but the deallocate is ignored

The deallocate does not need to be explicit - it may be performed as part of an array assignment or an assignment of a derived type containing an allocatable array component.

The cause of the issue is a change in version 11.1 that causes all allocated memory to be aligned on 8-byte boundaries; this change is represented in the compiled object code and the alignment information is not attached to the allocated array. Different routines in the Microsoft C++ library are used to do aligned and unaligned allocates and frees and these cannot be mixed.  The explicit error message noted in the first bullet above is shown only when the application is linked with the "debug" libraries.

There is no known workaround for this issue other than recompiling the source so that the allocates and deallocates do not cross the 11.0-11.1 boundary.  This issue will be fixed in a future update to the Intel Fortran Compiler.