Intel Software Network articles Feed

A New Linking Model-Single Dynamic Library mkl_rt Since Intel® MKL 10.3

Sat, 24 Sep 2011 08:00:00 -0700

Starting with Intel® MKL 10.3, there is a new dynamic library - the Single Dynamic Library interface (SDL interface) mkl_rt library was introduced. What is that? This article describes what is the SDL and how it can actually do for you.

Single Dynamic Library (SDL)

	Files	Notes
Windows*	mkl_rt.lib & mkl_rt.dll	Single Dynamic Library interface library & Single Dynamic Library
Linux and MacOS*	libmkl_rt.so	Single Dynamic Library

The runtime single dynamic libraries (SDL) library was introduced originally for solving the declared issue related to the processor specific libraries not getting loaded when dlopen(RTLD_GLOBAL) was called. The typical error message is

MKL FATAL ERROR: Cannot load neither libmkl_mc3.so nor libmkl_def.so

The single library is added allowing user to link to a single interface library which loads dependent libraries dynamically at runtime depending on runtime CPU detection and/or library function calls.

So the custom dynamic libraries builder in current version used it by default on the Linux* and Mac OS* X operating systems.

Besides resolving the load issue, the SDL actually brings some other benefits:

•1. A new linking model, make linking simpler

Generally, to link with Intel® Math Kernel Library (Intel® MKL), you may need to choose one library from the Interface layer and one library from the Threading layer and add the only library from the Computational layer and run-time libraries (RTL). See MKL Link Line Advisor

Alternatively, the Single Dynamic Library (SDL) does most of this for you and makes linking even simpler.

For example, dynamic linking of myprog.cpp and parallel Intel MKL supporting the cdecl interface under Windows IA32:

>cl myprog.cpp mkl_intel_c_dll.lib mkl_intel_thread_dll.lib mkl_core_dll.lib libiomp5md.lib

To use SDL library, put only one library in link line

>cl myprog.cpp mkl_rt.lib libiomp5md.lib

For details, please read mkl user guide: Using the Single Dynamic Library Interface

•2. Enables you to select the interface and threading layer dynamically

Setting the Threading Layer at use the mkl_set_threading_layer function or the MKL_THREADING_LAYER environment variable.

To set one of these interfaces at run time, use the mkl_set_interface_layer function or the MKL_INTERFACE_LAYER environment variable when based on the Intel(R) 64 architecture

For example

mkl_set_interface_layer(MKL_INTERFACE_LP64)

mkl_set_threading_layer(MKL_THREADING_SEQUENTIAL);

for sequential library and LP 64 interface.

Please take a look at this KB article Using the Intel® MKL Dynamic Interface for Windows OS for more details about new optional linking model.

•3. Support third-party application and language like C#, Java, Python better

Dynamic interface libraries have been added in Intel MKL 10.3 for improved linkage from C#. It is not required to build a custom DLL. The Intel MKL library named mkl_rt.dll can be called directly from C# code

A example is in http://software.intel.com/en-us/articles/using-intel-mkl-in-your-c-program/

It is same for python program. Using SDL directly removes the need to create your own custom library. Please see the article http://software.intel.com/en-us/articles/using-intel-mkl-in-your-python-programs/

For third-party application which have used previous mkl version, like have some link lines

-lmkl_em64t

And get the error like: libmkl_em64t can't be found

You can change them to -lmkl_rt as replacement. It includes all mkl routines declaration

SDL Known Issues

undefined symbol: omp_get_num_procs
from http://software.intel.com/en-us/forums/showthread.php?t=83364
Cause: The MKL loader located in libmkl_rt.so doesn't try to load libiomp5 library in previous MKL 10.3.x version and the problem is fixed since MKL 10.3.6.
Solution: build custom dll via custom dll builder tool or upgrade to latest MKL version (at least MKL 10.3.6)

SDL-Interface under x64 crashes
from http://software.intel.com/en-us/forums/showthread.php?t=80451
Solution: require the related MKL dlls (e.g. libimalloc mkl_mc3 mkl_core mkl_intel_thread) in the PATH

