• 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/

SciPy include modules for statistics, optimization, integration, linear algebra, Fourier transforms, signal and image processing, ODE solvers, and more.  The SciPy library depends on NumPy, which provides convenient and fast N-dimensional array manipulation. The SciPy library is built to work with NumPy arrays, and provides many user-friendly and efficient numerical routines such as routines for numerical integration and optimization for python users. Please refer http://www.scipy.org for more details on SciPy.



Version Information

This application note was created to help NumPy/SciPy 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 and SciPy Source Code

The NumPy source code can be downloaded from:

http://www.scipy.org/Download

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 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.

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

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

And to extract SciPy, use the below commands

$gunzip scipy-x.x.x.tar.gz $tar -xvf scipy-x.x.x.tar.gz 

The scipy-x.x.x directory will be created with extracted files.

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 and Installing 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.

Modify the the Fortran compiler configuration in numpy-x.x.x/numpy/distutil/fcompiler/intel.py to use the following compiler options for the Intel Fortran Compiler:

For ia32 and Intel64

ifort -xhost -openmp -fp-model strict -fPIC

If you are using ILP64 interface of Intel MKL, please add -i8 flag above.  Please download the modified intel.py for your reference, which can be replaced to use the above mentioned compiler options.

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 

Build and Install SciPy

Compile and install SciPy with the Intel Compilers: (On 64-bit platforms replace "intel" with "intelem")

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

Setup Library path for Intel MKL and Intel Compilers

If you build NumPY/SciPy 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 Intel MKL and Intel 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.

• calls to Intel® MKL occur in a single executable
• input and output arrays in function calls must be aligned on 16, 32, or 64 byte boundaries on systems with SSE / AVX1 / AVX2 instructions support (resp.)
• the number of computational threads used by the library remains constant throughout the run

It is well known that for general single and double precision IEEE floating-point numbers, the associative property does not always hold, meaning (a+b)+c may not equal a +(b+c).  Let's consider a specific example. In infinite precision arithmetic 2^-63 + 1  + -1 = 2^-63. If instead we do this same computation on a computer use double precision floating-point numbers, rounding error is introduced and we clearly see why order of operations becomes important:

(2^-63 + 1) + (-1) ≈ 1 + (-1) = 0

versus

2^-63 + (1 + (-1)) ≈ 2^-63 + 0 = 2^-63

This inconsistency in results due to order-of-operations is precisely what the new functions are designed to address.

The application related factors that affect the order of floating-point operations within a single executable program include code-path selection based on run-time processor dispatching, data array alignment, variation in number of threads, threaded algorithms and internal floating-point control settings. Most of these factors can be controlled by the user by properly controlling the number of threads, floating point settings and taking steps to align memory when it is allocated (see this previous article on getting reproducible results). On the other hand run-time dispatching and certain threaded algorithms have not allowed users to make changes that can ensure the same order of operations from run to run.

Intel MKL does run-time processor dispatching in order to identify the appropriate internal code paths to traverse for the Intel MKL functions called by the application. The code paths chosen may differ across a wide range of Intel processors and IA compatible processors and may provide differing levels of performance. For example, an Intel MKL function running on an Intel® Pentium® 4 processor may run an SSE2-based code path, while on a more recent Intel® Xeon® processor supporting Intel® Advanced Vector Extensions (AVX), that same library function may dispatch to a different code-path that uses these AVX instructions. This is because each unique code path has been optimized to match the features available on the underlying processor. The feature-based approach introduces a challenge: if any of the internal floating-point operations are done in a different order, or are re-associated, then the computed results may differ.

Dispatching optimized code-paths based on the capabilities of the processor on which it is running is central to the optimization approach used by Intel MKL so it is natural that there should be some performance trade-offs when requiring consistent results. If limited to a particular code-path, Intel MKL performance can in some circumstances degrade by more than half. This can be easily understood by noting that matrix-multiply performance nearly doubled with the introduction of new processors supporting AVX instructions. In other cases, performance may degrade by 10-20% if algorithms are restricted to maintain the order of operations.

