1. Build a custom library: To interface with Intel MKL from Python we recommend you use the custom library builder in the tools/builder sub-directory of the Intel MKL package. The Intel® MKL User's Guide has documentation on this tool (docs online). Here briefly are the steps I took to do this:
   
   
   1. Set up your environment to use the desired version of Intel MKL:
      source /<MKLpath>/tools/environment/mklvarsem64t.sh
   2. Build the DLL:
      cd /<MKLpath>/tools/builder
make em64t name=~/libmkl4py export=cblas_list
   3. The library as built above will depend on the OpenMP* threading runtime library used by Intel MKL (libiomp5.so). You should make sure that both libraries, libmkl4py.so and libiomp5.so, are in a directory specified in the LD_LIBRARY_PATH environment variable.
2. Call Intel MKL in your Python script: The following is a simple script (also available here) that loads the shared library just created and calls the matrix function.
   

   from ctypes import *
   
   # Load the share library
   mkl = cdll.LoadLibrary("./libmkl4py.so")
   cblas_dgemm = mkl.cblas_dgemm
   
   def print_mat(mat, m, n):
     for i in xrange(0,m):
       print " ",
       for j in xrange(0,n):
         print mat[i*n+j],
       print 
   
   # Initialize scalar data
   Order = 101  # 101 for row-major, 102 for column major data structures
   TransA = 111 # 111 for no transpose, 112 for transpose, and 113 for conjugate transpose
   TransB = 111
   m = 2
   n = 4
   k = 3
   lda = k
   ldb = n
   ldc = n
   alpha = 1.0
   beta = -1.0
   
   # Create contiguous space for the double precision array
   amat = c_double * 6      
   bmat = c_double * 12
   cmat = c_double * 8
   
   # Initialize the data arrays
   a = amat(1,2,3, 4,5,6)
   b = bmat(0,1,0,1, 1,0,0,1, 1,0,1,0)
   c = cmat(5,1,3,3, 11,4,6,9)
   
   print "\nMatrix A ="
   print_mat(a,2,3) 
   print "\nMatrix B ="
   print_mat(b,3,4)
   print "\nMatrix C ="
   print_mat(c,2,4)
   
   print "\nCompute", alpha, "* A * B + ", beta, "* C"
   
   # Call Intel MKL by casting scalar parameters and passing arrays by reference
   cblas_dgemm( c_int(Order), c_int(TransA), c_int(TransB), \
                c_int(m), c_int(n), c_int(k), c_double(alpha), byref(a), c_int(lda), \
                byref(b), c_int(ldb), c_double(beta), byref(c), c_int(ldc))
   
   print_mat(c,2,4)
   print

3. A few notes:
   • Matrices in the BLAS and LAPACK parts of Intel MKL are stored in one dimensional arrays and integers are used to specify their geometry.
   • I've actually loaded here CBLAS interface to the general matrix multiply function which allows you to choose how the matrix is specified. In my script I've listed the matrix by rows (row-major ordering). If you do not use the cblas interface to the BLAS or if you use LAPACK you should keep in mind that these functions assume the Fortran method of listing matrices by columns (column-major ordering).

We extended the list of examples demonstrate how possible to call different ( not only widespread example like dgemm ) from the Python program:

See the list of 3 different examples attached:
dft.zip  - shows the Python program calls 1D DFTI API
spblas.zip - shows how to call  matrix-matrix multiplication routine for a sparse matrix stored in the block compressed format (BSR)
vsl.zip - shows how to call vdRngGaussian routine ( generates normally distributed random numbers)  from VSL domain.

Notes:
Each zip file contains  *.res and *_list files mean input file and file for custom library building correspondingly

Dear all,

In this note I would like to remove some confusion about FFT interfaces supported by Intel® MKL.

Firstly, some history. The library has been providing Discrete Fourier Transforms Interface (DFTI) since MKL 6.0 (2002). In 2005, Intel MKL 8.1 added open source FFTW2 and FFTW3 wrappers to support essential functionality of the widely known Fastest Fourier Transform in the West library. In order to use the wrappers one had to compile them by their favourite C compiler.

Starting with Intel MKL 10.2 (2009), in particular with the latest release of MKL 10.2 Update 2, the FFTW3 interface has been fully integrated in MKL, so that an application using FFTW3 can be linked directly to the Intel MKL. Thus, an application using FFT functionality of Intel MKL can use either DFTI or FFTW3 interface, without extra effort for building the wrappers.

You are encouraged to upgrade your copy of Intel MKL to the latest MKL release.

With Intel MKL 10.2 and later all you need to use FFT functionality, either via DFTI or FFTW3 interface, is to link with Intel MKL.

For advanced use however the FFTW2 and FFTW3 wrappers to Intel MKL are provided in open source. For example,

• The FFTW2 interface doesn't support single precision and double precision interface in separate name spaces, so one has to compile the FFTW2 wrappers for the particular case of use.
• The Fortran interface of FFTW3 in Intel MKL does not support GNU g77 name decoration scheme. In that case one can still use FFTW3 interface with Intel MKL by compiling FFTW3 wrappers specially for use with g77 compiler.
• The implementation of the FFTW2 and FFTW3 wrappers may serve an additional usage example of MKL DFTI.