http://software.intel.com/en-us/forums/showthread.php?t=81913

http://software.intel.com/en-us/forums/showthread.php?t=82826

http://software.intel.com/en-us/forums/showthread.php?t=78272

Reference

How do I use Intel® MKL with Java*?
Using Intel® MKL in your C# program
Some more additional tips "How to call KL from your C# code"
Using Intel® MKL in your Python program
Intel® MKL and Third Party Application How to Use them together
Using the Intel® MKL Dynamic Interface for Windows OS
Linking Applications With Intel® MKL Version 10.0
MKL Link Line Advisor

Intel(R) MKL Command-line Link Tool

Mon, 19 Sep 2011 00:00:00 -0700

The Intel® Math Kernel Library (Intel® MKL) Link Tool is an executable program that can help to build an application using Intel® MKL or simplify building the application with Intel® MKL. The Intel MKL Link Tool can add all needed options and libraries for the application and advises on which environment variables to use.
The tool supports three modes:

Inquiry mode: In this mode, the tool can return the compiler options, libraries, or environment variables necessary to build and execute the application. Usage:
- Get Intel MKL libraries:
- Get compilation options:
- Get environment variables for application executable:

Compilation mode: In this mode the Intel MKL Link Tool can build the application. Usage:
where
Interactive mode: This mode allows users to go through all possible Intel MKL Link Tool supported options. The output provides libraries, options, or environment variables as in the inquiry mode, or a built application as in the compilation mode (depending on what you specify). Usage:

Use the -help option for full help with the Intel MKL Link Tool and to show the defaults for the current system.

Description of PARDISO errors and messages

Fri, 14 Jan 2011 11:30:00 -0800

See the table below for the description of the error indicator.

*Error* ( Integer)	Information
0	no error
-1	input inconsistency
-2	not enough memory
-3	reordering problem
-4	zero pivot, numerical factorization or iterative refinement problem
-5	unclassified (internal) error
-6	preordering failed (matrix types 11, 13 only)
-7	diagonal matrix is singular
-8	32-bit integer overflow problem
-9	not enough memory for OOC
-10	problems with opening OOC temporary files
-11	read/write problems with the OOC data file

Below each error is described in details:

0: no error

-1: Input inconsistency

This error can appear in the following situations:

Incorrect stage number for PARDISO was called.
Incorrect PARDISO calling sequence, e.g. run stage > 1 without initialization results in error reporting.
Incorrect number of matrices to be solved was set (PARDISO can be used for solving several matrices with the same sparsity structure at once, taking into account that their maximum number was defined previously. Setting the number of matrices to be solved outside the range of 1≤ … ≤maxfct results in error).
PARDISO checks the parameters at each stage for consistency with the parameters at the previous stages. Every disagreement results in error reporting.

-2: not enough memory

This error value is returned in the case of any problem with memory allocation inside PARDISO.

PARDISO messages:

"*** Error in PARDISO memory allocation: [STRUCTURE NAME], size to allocate: %d bytes"

"total memory wanted here: %d kbyte"

"symbolic (max): %d symbolic (permanent): %d"

"real(including 1 factor): %d"

It describes the issue that arises on allocation of STRUCTURE_NAME inside PARDISO. A additional information about current memory usages is also printed.

-3: reordering problem

Returned for any problem on a reordering stage (phase 11)

PARDISO messages:

"*** error PARDISO: reordering, symbolic factorization"

-4: zero pivot, numerical factorization or iterative refinement problem

Let us start with a citation of the Intel MKL manual:

Using phase =33 results in an error message (error =4, should be -4 * ) if the stopping criteria for the Krylow-Subspace iteration cannot be reached.

If phase= 23, then the factors L, U are recomputed for the matrix A and the error flag error=0 in case of a successful factorization. If phase =33, then error = -4 signals the failure

If the solver detects a zero or negative pivot for these matrix types, the factorization is stopped, PARDISO returns immediately with an error (error = -4) and iparm(30) contains the number of the equation where the first zero or negative pivot is detected.