Intel® MKL 11.0 includes new functions and environment variables, shown in figures 1, 2, and 3  designed to help users get bitwise reproducible results from the Intel MKL functions used.  To better understand how to use these features, some usage examples are provided below. Only the MKL_CBWR_AUTO and MKL_CBWR_COMPATIBLE options are supported on non-Intel CPUs.

To ensure MKL calls return the same results on all Intel or Intel compatible CPUs supporting SSE2 instructions or later make sure your application uses a fixed number of threads, in/output arrays in Intel MKL function calls are aligned properly, and

call mkl_cbwr_set(MKL_CBWR_COMPATIBLE)

or set the environment variable

MKL_CBWR_BRANCH = "COMPATIBLE"

Note: the special MKL_CBWR_COMPATIBLE option is provided because Intel and Intel compatible CPUs have approximation instructions (e.g., rcpps/rsqrtps) that may return different results. This option ensures that Intel MKL uses an SSE2 only code-path which does not use these instructions.

To ensure MKL calls return the same results on every Intel CPU that supports SSE2 instructions or later make sure your application uses a fixed number of threads, in/output arrays are aligned properly, and call

mkl_cbwr_set(MKL_CBWR_SSE2)

or set the environment variable

MKL_CBWR_BRANCH = "SSE2"

Note: on non-Intel CPUs the results may differ because the MKL_CBWR_COMPATIBLE is run instead.

To ensure MKL calls return the same results on every Intel CPU that supports SSE4.1 instructions or later make sure your application uses a fixed number of threads, in/output arrays are aligned properly, and call

mkl_cbwr_set(MKL_CBWR_SSE4_1)

or set the environment variable

MKL_CBWR_BRANCH = "SSE4_1"

Note: on non-Intel CPUs the results may differ because the MKL_CBWR_COMPATIBLE is run instead.

Ensure MKL calls return the same results on every Intel CPU that supports AVX instructions or later make sure your application uses a fixed number of threads, in/output arrays are aligned properly, and call

mkl_cbwr_set(MKL_CBWR_AVX)

or set the environment variable

MKL_CBWR_BRANCH = "AVX"

Note: on non-Intel CPUs the results may differ because the MKL_CBWR_COMPATIBLE code-path is run instead. On an  Intel CPU without AVX support, the MKL_CBWR_DEFAULT path is run instead.

Please consult the user guide for additional details.

Questions on the new releases, version numbers, and upgrade

Q: what's the latest mkl version? we have Intel compiler 11.1 which includes mkl. Does this mean the mkl version is 11.1?
A: The version of Intel MKL that is included in the Intel Compiler 11.1 is Intel MKL 10.2 (and updates of this compiler contain updates of Intel MKL). If you’d like to know which version of Intel MKL you’re using, you can check the mklsupport* file in the doc or Documentation directory. Another place to look is one of the following knowledgebase articles:

• Which version of Intel IPP, Intel MKL and Intel TBB is installed by the Intel® Compiler Professional Edition?
• Which version of the Intel® IPP, Intel® MKL and Intel® TBB Libraries are Included in the Intel® Composer Bundles?

Q: You mentioned that Intel Composer XE contains the C++ compiler. Why is there a separate C++ Composer XE product then?
A: There is an Intel® C++ Composer XE 2011 as well as an Intel® Fortran Composer XE 2011. These are available for those that need only one of the two compilers in Intel® Composer XE 2011. See the buy or renew products page for a full list.

Q: Intel® Parallel Studio XE 2011 - your first slide did not mention Mac OS* X. Why?
A: Intel® Parallel Studio XE 2011 is a suite of tools some of which are not available for Mac OS* X. The compiler and library support continues through the Intel® C++ Composer XE 2001 and Intel® Fortran Composer XE 2001 for Mac OS* X products. See: http://software.intel.com/en-us/articles/intel-sdp-products/.

