tsai
/
mathnet-numerics
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Math.NET Numerics
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
10 Commits
25 Branches
121 Tags
187 MiB
 
 
 
Tree: 6a03ab3548
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '6a03ab3548'
${ noResults }
mathnet-numerics/MKL.html

407 lines
24 KiB
Raw Blame History

<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8"/>
<title>Intel Math Kernel Library (MKL)
</title>
<meta name="viewport" content="width=device-width, initial-scale=1.0"/>
<meta name="description" content="Math.NET Numerics, providing methods and algorithms for numerical computations in science, engineering and every day use. .Net 4, .Net 3.5, SL5, Win8, WP8, PCL 47 and 136, Mono, Xamarin Android/iOS."/>
<meta name="author" content="Christoph Ruegg, Marcus Cuda, Jurgen Van Gael"/>
<script src="https://code.jquery.com/jquery-1.8.0.js"></script>
<script src="https://code.jquery.com/ui/1.8.23/jquery-ui.js"></script>
<script src="https://netdna.bootstrapcdn.com/twitter-bootstrap/2.2.1/js/bootstrap.min.js"></script>
<link href="https://netdna.bootstrapcdn.com/twitter-bootstrap/2.2.1/css/bootstrap-combined.min.css" rel="stylesheet"/>
<link type="text/css" rel="stylesheet" href="https://numerics.mathdotnet.com/content/style.css" />
<style>
#main table:not(.pre) {
border: 1px solid #dddddd;
max-width: 100%;
border-style: solid;
border-width: 1px;
border-color: gray;
border-collapse: collapse;
border-right-width: 1px;
border-bottom-width: 1px;
margin-top: 15px;
margin-bottom: 25px;
}
#main table:not(.pre) th, #main table:not(.pre) td {
border: 1px solid #dddddd;
padding: 6px;
}
#main table:not(.pre) th p, #main table:not(.pre) td p {
margin-bottom: 5px;
}
</style>
<script type="text/javascript" src="https://numerics.mathdotnet.com/content/tips.js"></script>
<!-- HTML5 shim, for IE6-8 support of HTML5 elements -->
<!--[if lt IE 9]>
<script src="https://oss.maxcdn.com/html5shiv/3.7.2/html5shiv.min.js"></script>
<![endif]-->
<script type="text/javascript" src="https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.1/MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script>
</head>
<body>
<div class="container">
<div class="masthead">
<ul class="nav nav-pills pull-right">
<li><a href="https://www.mathdotnet.com">Math.NET Project</a></li>
<li><a href="https://numerics.mathdotnet.com">Math.NET Numerics</a></li>
<li><a href="https://github.com/mathnet/mathnet-numerics">GitHub</a></li>
</ul>
<h3 class="muted">Math.NET Numerics</h3>
</div>
<hr />
<div class="row">
<div class="span9" id="main">
<h1><a name="Intel-Math-Kernel-Library-MKL" class="anchor" href="#Intel-Math-Kernel-Library-MKL">Intel Math Kernel Library (MKL)</a></h1>
<p>Math.NET Numerics is designed such that performance-sensitive algorithms
can be swapped with alternative implementations by the concept of providers.
There is currently only a provider for <a href="https://numerics.mathdotnet.com/api/MathNet.Numerics.Providers.LinearAlgebra.Mkl/MklLinearAlgebraProvider.htm">linear algebra related routines</a>, but there
are plans to add additional more e.g. related to nonlinear optimization problems or signal processing.</p>
<p>Providers become interesting when they can leverage a platform-native high performance library
like Intel MKL instead of the default purely managed provider. Math.NET Numerics
provides such a provider as NuGet packages:</p>
<ul>
<li>MathNet.Numerics.MKL.Win</li>
<li>MathNet.Numerics.MKL.Linux</li>
</ul>
<p>Since these native libraries can become very big, there are also variants supporting
only a single platform, for example:</p>
<ul>
<li>MathNet.Numerics.MKL.Win-x86</li>
<li>MathNet.Numerics.MKL.Win-x64</li>
</ul>
<p>In order to leverage the MKL linear algebra provider, we need to make sure the .NET
runtime can find the native libraries (see below) and then enable it by calling:</p>
<table class="pre"><tr><td class="lines"><pre class="fssnip"><span class="l">1: </span>
</pre></td>
<td class="snippet"><pre class="fssnip highlighted"><code lang="csharp">Control.UseNativeMKL();
</code></pre></td></tr></table>
<p>Alternatively you can also enable it by setting the environment variable <code>MathNetNumericsLAProvider=MKL</code>.</p>
<p>You can also explicitly disable the MKL provider by forcing it to use the managed provider by calling:</p>
<table class="pre"><tr><td class="lines"><pre class="fssnip"><span class="l">1: </span>
</pre></td>
<td class="snippet"><pre class="fssnip highlighted"><code lang="csharp">Control.UseManaged();
</code></pre></td></tr></table>
<p>You can tell what provider is effectively loaded by calling <code>Control.LinearAlgebraProvider.ToString()</code>,
which will return something along the lines of <code>Intel MKL (x86; revision 7)</code>.</p>
<h2><a name="Native-Binaries" class="anchor" href="#Native-Binaries">Native Binaries</a></h2>
<p>In .Net, the fusion engine is responsible for finding referenced
assemblies in the file system and loading them into the executing process.
However, native binaries like our MKL provider are platform specific,
so we need to load them with services of the platform instead of the .Net runtime.
We use P/Invoke to talk to the binaries, but for this to work they must
have already been loaded or the platform service needs to be able to find and
load them on its own.</p>
<p>In order to make providers easier to use, since v3.6.0 Math.NET Numerics
first tries to load native providers from a set of known directories before
falling back to the platform's default behavior. In each of these directories
it first looks for a processor-architecture specific folder within the directory,
before looking at the directory itself:</p>
<ol>
<li>If <code>Control.NativeProviderPath</code> is set: <code>{NativeProviderPath}/{Platform}/</code></li>
<li>If <code>Control.NativeProviderPath</code> is set: <code>{NativeProviderPath}/</code></li>
<li><code>{AppDomain.BaseDirectory}/{Platform}/</code></li>
<li><code>{AppDomain.BaseDirectory}/</code></li>
<li><code>{ExecutingAssemblyPath}/{Platform}/</code></li>
<li><code>{ExecutingAssemblyPath}/</code></li>
<li>Fall back to the platform's default behavior (see below)</li>
</ol>
<p>Where <code>{Platform}</code> can be one of the following: <code>x86</code>, <code>x64</code>, <code>ia64</code>, <code>arm</code> or <code>arm64</code>.</p>
<p>This means that you can, for example, place the 32 bit MKL provider binaries into <code>C:\MKL\x86</code>
and the 64 bit ones into <code>C:\MKL\x64</code>, and then set <code>Control.NativeProviderPath = @"C:\MKL";</code>.
Numerics will automatically choose the right one depending on whether your process is
running in 32 or 64 bit mode, and there is no more need to copy the large binaries to the
output folder of every script or project.</p>
<h2><a name="Default-Behavior-on-Windows" class="anchor" href="#Default-Behavior-on-Windows">Default Behavior on Windows</a></h2>
<p>On Windows it is usually enough to make sure the native libraries are in the
same folder as the executable. Reference the appropriate NuGet package and set
"Copy to Output Directory" for both MathNet.Numerics.MKL.dll and libiomp5md.dll
to "Copy always", or place the two native DLLs manually into the same directory
as your application's executable. There is no need to set the native provider
path explicitly.</p>
<p>For more details how the platform default behavior works and what influences it,
see <a href="https://msdn.microsoft.com/en-us/library/windows/desktop/ms682586.aspx">Dynamic-Link Library Search Order</a>.</p>
<h2><a name="Default-Behavior-on-Linux" class="anchor" href="#Default-Behavior-on-Linux">Default Behavior on Linux</a></h2>
<p>Native assembly resolving is very different on Linux than on Windows, simply putting the native
libraries into the same folder as the executable is not enough. The safe way is to edit <code>/etc/ld.so.conf</code>
and use <code>ldconfig</code> to tell where to look for the libraries. Alternatively you could add the path
to <code>LD_LIBRARY_PATH</code> or even just copy them to <code>/usr/lib</code>.</p>
<p>For details see Mono's <a href="http://www.mono-project.com/docs/advanced/pinvoke/#linux-shared-library-search-path">Interop with Native Libraries</a>.</p>
<h2><a name="Default-Behavior-on-Mac-OS-X" class="anchor" href="#Default-Behavior-on-Mac-OS-X">Default Behavior on Mac OS X</a></h2>
<p>You can configure the search path on one of the environment variables like <code>DYLD_LIBRARY_PATH</code>
or just copy them e.g. to <code>/usr/lib</code>.</p>
<p>For details see Mono's <a href="http://www.mono-project.com/docs/advanced/pinvoke/#mac-os-x-framework-and-dylib-search-path">Interop with Native Libraries</a>.</p>
<p>To build the MKL native provider for OSX:</p>
<ol>
<li>
Make sure you've a valid <a href="https://software.intel.com/en-us/qualify-for-free-software/academicresearcher">Intel MKL</a> licence installed on your mac (look at opt/intel).
If not, you can get a free trial on intel's web site.
</li>
<li>Open the terminal</li>
<li>cd to the folder mathnet-numerics/src/NativeProviders/OSX</li>
<li>Run the .sh script by typing sh mkl_build.sh</li>
<li>... wait for the build</li>
</ol>
<table class="pre"><tr><td class="lines"><pre class="fssnip"><span class="l">1: </span>
<span class="l">2: </span>
<span class="l">3: </span>
<span class="l">4: </span>
</pre></td>
<td class="snippet"><pre class="fssnip"><code lang="sh">lionel:~ Lionel$ cd /Users/Lionel/Public/Git/GitHub/mathnet-numerics/src/NativeProviders/OSX
lionel:OSX Lionel$ ls
mkl_build.sh
lionel:OSX Lionel$ sh mkl_build.sh
</code></pre></td></tr></table>
<p>Check the /x86 and /x64 folders in mathnet-numerics/out/MKL: you should now find the <code>libiomp5.dylib</code> and <code>MathNet.Numerics.MKL.dll</code> libaries.
You need to add the path to the generated libraries in your <code>DYLD_LIBRARY_PATH</code> environment variable (which you can move to the folder of you choice before).
To do that, open your /Users/Lionel/.bas_profile.sh file with a text editor and add the following statements.</p>
<table class="pre"><tr><td class="lines"><pre class="fssnip"><span class="l">1: </span>
<span class="l">2: </span>
</pre></td>
<td class="snippet"><pre class="fssnip"><code lang="sh">export DYLD_LIBRARY_PATH=$DYLD_LIBRARY_PATH:/Users/Lionel/../mathnet-numerics/out/MKL/OSX/x64
export DYLD_LIBRARY_PATH=$DYLD_LIBRARY_PATH:/Users/Lionel/../mathnet-numerics/out/MKL/OSX/x86
</code></pre></td></tr></table>
<p>Of course replace <code>Lionel</code> by your account login.</p>
<p>Have a look a the example down this page to compare MKL-provider vs. managed-provider performances.</p>
<h2><a name="F-Interactive" class="anchor" href="#F-Interactive">F# Interactive</a></h2>
<p>In F# Interactive, the easiest way to use native providers is to copy them to a shared
directory somewhere and use them directly from there:</p>
<table class="pre"><tr><td class="lines"><pre class="fssnip"><span class="l">1: </span>
<span class="l">2: </span>
</pre></td>
<td class="snippet"><pre class="fssnip highlighted"><code lang="fsharp"><span class="i">Control</span><span class="o">.</span><span class="i">NativeProviderPath</span> <span class="o">&lt;-</span> <span class="s">@&quot;C:\MKL&quot;</span>
<span class="i">Control</span><span class="o">.</span><span class="i">UseNativeMKL</span>()
</code></pre></td>
</tr>
</table>
<p>If you are using the F# Power Tools in VisualStudio, you can also let it generate "Reference
scripts for F# Interactive" right from the context menu. This will generate a script called
<code>load-references.fsx</code> in a <code>Scripts</code> folder, which you can extend as follows to load the
MKL provider automatically.</p>
<table class="pre"><tr><td class="lines"><pre class="fssnip"><span class="l">1: </span>
<span class="l">2: </span>
<span class="l">3: </span>
<span class="l">4: </span>
<span class="l">5: </span>
</pre></td>
<td class="snippet"><pre class="fssnip highlighted"><code lang="fsharp"><span class="k">open</span> <span class="i">System</span><span class="o">.</span><span class="i">IO</span>
<span class="k">open</span> <span class="i">MathNet</span><span class="o">.</span><span class="i">Numerics</span>
<span class="i">Control</span><span class="o">.</span><span class="i">NativeProviderPath</span> <span class="o">&lt;-</span> <span class="i">Path</span><span class="o">.</span><span class="i">Combine</span>(<span class="k">__SOURCE_DIRECTORY__</span>,<span class="s">&quot;../&quot;</span>)
<span class="i">Control</span><span class="o">.</span><span class="i">UseNativeMKL</span>()
</code></pre></td>
</tr>
</table>
<p>This script assumes that the MKL binaries have been copied to the project directory,
which is also where the NuGet packages place them by default. If you place them somewhere
else, adapt the path accordingly.</p>
<p>See also <a href="http://christoph.ruegg.name/blog/loading-native-dlls-in-fsharp-interactive.html">Loading Native DLLs in F# Interactive</a>
for more alternatives.</p>
<h2><a name="LINQPad-and-assembly-shadowing" class="anchor" href="#LINQPad-and-assembly-shadowing">LINQPad and assembly shadowing</a></h2>
<p>The automatic strategy may still work if assembly shadowing is involved,
but it often simpler and more reliable to provide the folder explicitly.
This also works well in LINQPad, with and without assembly shadowing:</p>
<table class="pre"><tr><td class="lines"><pre class="fssnip"><span class="l">1: </span>
<span class="l">2: </span>
</pre></td>
<td class="snippet"><pre class="fssnip highlighted"><code lang="csharp">Control.NativeProviderPath <span class="o">=</span> <span class="s">@"C:\MKL"</span>;
Control.UseNativeMKL();
</code></pre></td></tr></table>
<h2><a name="Example-Intel-MKL-on-Linux-with-Mono" class="anchor" href="#Example-Intel-MKL-on-Linux-with-Mono">Example: Intel MKL on Linux with Mono</a></h2>
<p>We also provide MKL NuGet package for Linux if you do not want to build them yourself. Assuming you have
Mono and NuGet installed (here v3.2.8), you can fetch the MKL package of the right architecture
(x64 or x86, <code>uname -m</code> if you don't know) as usual:</p>
<table class="pre"><tr><td class="lines"><pre class="fssnip"><span class="l">1: </span>
<span class="l">2: </span>
</pre></td>
<td class="snippet"><pre class="fssnip"><code lang="sh">mono nuget.exe install MathNet.Numerics -Pre -OutputDirectory packages
mono nuget.exe install MathNet.Numerics.MKL.Linux-x64 -Pre -OutputDirectory packages
</code></pre></td></tr></table>
<p>Native assembly resolving is very different on Linux than on Windows, simply putting the native
libraries into the same folder as the executable is not enough. The safe way is to edit <code>/etc/ld.so.conf</code>
and use <code>ldconfig</code> to tell where to look for the libraries, but for now we'll just copy them to <code>/usr/lib</code>:</p>
<table class="pre"><tr><td class="lines"><pre class="fssnip"><span class="l">1: </span>
<span class="l">2: </span>
</pre></td>
<td class="snippet"><pre class="fssnip"><code lang="sh">sudo cp packages/MathNet.Numerics.MKL.Linux-x64.1.3.0/content/libiomp5.so /usr/lib/
sudo cp packages/MathNet.Numerics.MKL.Linux-x64.1.3.0/content/MathNet.Numerics.MKL.dll /usr/lib/
</code></pre></td></tr></table>
<p>Then we're all set and can just call <code>Control.UseNativeMKL()</code> if we want to use the native provider.
Let's create the following C# file <code>Example.cs</code>:</p>
<table class="pre"><tr><td class="lines"><pre class="fssnip"><span class="l"> 1: </span>
<span class="l"> 2: </span>
<span class="l"> 3: </span>
<span class="l"> 4: </span>
<span class="l"> 5: </span>
<span class="l"> 6: </span>
<span class="l"> 7: </span>
<span class="l"> 8: </span>
<span class="l"> 9: </span>
<span class="l">10: </span>
<span class="l">11: </span>
<span class="l">12: </span>
<span class="l">13: </span>
<span class="l">14: </span>
<span class="l">15: </span>
<span class="l">16: </span>
<span class="l">17: </span>
<span class="l">18: </span>
<span class="l">19: </span>
<span class="l">20: </span>
<span class="l">21: </span>
<span class="l">22: </span>
<span class="l">23: </span>
<span class="l">24: </span>
<span class="l">25: </span>
<span class="l">26: </span>
<span class="l">27: </span>
<span class="l">28: </span>
<span class="l">29: </span>
<span class="l">30: </span>
<span class="l">31: </span>
</pre></td>
<td class="snippet"><pre class="fssnip highlighted"><code lang="csharp"><span class="k">using</span> System;
<span class="k">using</span> System.Diagnostics;
<span class="k">using</span> MathNet.Numerics;
<span class="k">using</span> MathNet.Numerics.LinearAlgebra;
<span class="k">class</span> Program
{
<span class="k">static</span> <span class="k">void</span> Main(<span class="k">string</span>[] args)
{
<span class="c">// Using managed code only</span>
Control.UseManaged();
Console.WriteLine(Control.LinearAlgebraProvider);
<span class="k">var</span> m <span class="o">=</span> Matrix&lt;<span class="k">double</span>&gt;.Build.Random(<span class="n">500</span>, <span class="n">500</span>);
<span class="k">var</span> v <span class="o">=</span> Vector&lt;<span class="k">double</span>&gt;.Build.Random(<span class="n">500</span>);
<span class="k">var</span> w <span class="o">=</span> Stopwatch.StartNew();
<span class="k">var</span> y<span class="n">1</span> <span class="o">=</span> m.Solve(v);
Console.WriteLine(w.Elapsed);
Console.WriteLine(y<span class="n">1</span>);
<span class="c">// Using the Intel MKL native provider</span>
Control.UseNativeMKL();
Console.WriteLine(Control.LinearAlgebraProvider);
w.Restart();
<span class="k">var</span> y<span class="n">2</span> <span class="o">=</span> m.Solve(v);
Console.WriteLine(w.Elapsed);
Console.WriteLine(y<span class="n">2</span>);
}
}
</code></pre></td></tr></table>
<p>Compile and run:</p>
<table class="pre"><tr><td class="lines"><pre class="fssnip"><span class="l">1: </span>
<span class="l">2: </span>
<span class="l">3: </span>
<span class="l">4: </span>
<span class="l">5: </span>
</pre></td>
<td class="snippet"><pre class="fssnip"><code lang="sh"># single line:
mcs -optimize -lib:packages/MathNet.Numerics.3.0.0-alpha8/lib/net40/
-r:MathNet.Numerics.dll Example.cs -out:Example
# launch:
mono Example
</code></pre></td></tr></table>
<h2><a name="Licensing-Restrictions" class="anchor" href="#Licensing-Restrictions">Licensing Restrictions</a></h2>
<p>Be aware that unlike the core of Math.NET Numerics including the native wrapper, which are both
open source under the terms of the MIT/X11 license, the Intel MKL binaries themselves are closed
source and non-free.</p>
<p>The Math.NET Numerics project does own an Intel MKL license (for Windows, no longer for Linux) and
thus does have the right to distribute it along Math.NET Numerics. You can therefore use the Math.NET
Numerics MKL native provider for free for your own use. However, it does <em>not</em> give you any right to
redistribute it again yourself to customers of your own product. <strong>If you need to redistribute,
buy a license from Intel. If unsure, contact the Intel sales team to clarify.</strong></p>
</div>
<div class="span3">
<ul class="nav nav-list" id="menu">
<li class="nav-header">Math.NET Numerics</li>
<li><a href="https://numerics.mathdotnet.com/Packages.html">NuGet & Binaries</a></li>
<li><a href="https://numerics.mathdotnet.com/ReleaseNotes.html">Release Notes</a></li>
<li><a href="https://numerics.mathdotnet.com/License.html">MIT/X11 License</a></li>
<li><a href="https://numerics.mathdotnet.com/Compatibility.html">Platform Support</a></li>
<li><a href="https://numerics.mathdotnet.com/api/">Class Reference</a></li>
<li><a href="https://github.com/mathnet/mathnet-numerics/issues">Issues & Bugs</a></li>
<li><a href="https://numerics.mathdotnet.com/Users.html">Who is using Math.NET?</a></li>
<li class="nav-header">Contributing</li>
<li><a href="https://numerics.mathdotnet.com/Contributors.html">Contributors</a></li>
<li><a href="https://numerics.mathdotnet.com/Contributing.html">Contributing</a></li>
<li><a href="https://numerics.mathdotnet.com/Build.html">Build & Tools</a></li>
<li><a href="http://feedback.mathdotnet.com/forums/2060-math-net-numerics">Your Ideas</a></li>
<li class="nav-header">Getting Help</li>
<li><a href="https://discuss.mathdotnet.com/c/numerics">Discuss</a></li>
<li><a href="https://stackoverflow.com/questions/tagged/mathdotnet">Stack Overflow</a></li>
<li class="nav-header">Getting Started</li>
<li><a href="https://numerics.mathdotnet.com/">Getting started</a></li>
<li><a href="https://numerics.mathdotnet.com/Constants.html">Constants</a></li>
<li>Floating-Point Numbers</li>
<li>Arbitrary Precision Numbers</li>
<li>Complex Numbers</li>
<li><a href="https://numerics.mathdotnet.com/Matrix.html">Matrices and Vectors</a></li>
<li><a href="https://numerics.mathdotnet.com/Euclid.html">Euclid & Number Theory</a></li>
<li>Combinatorics</li>
<li class="nav-header">Evaluation</li>
<li><a href="https://numerics.mathdotnet.com/Functions.html">Special Functions</a></li>
<li>Differentiation</li>
<li><a href="https://numerics.mathdotnet.com/Integration.html">Integration</a></li>
<li class="nav-header">Statistics/Probability</li>
<li><a href="https://numerics.mathdotnet.com/DescriptiveStatistics.html">Descriptive Statistics</a></li>
<li><a href="https://numerics.mathdotnet.com/Probability.html">Probability Distributions</a></li>
<li class="nav-header">Generation</li>
<li><a href="https://numerics.mathdotnet.com/Generate.html">Generating Data</a></li>
<li><a href="https://numerics.mathdotnet.com/Random.html">Random Numbers</a></li>
<li class="nav-header">Transformation</li>
<li>Fourier Transform (FFT)</li>
<li>Filtering & DSP</li>
<li>Window Functions</li>
<li class="nav-header">Solving Equations</li>
<li><a href="https://numerics.mathdotnet.com/LinearEquations.html">Linear Equation Systems</a></li>
<li>Nonlinear Root Finding</li>
<li class="nav-header">Optimization</li>
<li>Linear Least Squares</li>
<li>Nonlinear Optimization</li>
<li><a href="https://numerics.mathdotnet.com/Distance.html">Distance Metrics</a></li>
<li class="nav-header">Curve Fitting</li>
<li><a href="https://numerics.mathdotnet.com/Regression.html">Regression</a></li>
<li>Interpolation</li>
<li>Fourier Approximation</li>
<li class="nav-header">Native Providers</li>
<li><a href="https://numerics.mathdotnet.com/MKL.html">Intel MKL</a></li>
<li class="nav-header">Working Together</li>
<li><a href="https://numerics.mathdotnet.com/CSV.html">Delimited Text Files (CSV)</a></li>
<li><a href="https://numerics.mathdotnet.com/MatrixMarket.html">NIST MatrixMarket</a></li>
<li><a href="https://numerics.mathdotnet.com/MatlabFiles.html">MATLAB</a></li>
<li><a href="https://numerics.mathdotnet.com/IFSharpNotebook.html">IF# Notebook</a></li>
<li>FsLab & Deedle</li>
<li>Microsoft Excel</li>
<li>numl.net machine learning</li>
<li>R-project</li>
</ul>
</div>
</div>
</div>
</body>
</html>