The error returned in the case of any problem at the factorization stage (phase 22) or at the iterative refinement stage of solution.

PARDISO messages:

"*** Error in PARDISO: cgs error iparam(20) %d" – prints iparm(20) – see CG / CGS diagnostics in the Intel MKL manual

"*** error PARDISO: iterative refinement"

" contraction rate is greater than 0.9, interrupt" – rate of contraction is too small

"*** error PARDISO: iterative refinement"

" exceeds max. iteration number %d" - prints abs(iparm(8))

"*** Error in PARDISO: internal error, insufficient memory factorization" – looks like a problem at the factorization stage except for pivoting issues (see errors below)

"*** Error in PARDISO: zero or negative pivot, A is not SPD-matrix" – original matrix (almost) not SPD one (probably due to computer arithmetic inaccuracies)

"*** Error in PARDISO: zero pivot" – the same as above but for other matrix types

-5: unclassified (internal) error

This error value is not used currently and is reserved for the future use.

-6: preordering failed (matrix types 11, 13 only)

This error value is returned in the case of any problem at the stage of preparation for reordering (in matching algorithm).

PARDISO messages:

"*** Error in PARDISO: preordering failed after %d neqns out of %d"

"structure singular or input/parameter problem (matrix type 11,13)"

Looks like the message provides no meaningful information.

-7: diagonal matrix problem

PARDISO prints no messages.

-8: 32-bit integer overflow problem

This error value is returned on 32-bit architecture for big matrices when indices become greater than the maximal integer value on this platform.

PARDISO messages:

"*** error PARDISO: reordering, symbolic factorization"

-9: not enough memory for OOC

Let us start with a citation of the Intel MKL manual:

Note that if iparm(60) is equal to 1 or 2, and the total peak memory needed for strong local arrays is more than MKL_PARDISO_OOC_MAX_CORE_SIZE, the program stops with error -9. In this case, increase of MKL_PARDISO_OOC_MAX_CORE_SIZE is recommended.

This error value is returned when amount of memory available for PARDISO (defined by MKL_PARDISO_OOC_MAX_CORE_SIZE, by default 2000 Mb) is not enough to solve the current matrix. The issue can be resolved by increasing the value for available memory.

-10: problems with opening OOC temporary files

This error value is returned when PARDISO can’t create / open temporary files for storing OOC arrays, e.g. in the case of wrong permissions or when files were removed or blocked or not released after the previous steps.

-11: read/write problems with the OOC data file

This error value is returned when some problems appear in the process of working with files, e.g. in the case of no space left on device or problems with read / write operations because of algorithm issues.

* - the documentation error. Will be fixed in the version 10.3 Update3.

** - available memory means the RAM system's memory which is available at the moment of starting the calculations.

True DSS and PARDISO overloaded F90 interfaces are available in Intel®MKL 10.3.1 and 10.2.7.

Wed, 08 Dec 2010 11:30:00 -0800

Renewed F90 interfaces for DSS and PARDISO are available in Intel® MKL 10.3.1 and 10.2.7.

There are a few advantages over the previous version.

DSS:

New DSS F90 interfaces allow calling factor and solve routines via short names.

Now there is no need to specify a data type (real/complex) in the name of routines as the interfaces are overloaded.

All data types are supported: real(kind=4), real(kind=8), complex(kind=4) and complex(kind=8).

Old names	New names
dss_factor_real() dss_factor_complex() dss_solve_real() dss_solve_complex()	dss_factor() dss_solve()

Backward compatibility with old names is supported.

PARDISO:

New PARDISO F90 interface is also overloaded and accepts all data types:

real(kind=4), real(kind=8), complex(kind=4) and complex(kind=8).

NOTE: Despite new F90 interfaces are overloaded by all data types - do not forget to set single precision options explicitly in DSS and/or PARDISO when it's needed.

How to select different update of Intel® Composer XE 2011 for Linux* and Mac OS* X