Q: I recently purchased Intel Fortran Compiler 11.1, is the new Intel MKL 10.3 included as an upgrade?
A: Yes. Anyone with a current (unexpired) license for Intel MKL or professional editions of the Intel Compilers can obtain the new version of those tools (including Intel MKL 10.3).

Performance

Q: In which areas does ATLAS beat MKL?
A: We do regular performance benchmarking against ATLAS. We are not aware of places where ATLAS has better performance. If you know of any, please let us know.

Q: Is the hybrid improvement (MPI+OpenMP*) mainly for 3D FFTs?
A: Earlier we had implemented hybrid parallelism for 3D FFTs and now we have introduced it (MPI + OpenMP*) on cluster 1D complex transforms too. Most of the improvement is for vector lengths which are a multiple of the number of MPI processes

Q: Do you have a performance comparison with 64-bit GotoBLAS? I observed that GotoBLAS is faster in some case but a bit unstable.
A: No we don't have any performance comparisons.

Q: You talked about the MKL 10.3 performance on the new 6 core system. What about the performance on the existing Nehelem system?
A: You can find more performance information on the Intel MKL site under the 'resources' tab.

Q: I am testing PARDISO in my laptop and comparing with DSS sparse solver. They solve the matrix in the same amount of time. Am I doing something wrong?
A: This would be expected. DSS sits on top of Pardiso. The main value of DSS is that it provides a simplified interface.

Questions on Intel MKL features

Q: C interface to LAPACK - what kind of overhead with using it? I have been okay with the current usage, confusing but okay. Should I move over?
A: New kernels are steadily being introduced to eliminate the performance and memory overhead of transposition required for row-major data structures. Let us know if you have questions about a particular LAPACK function in a particular version of Intel MKL.

Q: Random number generator - should I expect to see differences in numbers generated (everything else constant including CPU) in a 32-bit build and a 64-bit build?
A: There are some cases where random generators differ between 32- and 64-bit builds due to different accuracy level of the VML functions used. More info to follow...

Q: Can you explain disadvantages of linking the OpenMP run-time library statically?
A: If your application or plug-in will be used in an environment where any other application or plug-in might also be threaded using OpenMP* then the OpenMP run-time may stall when it finds another statically linked run-time library already initialized.

Usage and tips

Q: Are there any common mistakes that new users make that frequently lead to undefined behaviour?
A: There are many ways that we see users make mistakes, but they are not so easy to enumerate. Here are some general categories that the problems can fall into: linking problems (use the link line advisor or user’s guide), improper data layout (e.g., for FFTs or PARDISO—see the reference manual), or simple API misunderstandings (see the reference manual)

Q: Is the icc -mkl=[parallel,sequential] link method recommended?
A: Yes! Take a look at the "Using MKL in Intel® Compiler - mkl, Qmkl options" article for more information.

Q: Is there some support for Eclipse IDE?
A: There is some integration of our documentation into the IDE as well as documentation in the product on how to setup Eclipse for use of Intel MKL. Take a look at “Programming with Intel® Math Kernel Library in the Eclipse* Integrated Development Environment (IDE)” section of the User's Guide for Linux*.

Plans for the future

Q: What new library functionality can users expect to appear in Intel MKL in coming years?
A: A package of Eigensolvers, a cluster version of PARDISO, extensions to VSL, etc.

Q: In the roadmap, do you have any implementations on GPU?
A: We have no current plans to extend GPU support.

#include <stdio.h>
#include “mkl_vsl.h”
 
int main()
{
   double r[1000]; /* buffer for random numbers */
   double s; /* average */
   VSLStreamStatePtr stream;
   int i, j;
    
   /* Initializing */        
   s = 0.0;
   vslNewStream( &stream, VSL_BRNG_SFMT19937, 777 );
    
   /* Generating */        
   for ( i=0; i<10; i++ );
   {
      vdRngGaussian( VSL_RNG_METHOD_GAUSSIAN_ICDF, stream, 1000, r, 5.0, 2.0 );
      for ( j=0; j<1000; j++ );
      {
         s += r[j];
      }
   }
   s /= 10000.0;
    
   /* Deleting the stream */        
   vslDeleteStream( &stream );
    
   /* Printing results */        
   printf( “Sample mean of normal distribution = %f\n”, s );
    
   return 0;
}

