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.



 

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

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.

Linux Distributions	IA-32	Intel® 64 (32- and 64-bit Applications)	Itanium®
Red Hat Enterprise Linux* 4.0
Red Hat Enterprise Linux* 5.0
Fedora* Core 10 †
Fedora* Core 11 †
CAOS* 1 †
CentOS* 5.3 †
SUSE* Linux Enterprise Server 10
SUSE* Linux Enterprise Server 11
openSuSE* Linux* 10.3 †
openSuSE* Linux* 11.1 †

Windows Versions	IA-32	Intel® 64 (32- and 64-bit Applications)	Itanium®
Microsoft* Windows XP* †
Microsoft* Windows XP Professional x64 Edition* †
Microsoft* Windows Server 2003* †
Microsoft* Windows Compute Cluster Server 2003*
Microsoft* Windows Vista* †
Microsoft* Windows* Server 2008 †
Microsoft* Windows* HPC Server 2008
Microsoft* Windows 7* †

† These distributions are supported by the Intel® MPI Library and the Intel® Trace Analyzer and Collector only.
No Intel® Cluster Toolkit and Intel® Cluster Toolkit Compiler Edition support at this time.

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.

The below instructions describe how to run Intel MPI Library jobs using Sun Grid Engine. This document relates to Linux*. While there are some differences and additional steps when using Microsoft* Windows*, in general the procedure is the same.

All optional steps are recommended but not necessary for successful integration.

1. [Optional] Visit sun.com and get a brief overview of SGE
2. Installation

   See the Installation Guide from sun.com for details. Roughly, the steps are as follows:

   • Install Master Host (see ‘How to Install the MasterHost’ section);
   • Install Execution Host (see ‘How to Install ExecutionHosts’ section);
   • Register Administration Hosts (see the corresponding section in the Installation Guide);
   • Register Submit Hosts (see corresponding section);
   • Verify the installation (see corresponding section).

   IMPORTANT NOTES:

   • To finalize the installation process, you’ll have to configure the network services manually (by modifying /etc/services), which requires root privileges.
   • It’s possible to install/run SGE as a non-privileged user, but
     1. there are some limitations in that case;
     2. you need root privileges for the complete installation process (at least, for modifying /etc/services).
3. Create a new Parallel Environment (PE) for Intel MPI Library
   
   1. Create the appropriate configuration file for the new PE. It should contain the following lines:

      pe_name	impi
      slots	999
      user_lists	NONE
      xuser_lists	NONE
      start_proc_args	NONE
      stop_proc_args	NONE
      allocation_rule	$round_robin
      control_slaves	FALSE
      job_is_first_task	FALSE
      urgency_slots	min

   2. Add the new PE using the following command:

      ‘qconf –Ap <config_file>’

   USEFUL COMMANDS:
   * qconf –spl – view all PEs currently available;
   * qconf –sp <PE_name> - view settings for a particular PE;
   * qconf –dp <PE_name> - remove a PE;
   * qconf –mp <PE_name> - modify an existing PE.

   Also see the ‘Managing Special Environment’ section in the Administration Guide from sun.com if you need more details about PE configuration.

4. Associate a queue with the new PE

   Use the following commands for that:

   1. qconf –sql – to see all queues available;
   2. qconf –mq <queue_name> - to modify the queue’s settings. Find the ‘pe_list’ property in the open window and add the ‘impi’ string to that property.

   USEFUL COMMANDS:
   * qconf –sq <queue_name> - view the queue’s settings.

   See the Administration Guide if you need more details about the queue configuration process.

5. Add Intel MPI Library environment to your current environment by sourcing the appropriate mpivars.[c]sh script located in the <install_dir>/bin[64] directory
6. Build the MPI application to be run
7. [Optional] Make sure that Intel MPI Library works fine on the desired hosts. For this, manually run your application on the desired hosts individually
8. Submit your MPI job to SGE

   Use the following command for that:

   qsub -N <job_name> -pe impi <num_of_processes> \
-V <mpirun_absolute_name> -r ssh -np <num_of_processes> <app_absolute_name>

   
   where
   -V option is used so that all environment variables available in the current shell are exported to a job.

    

   USEFUL COMMANDS to monitor and control jobs:
   * qstat – show status of SGE jobs and queues;
   * qstat –j – show detailed information about jobs (can be useful for pending jobs);
   * qdel – remove existing job.
   After submitting the job you can monitor its status using the qstat command. When the job is finished, you can find the job’s output and error output in your HOME directory – just look for <job_name>.o<jobID> and <job_name>.e<jobID> files.

   See the User’s Guide, if you need more information about the job submission process.

To use the Intel® MPI Library installation, make sure that:
lib -> ./itac/lib_impi3
slib -> ./itac/slib_impi3

To use the MPICH installation, make sure that:
lib -> ./itac/lib_mpich
slib -> ./itac/slib_mpich

IA-32 Architecture refers to systems based on 32-bit processors generally compatible with the Intel Pentium® II processor, (for example, Intel® Pentium® 4 processor or Intel® Xeon® processor), or processors from other manufacturers supporting the same instruction set, running a 32-bit operating system.

Intel® 64 Architecture (formerly Intel® EM64T)refers to systems based on IA-32 architecture processors which have 64-bit architectural extensions, (for example, Intel® Core™2 processor family), running a 64-bit operating system such as Microsoft Windows Vista* x64 or a Linux* "x86_64" variant. If the system is running a 32-bit  operating system, then IA-32 architecture applies instead. Systems based on AMD* processors running a 64-bit operating system are also supported by Intel compilers for Intel® 64 architecture applications.

64-bit computing on Intel architecture requires a computer system with a processor, chipset, BIOS, operating system, device drivers and applications enabled for Intel® 64 architecture. Performance will vary depending on your hardware and software configurations. Consult with your system vendor for more information.

IA-64 Architecture refers to systems based on the Intel® Itanium® processor running a 64-bit operating system.