Mon, 06 Dec 2010 08:00:00 -0800

Reference Number : dpd200194608, dpd200160631

Version : 2011 (Compiler 12.0)

Product : Intel Composer XE

Operating System : Linux, Mac OS X

Problem Description : When an Intel Composer XE update is installed, the scripts compilervars.sh [.csh] in the bin directories of previously installed compilers no longer set the environment for the corresponding compiler or update, but set the environment for the most recent update instead. This applies to all components of Intel Composer XE that may be present: C/C++ and Fortran Compilers; Intel Debugger; Intel Threading Building Blocks; Intel Math Kernel Library and Intel Performance Primitives.

Workaround:

To select a compiler update other than the latest, please use the script compilervars_arch.sh [.csh] from the bin directory of the desired compiler version. Similarly, for other components of Intel Composer XE, use the scripts idbvars.sh, tbbvars.sh, mklvars.sh and ippvars.sh from the bin directory of the desired version, as needed.

Resolution Status:
The issue has been fixed in Composer XE update #4. To select a specific version, use the compilervars.[c]sh script from the version-specific directory. For example, after installing update #4 on a system where update #3 was already installed:

> source /opt/intel/composerxe-2011.3.174/bin/compilervars.sh intel64 <<<=== update #3

> ifort -V
Intel(R) Fortran Intel(R) 64 Compiler XE for applications running on Intel(R) 64, Version 12.0.3.174 Build 20110309

> source /opt/intel/composerxe-2011.4.191/bin/compilervars.sh intel64 <<<== update #4

> ifort -V
Intel(R) Fortran Intel(R) 64 Compiler XE for applications running on Intel(R) 64, Version 12.0.4.191 Build 20110427

As before, the script from the generic, non-version specific directory will initialize for the most recent update:

> source /opt/intel/composerxe-2011/bin/compilervars.sh intel64 <<<=== non-version specific (most recent update)
> ifort -V
Intel(R) Fortran Intel(R) 64 Compiler XE for applications running on Intel(R) 64, Version 12.0.4.191 Build 20110427

[DISCLAIMER: The information on this web site is intended for hardware system manufacturers and software developers. Intel does not warrant the accuracy, completeness or utility of any information on this site. Intel may make changes to the information or the site at any time without notice. Intel makes no commitment to update the information at this site. ALL INFORMATION PROVIDED ON THIS WEBSITE IS PROVIDED "as is" without any express, implied, or statutory warranty of any kind including but not limited to warranties of merchantability, non-infringement of intellectual property, or fitness for any particular purpose. Independent companies manufacture the third-party products that are mentioned on this site. Intel is not responsible for the quality or performance of third-party products and makes no representation or warranty regarding such products. The third-party supplier remains solely responsible for the design, manufacture, sale and functionality of its products. Intel and the Intel logo 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.]

New matrix vector product BLAS routines

Sun, 07 Nov 2010 07:30:00 -0800

Starting with the version 10.3, Intel® MKL provides BLAS Level 2 routines for computing two matrix-vector products for a dense matrix. These routines support all MKL's data types ( single/double, single complex, double complex precisions).

The current implementation offers FORTRAN 77 and FORTRAN 95 interfaces only.

This is Fortran77 Syntax for the double precision data type:

call dgem2vu(m, n, alpha, a, lda, x1, incx1, x2, incx2, beta, y1, incy1, y2, incy2);

Description
The dgem2vu routines perform two matrix-vector operations defined as
y1 := alpha*A*x1 + beta*y1,
and
y2 := alpha*A'*x2 + beta*y2,
where:
alpha and beta are scalars,
x1, x2, y1, and y2 are vectors,
A is an m-by-n matrix.

and the output parameters are y1 and y2 correspondingly.

The prototype of the code:

A prototype code is:
do j = 1, N
do i = 1, M
B1(i) = B1(i) + A(i,j)*V1(j)
B2(j) = B2(j) + A(i,j)*V2(i)
end do
end do