Users can turn ON or OFF this setting by using VML_FTZDAZ_ON / VML_FTZDAZ_OFF (default) in VML functions.

VML_FTZDAZ_ON mode improves performance of computations that involve denormalized numbers at the cost of reasonable accuracy loss.

Enabling this mode changes numerical behavior of the functions:  denormalized input values may be treated as zeros and denormalized results may flush to zero.  Accuracy loss may occur if input and/or output values are close to denormal range.

Usage example:

vmlSetMode( VML_LA | VML_FTZDAZ_ON);

vmdExp(1000, a, r, VML_LA | VML_FTZDAZ_ON);

Optimization Notice

Intel's compilers may or may not optimize to the same degree for non-Intel microprocessors for optimizations that are not unique to Intel microprocessors. These optimizations include SSE2, SSE3, and SSSE3 instruction sets and other optimizations. Intel does not guarantee the availability, functionality, or effectiveness of any optimization on microprocessors not manufactured by Intel. Microprocessor-dependent optimizations in this product are intended for use with Intel microprocessors. Certain optimizations not specific to Intel microarchitecture are reserved for Intel microprocessors. Please refer to the applicable product User and Reference Guides for more information regarding the specific instruction sets covered by this notice. Notice revision #20110804

]]> http://software.intel.com/en-us/articles/denormal-paths-speedup-in-vml-by-setting-ftzdaz-setting/ Sat, 06 Nov 2010 11:30:00 -0700 http://software.intel.com/en-us/articles/denormal-paths-speedup-in-vml-by-setting-ftzdaz-setting/#comments http://software.intel.com/en-us/articles/denormal-paths-speedup-in-vml-by-setting-ftzdaz-setting/ Intel® C++ Compiler for Linux* Knowledge Base Intel® C++ Compiler for Mac OS X* Knowledge Base Intel® C++ Compiler for Windows* Knowledge Base Intel® Fortran Compiler for Linux* Knowledge Base Intel® Fortran Compiler for Mac OS X* Knowledge Base Intel® Math Kernel Library Knowledge Base Intel® Visual Fortran Compiler for Windows* Knowledge Base
The special cases illustrating speed-ups can be achieved on Intel AVX-enabled processors running an Intel AVX-enabled operating systems over Intel® Xeon® Processor 6000 and 7000 Sequence (Server) in Intel MKL 10.3 are as following:

Intel AVX DGEMM (M, N, K=8Kx4Kx128) performs 1.8x over Intel® Xeon® Processor 6000 and 7000 Sequence (Server).

Intel AVX DGEMM/SGEMM achieves 88-90% machine peak.

The Intel AVX/NHM speedup is 1.8x for radix-2 1D cluster FFTs  with N=1024

The Intel® Optimized LINPACK benchmark, using Intel AVX optimizations, performs over 1.86x (or over 80% overall efficiency) on 4 cores with N=20000.

Optimization Notice