More details on FFTW2 and FFTW3 interfaces to Intel MKL can be found in MKL Reference Manual, Appendix G.

Dummy library removed and recommended solution:
As the claim in Compatibility libraries (also known as dummy libraries) no more available,  since MKL 10.2, we remove the dummy libraries completely. You are strongly encouraged to link Intel MKL library with layered mode.  

Please refer to Intel® Math Kernel Library Link Line Advisor 

or the map table in For easily migrating from Intel® MKL 9.x to 10.x

For some users who may still want to use one library instead of the "complex" combination of layered libraries, you may create the "dummy" library manually.

Intel® MKL for Linux

For example, you had one library libmkl.so from earlier version which worked and you hope keep use the name in your link line or makefile, you can create a "dummy" library manually,

For example, you are using intel compiler, threading mode, lp64 interface, create the dummy library by command

$ vi libmkl.so

add the below text in the fake file

GROUP (-lmkl_intel_lp64 -lmkl_intel_thread -lmkl_core)

Keep it into the MKL library directory.

If you had used static library -lmkl_em64t,    

   $ vi libmkl_em64.a

Add the text

GROUP (libmkl_intel_lp64.a libmkl_intel_thread.a libmkl_core.a)

Keep it into the mkl library directory.

Intel® MKL for windows

In case of Windows you may create c file with the following code:

// dynamic library link

#pragma comment(lib, "mkl_intel_c_dll")
#pragma comment(lib, "mkl_intel_thread_dll")
#pragma comment(lib, "mkl_core_dll")
#pragma comment(lib, "libiomp5md")

 // static library link
//#pragma comment(lib, "mkl_intel_c")
//#pragma comment(lib, "mkl_intel_thread")
//#pragma comment(lib, "mkl_core")
//#pragma comment(lib, "libiomp5md")

void dummy_func_somethingrandom_1234217846()

{ return; }

Compiling this code with any compiler and making lib out of it:

>cl -c mkl_ia32.c

>lib mkl_ia32.obj

The fake function is essential, since in some cases Microsoft Visual Stuio linker can report an error while linking library without any functions in it.

TroubleShooting regarding dummy library: 

1. Problem with Linking Applications to Intel MKL 10.0 for Linux* Dummy Shared Librares
2. Errors linking Intel® compilers with Intel® MKL 10.x
3. "MKL FATAL ERROR: Cannot load neither xxxx" with Intel MKL 10.x
4. If you are link mkl library pure layaered library by configure as below

./configure --mkl_lib='/opt/intel/mkl/10.2.x.0xx/lib/em64t/libmkl_intel_lp64.a
/opt/intel/mkl/10.2.x.0xx/lib/em64t/libmkl_sequential.a
/opt/intel/mkl/10.2.x.0xx/lib/em64t/libmkl_core.a'

Please note the mark '  ' are required.

2. Intel® MKL for windows
   You can install MKL seperately or install the intergarted MKL when install Intel Fortran Compiler Professional version. 

3. Microsoft* Visual Studio 2005 or 2008.
For who'd like to build x64 bit appliation, please install the MSVC* package which supports X64 development.

Step1 : Which kind of application: ia32, em64t or ia64 application you need to build?
Which target machine you need your application run on?
ia32: 32 bit application. 
EM64t: Intel 64 bit application
IA64:  Intel Itanium 64bit application. 

Most of us may build ia32 or em64t application on a xeon machine with windows*. Then in MSVC* environment, please check the project configuration manager=> active platform.  They should be  "ia32" or "X64" (which is corresponding to em64t).

Step 2 : Which MKL library you need link against?
2.1) please check the on-line KB article Intel® Math Kernel Library Link Line Advisor  After choose it, you can get which libraries you need to list. 

For example,
"mkl_intel_c.lib mkl_intel_thread.lib mkl_core.lib libiomp5md.lib" are enough for a ia32 windows application generally.
"mkl_intel_lp64.lib mkl_intel_thread.lib mkl_core.lib libiomp5md.lib" are ok for a X64 windows appliation

Step 3: How to link MKL in your project manually?
3.1)  Please follow the steps in how to use MKL in MSVC  to add the include path, library path and mkl library as the article show. 

For example, add include path manually


please take care of about library path,  you need enter right directory:
<MKL install dir>\ia32,  for ia32 application
<MKL install dir>\em64t, for X64 application
<MKL install dir>\ia64, for IA64 application
they can't be mixed. 


Step 4: How to link MKL in your project automatically - One Button Support  (optional)
The recent MKL version have provided one "build" menu in MSVC environment. Click one button, all of environment setting and required library are ready in your project.
* This step can replace the step3 in most of case.  
Or if the button is not show, please try step3, set the paths and library manually.
4.1) See below sreencopy in MSVC 2005, click the version you need

Then the required library will be added in your project automatically.


4.2) In Visual Fortran compiler, it is a little different, to integrate MKL,  please click the compiler option as below, change the "No" to value like /Qmkl:parallel or /Qmkl:sequential