because of the reuse matrix A(i,j) elements at the loop, there is a significant performance benefit versus 2 consecutive calls of 2 DGEMVs or DSYMV routines.

Below is the performance result comparison for DGEM2VU / ( 2 consecutive calls of DGEMV ) / DSYMV

C interface Support for LAPACK

Sat, 06 Nov 2010 11:30:00 -0700

Intel® MKL 10.3, we have extended C support and added C language interface to LAPACK rotuines.

Please refer the C interface to LAPACK technical paper for more details.

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

Intel® FLEXlm* License Borrowing Capability

Fri, 06 Aug 2010 00:00:00 -0700

Overview

This feature allows users to ‘borrow” a license seat from the license host server for a limited time, disconnect from the network and use the borrowed license even with no connection to the license server. This is very useful in case you want to use the software offline.

Required Information

To use the license borrow functionality for Intel floating product licenses, customers need to ensure they have the following items:

1) A build of the Intel® License Manager for FLEXlm* (for the desired OS) that supports the Borrow capability:

a) Users need to make sure that they are using a build of Intel FLEXlm* License Manager which supports borrowing
and early return of borrowed licenses.

b) We recommend the customer download and install one of the free license manager servers available at the
following website link:
http://software.intel.com/en-us/articles/performance-tools-for-software-developers-intel-flexlm-license-servers/

2) A license file which has the keyword BORROW in it:

a) Licenses for Intel® Software Development Products with version 2011 have the BORROW feature with a BOROW period of 7 days enabled by default.

b) To obtain a borrow-enabled license for a multi-seat floating product license with a version older than 2011, please   submit an issue to Intel® Premier Support at https://premier.intel.com/ under product 'Download, Licensing and Registartion'.


Steps for starting the FLEXlm* License Manager (Server) for using the Borrow feature

(1) Start the license server using the new borrow-enabled license file(s).

(2) Check the log for the Intel® FLEXlm* License Server and make sure that it does not complain about BORROW keyword in the license file.

     • By default, the log file location on Windows* is: %ProgramFiles%\Common Files\Intel\FLEXlm
     • By default, the log file location on Linux* and Mac OS* X is the same where FLEXlm server has been installed

     A typical log file when FLEXlm Server has started successfully looks like the following:

     14:00:31 (lmgrd) US Patents 5,390,297 and 5,671,412.
    14:00:31 (lmgrd) World Wide Web: http://www.macrovision.com
     14:00:31 (lmgrd) License file(s): server.lic
     14:00:31 (lmgrd) lmgrd tcp-port 28518
     14:00:31 (lmgrd) Starting vendor daemons ...
     14:00:31 (lmgrd) Started INTEL (internet tcp_port 35860 pid 9309)
     14:00:31 (INTEL) FLEXlm version 9.23
     14:00:31 (INTEL) Server started on LicenseServer for:
     14:00:31 (INTEL) I3F97C15E (consisting of:   ArBBL
     14:00:31 (INTEL) CCompL    DbgL    FCompL
     14:00:31 (INTEL) MKernL    PerfAnl    PerfPrimL
     14:00:31 (INTEL) StaticAnlL    ThreadAnlGui    ThreadBB)

Client System Setup for the Borrow feature (Application Setup)

NOTE: The term “Client” refers to the application that uses Intel FLEXlm floating license seat check-out and check-in.

1) Download the lmutil for your operating system and architecture from http://www.globes.com/support/fnp_utilities_download.htm.

2) If you are not able to download the lmutil from the website above, work with your Intel Support team contact (or submit an issue to Premier Support at https://premier.intel.com/) for access to lmutil, and have the information about your Operating System, OS Version and Architecture (IA-32, Intel® 64 and/or IA-64[Intel® Itanium®]).

3) Verify that no Intel product components’ license seats (i.e., Compiler Professional Edition, Vtune, etc.) can be borrowed by running the following command. If you see any information that indicates one or more features/components were borrowed, then borrowing has already been enabled for those licensed features/components. Here is an example of output when no borrowing is enabled.

lmutil lmborrow -status