Intel's compilers may or may not optimize to the same degree for non-Intel microprocessors for optimizations that are not unique to Intel microprocessors. These optimizations include SSE2, SSE3, and SSSE3 instruction sets and other optimizations. Intel does not guarantee the availability, functionality, or effectiveness of any optimization on microprocessors not manufactured by Intel. Microprocessor-dependent optimizations in this product are intended for use with Intel microprocessors. Certain optimizations not specific to Intel microarchitecture are reserved for Intel microprocessors. Please refer to the applicable product User and Reference Guides for more information regarding the specific instruction sets covered by this notice. Notice revision #20110804

]]> http://software.intel.com/en-us/articles/intel-avx-optimization-in-intel-mkl-v103/ Wed, 03 Nov 2010 11:30:00 -0700 http://software.intel.com/en-us/articles/intel-avx-optimization-in-intel-mkl-v103/#comments http://software.intel.com/en-us/articles/intel-avx-optimization-in-intel-mkl-v103/ Intel® C++ Compiler for Linux* Knowledge Base Intel® C++ Compiler for Mac OS X* Knowledge Base Intel® C++ Compiler for Windows* Knowledge Base Intel® Cluster Toolkit for Linux* Knowledge Base Intel® Cluster Toolkit for Windows* Knowledge Base Intel® Fortran Compiler for Linux* Knowledge Base Intel® Fortran Compiler for Mac OS X* Knowledge Base Intel® Math Kernel Library Knowledge Base www.CompilerReimbursementProgram.com, for further information. ]]> http://software.intel.com/en-us/articles/information-about-the-ftc-decision-and-order-on-the-intel-compilers-reimbursement-fund/ Mon, 01 Nov 2010 00:00:00 -0700 http://software.intel.com/en-us/articles/information-about-the-ftc-decision-and-order-on-the-intel-compilers-reimbursement-fund/#comments http://software.intel.com/en-us/articles/information-about-the-ftc-decision-and-order-on-the-intel-compilers-reimbursement-fund/ Intel® C++ Compiler for Linux* Knowledge Base Intel® C++ Compiler for Mac OS X* Knowledge Base Intel® C++ Compiler for Windows* Knowledge Base Intel® Software Development Tool Suites for Intel® Atom™ Processor Knowledge Base Intel® Fortran Compiler for Linux* Knowledge Base Intel® Fortran Compiler for Mac OS X* Knowledge Base Intel® Integrated Performance Primitives Knowledge Base Intel® Math Kernel Library Knowledge Base Intel® Parallel Composer Knowledge Base Intel® Visual Fortran Compiler for Windows* Knowledge Base

Click here to register and download

Intel MKL 10.3 beta is available now, your feedback is critical to the success of our product. We are especially interested in your feedback on the key features listed below. We also encourage you to send us feedback about our beta programs, web site and support services.

New Key features:

•  Intel^® Advanced Vector Extensions (Intel AVX) optimization

Intel AVX is the next step in the evolution of Intel processors. Intel AVX optimization has been extended to more MKL functions to get better performance on future Intel architecture.

•  Summary Statistics library

An optimized parallel library that uses recent advances of statistics by providing modern algorithms that enhance accuracy and performance of statistical computations.

•  Extended MKL C language support

o    C interface to LAPACK
o    C style 0-based index arrays in PARDISO

•  Dynamic interface libraries for Windows

New dynamic interface libraries have been added for improved linkage from C# or Java on Windows.

• Routine Level mode controls in VML

Users can now control or set the accuracy for each function separately in VML with a new argument in each function

• New symmetric matrix-vector product BLAS routine in blocked storage

• Split Complex (real real) support for 2D/3D FFTs
• New fast basic random number generator SFMT19937
• New Routine for Linear Fraction Transformation of vectors

Directory Changes in the Intel® MKL 10.3 Beta
List of bugs fixed in this release


Registration and Download:

1.     Review the Intel^® MKL 10.3 Beta system requirements at the end of this document.

2.     Click here to begin the registration process.

3.     Provide a valid email address. Installation information will be sent to your email account.

4.     Click the Submit button to obtain a serial number and the URL to download the beta copy.

Additional Documents

Link to documents	Description
Installation Guide	This document explains how to install and configure for use the Intel® MKL 10.3 Beta product. Installation is a multi-step process. Please read this document in its entirety before beginning and follow the steps in sequence.
Getting Started Guide	To get started using the library and to find information on APIs and building an application with Intel® MKL.
Release Notes	This document provides system requirements, installation instructions, issues and limitations, and legal information.

Beta Support and feedback:

Submit problem reports, usage questions and general feedback to Intel MKL User Forum, this forum is exclusively to discuss Intel^® MKL related information with other developers and Intel engineers.

At the end of beta program a survey will be sent out to all participants. The survey will ask questions about your target platform, new feature usage, Intel MKL product quality and documentation.