Please note: some interface libraries (i.e mkl_lapack95.lib mkl_blas95.lib fftw3xc_ms) are not MKL standard library,  so the "one button" integration don't support it.  You may add them manually if you need to use them.

Step 5: About Compaq*Visual Fortran support and porting from 32bit to 64bit (Optional for who have used CVF)
CVF and Intel Fortran compiler use different call convention by default:
CVF: stdcall
Intel Fortran, C Compiler: cdecl (default interface of the Microsoft Visual C* application)

5.1) MKL support both of them on ia32 platform, but if you are porting from CVF to intel Fortran, you may take care of the required library: mkl_intel_s or mkl_intel_c.lib

• Using the CVF compiler
  The CVF compiler will link with mkl_intel_s[_dll].lib if routines are compiled with the default interface. However, if you compile with the option /iface=(cref,nomixed_str_len_arg), the compiler will link with mkl_intel_c[_dll].lib .
• Using the Intel® Fortran compiler
  The Intel Fortran compiler will link with mkl_intel_c[_dll].lib by default. But if the /Gm option is used, call mkl_intel_s  [_dll].lib (/Gm enables CVF and Powerstation calling convention compatibility, so does /iface:cvf).

5.2) MKL don't provide em64t and IA64 CVF interface support.  So if you are porting CVF 32bit application to X64 or IA64 platform with Intel Fortran compiler and MKL. Please note, you must to link "mkl_intel_lp64|ilp64, mkl_intel_thread, mkl_core.lib" and remove the compiler option /Gm or /iface:cvf.

Here is a MSVC 2005 project (Intel fortran 11.0.0.074 IA32 application) for your reference.DFT_VF_sample.zip

Troubleshooting
When build the project,
1. fatal error LNK1104: cannot open file 'mkl_xxx.lib'
please make sure the library is in the library path and the path you marked in step 3 or step 4 are right one

2. "error #7002: Error opening the compiled module file.  Check INCLUDE paths. [MKL_DFTI]."
Please add the header file mkl_dfti.f90 in your code, for example,

! Include to build module MKL_DFTI
INCLUDE 'mkl_dfti.f90'
before  the code line
USE MKL_DFTI

Or copy the mkl_dfti.f90 file to the source directory of your project and include it in your Project. 

or vice versa message
This can cause performance degradation.

Cause:

Both libiomp5md.dll and libguide40.dll are Intel OpenMP Runtime library. The libiomp5md.dll is new Intel OpenMP* Compatibility library while the libguide40.dll is legacy OpenMP library. Since Intel® MKL 10.1.0.018 and Intel® Compiler 11.x and later,  the default OpenMP runtime library for Intel MKL has been changed from libguide to libiomp.  Please see <http://software.intel.com/en-us/articles/openmp-support-change/>
 
The error is caused by multiple OpenMP libraries were linked in same application. For example, you have two mkl versions MKL 10 and MKL 10.2.1 are linked in same appliation. The error arises because of the duplicate initialization of OpenMP Runtime library from MKL 10 which link libguide40 and MKL 10.2.1 which use libiomp5md .

Please note, the libguide40.dll sometimes were linked implicitly, e.g. by third-party library, custom dll or by dummy library mkl_c.lib in previous MKL version.

Solution:

Please remove one of them and keep only one OpenMP runtime library.

We recommend using and distributing libiomp5md.dll (located in the \bin directory), as libguide40 will be obsolete.

For the third-party library or custom dll which have used the libguide40.dll from pervious  MKL version, in order to avoid such kind of issue, we strongly recommend rebuild your library with libiomp5md.dll.

• Extra Precise Iterative Refinement
• Non-Negative Diagonals from Householder QR
• High Performance QR and Householder Reflections on Low-Profile Matrices
• New fast and accurate Jacobi SVD
• Routines for Rectangular Full Packed format
• Pivoted Cholesky
• Mixed precision iterative refinement routines for exploiting fast single precision hardware
• Some new variants added for the one sided factorization
• More robust DQDS algorithm

Introduction 

Several users have asked how to call and link the Intel® Math Kernel Library (Intel® MKL) functions from their C# programs. While the standard way of interfacing with third party software libraries from C# is well documented, some of the steps in interfacing with Intel MKL specifically may still be confusing. The attached source code package is intended to show how to navigate the whole process for Intel MKL users. These examples show how to create a DLL from Intel MKL libraries, call those functions from their C# source, and interface with that DLL.

Examples are provided for calling the BLAS, LAPACK, DFTI (the FFT interface), the PARDISO direct sparse solver, and the vector math library (VML).

Building the Examples

Follow these steps to build the example programs:

• unzip the contents of the attached zip file
• Open a Microsoft Visual Studio command prompt or add the Microsoft.NET Framework to the PATH environment variable in another command prompt
• Run the build script (makefile) using nmake
  • Example: nmake ia32 MKLROOT="c:\program files\intel\mkl\10.1.1.015"
  • The makefile provides further explanation of the parameters in comments

This will create an executable for each of the example programs.

Example files: Intel_MKL_C#_Examples.zip

Take our C++/C# interface survey for Intel® Math Kernel Library

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.