Example:
lmutil lmborrow -status
lmutil - Copyright (c) 1989-2009 by Macrovision Corporation. All rights reserved.

4) Configure the borrow duration and FLEXlm feature to be borrowed:

lmutil lmborrow INTEL dd-mmm-yyyy:[time] -c

Example:
lmutil lmborrow INTEL 06-Oct-2011 CCompL -c server.lic

where,
server.lic is the license file which was used to start the server. It should be noted that license borrowing will fail if the license file on the client side is different than the one which was used to start the server.

The command above borrows a “featurename” called CCompL (Intel® C++ Compiler for Linux*) from the vendor INTEL until 6th Oct 2011 using the license file server.lic

NOTE: The time specified on command line of lmborrow is the end date/time the user planed to borrow, which must be <= 168 hours, which is the maximum borrow period. If the user wants to borrow the license seat for only 1 or 2 days, the corresponding date/time for that period should be set.
Users cannot borrow a license seat for more than the 168 hour barrier that is set in the license file and in the license server logic. If an extended borrow time is required, please submit an issue to Intel® Premier Support at https://premier.intel.com/ under product 'Download, Licensing and Registartion' providing a jsutification of why you need to extend the borrow time beyond 7 days.

After running this command, the customer should see the following:

lmutil - Copyright (c) 1989-2004 by Macrovision Corporation. All rights reserved.
Setting LM_BORROW=3-oct-2011:INTEL:06-oct-2011:CCompL

5) If the above steps are successful, you are now ready to borrow a seat by running the client application (e.g. – Composer XE, Vtune Amplifier XE, Inspector XE, etc). The FLEXlm feature will be borrowed when you run the client/application and a successful check-out happens. As soon as the first license is checked out, the server log file will confirm the borrowed feature with the following message in the log file:

14:35:14 (INTEL) OUT: "I3F97C15E" User1@Host1
14:35:14 (INTEL) OUT: "CCompL" User1@Host1

Note that there are no corresponding IN entries in the server log. This is different behavior than a normal check-out where corresponding to every two OUT entries in the server log file, you will also see two IN entries after the OUT entries after the application exits.

6) Verify that the FLEXlm product feature was really borrowed by running the following command on the client system:

lmutil lmborrow –status

Example for borrowing a seat for the Intel C++ Compiler for Linux*:

lmutil lmborrow –status
lmutil - Copyright (c) 1989-2004 by Macrovision Corporation. All rights reserved.

Vendor Feature Expiration
______ ________ __________

INTEL CCompL 6-Oct-11 23:59

NOTE: Before the Borrow period expires, the product will always get the license from the local storage for the Borrowed license seat when it tries to check-out license. The Client system on which the product is used does not need to be attached to FLEXlm* license host server.

7) Disconnect the client system from the server network. Now with the borrowed license, you can use the software application with the borrowed license.

NOTE: After the Borrow period expires, the product license seat will no longer to be able to check-out the license from local storage. Instead, the client system must be “attached” to the FLEXlm* license host server to check-out a product license seat.

8) Run the following command to return a borrowed license:

lmutil lmborrow -return -c server.lic featurename

Example:
lmutil lmborrow -return -c server.lic CCompL
lmutil - Copyright (c) 1989-2009 by Macrovision Corporation. All rights reserved.

On the FLEXlm server side, you will see the following message in the log file for the borrowed feature which was returned. This message is different compared to a normal check-in.

14:40:17 (INTEL) REMOVING User1@Host1:/dev/pts/0 from CCompL by administrator request.

14:40:17 (INTEL) IN: "CCompL" User1@Host1 (USER_REMOVED)
14:40:17 (INTEL) IN: "I3F97C15E" User1@Host1 (USER_REMOVED)

9) Run the following command to verify that the license was returned successfully back to the server:

lmutil lmborrow -status

Example:
./lmutil lmborrow -status
lmutil - Copyright (c) 1989-2009 by Macrovision Corporation. All rights reserved.

Note: If you try to return a license which has not been borrowed, you will see a message like this:

./lmutil lmborrow -return -c server.lic CCompL
lmutil - Copyright (c) 1989-2009 by Macrovision Corporation. All rights reserved.
Error: CCompL not currently borrowed.

Getting reproducible results with Intel® MKL

Thu, 29 Jul 2010 00:00:00 -0700

Introduction

The Intel® Math Kernel Library (Intel® MKL) contains highly optimized, extensively threaded math routines for science, engineering, and financial applications that require maximum performance. While performance is the chief reason for the existence of Intel MKL, users count on Intel MKL to employ the best practices available to provide accurate results. In recent years, a growing number of Intel MKL users have noted a number of factors that can affect the numerical results of the library. This article discusses the underlying reason for these variations in output, the mechanisms that cause the variations in Intel MKL, and some ways to improve chances for consistency in certain cases.

The sources of indeterminism

Most users of floating point math libraries expect some rounding error when doing multiple calculations. A simple experiment shows that the rounding error can be different if the order of operations changes. If we assume for a moment double precision floating point numbers, then:

2⁶⁰ + (-2⁶⁰ + 1) = 2⁶⁰ + -2⁶⁰ = 0

since -2⁶⁰ + 1 rounds to -2⁶⁰. Yet

(2⁶⁰ + -2⁶⁰) + 1 = 0 + 1= 1

With this simple example in mind we’ll discuss three different cases where methods used in Intel MKL that are crucial to performance cause indeterminate results.

Memory alignment: One of the ways Intel MKL gets good performance is through use of new instructions made available with successive generations of Intel® processors. Some of these instructions make computation more efficient by performing the same floating point operation on multiple floating point numbers at once. The way some of these instructions are loaded however depends on how the data is situated in memory. If in one run of the program, the data happens to be aligned along a 16-byte boundary, then the first 2 double precision numbers in the array would be grouped together, while in the next run, if the array is offset from that memory boundary, then the 2nd and 3rd double precision numbers are grouped together. This difference in order can cause different results when running the same program two times consecutively with all settings remaining identical. Update: The latest processors supporting Intel Advanced Vector Extensions (AVX) have larger registers and thus change the requirement to alignment along 32-byte boundaries.

Internal Intel MKL code paths: To get the best performance wherever a program is run, Intel MKL will check on the processor type at runtime and can dispatch processor-specific code accordingly. If a particular instruction set or cache of a certain size is available a specialized code path may exploit it. These code paths are different enough that they will again cause a different order of operations and will cause slightly different results on different processors.

Threading: Finally, Intel MKL has been threaded for over 10 years, but it is only more recently that access to systems with many processors has become common place. Threading is an important way that Intel MKL provides top performance on today’s systems. With different numbers of threads, a problem will be divided in different ways and order of operations change, causing the results to change slightly. If the number of threads is not set, Intel MKL will by default use the number of cores that the OS reports are available on that system. But even in the case when a program is run more than once on the same systems with same number of threads some function in Intel MKL may return differing results. The reason has to do with how these functions use threading to asynchronously accumulate the results from the multiple threads. Since very small changes in the system can cause the threads to return in a different order, the results can be accumulated in a different order, causing slight variations in output.

What can be done?

In the case of memory alignment, the answer is relatively easy. Simply aligning the memory allocated for input data along 16-byte boundaries (or 32-byte boundaries on processors supporting Intel AVX) will ensure that the results will be consistent. To this end we provide the mkl_malloc() functions to allocate memory along these boundaries.

In the case of threading, many functions will return the same results if run with the same number of threads on the same number of cores. For those functions that are exceptions to this, one should set the number of threads to 1, or link the sequential version of the library at significant cost to the performance on systems where Intel MKL would otherwise use a large number of cores.

Finally, because disabling the optimized code paths or threading can have such a large impact on performance, the best option may be to consider making some allowance for small variations in results wherever possible.

Intel® Math Kernel Library 10.3 Beta

Fri, 02 Jul 2010 07:30:00 -0700

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

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.