<?xml version="1.0" encoding="UTF-8"?>
<!-- Generated on Fri, 10 Feb 2012 05:23:51 -0800 -->
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
  <channel>
    <atom:link href="http://software.intel.com/en-us/articles/intel-fortran-compiler-for-mac-os-x-kb/type/tips-and-techniques/feed/" rel="self" type="application/rss+xml" />
    <title>Intel Software Network articles Feed</title>
    <link>http://software.intel.com/en-us/articles/intel-fortran-compiler-for-mac-os-x-kb/type/tips-and-techniques/</link>
    <description></description>
    <language>en-us</language>
    <item>
      <title>Using the IDB Debugger under Mac OS* X 10.7 Lion</title>
      <description><![CDATA[ <br />
<div id="art_pre_template"><b>Reference Number : </b>DPD200178014<br /><br /><br /><b>Version : </b>IDB for Mac OS* X 10.7 Lion, v12.1 ( Updates 6, 7, 8, and possible future updates)<br /><br /><br /><b>Product : </b>Composer XE 2011 for Mac OS* X<br /><br /><br /><b>Operating System : </b>Mac OS* X 10.7<br /><br /><br /><b>Problem Description : </b>IDB debugger does not load default images produced by IFORT or ICC/ICPC: <b><br />"Could not start process for ...<br />No image loaded ... Recovering ... "<br /></b><br /><br /><br /><b>Resolution Status : </b><br /><br />Mac OS* X Lion, by default, defaults to building executables with Position Independent Executable (PIE) code.  However, the Intel IDB debugger does not currently (as of Composer XE 2011 Updates 6, 7, 8, and 9) support debugging of PIE executables.  <br /><br />To work around this, IFORT and ICC/ICPC can be directed to produce non-PIE executables.  The following options are required to produce an executable that IDB can process:<br /><br /><b>-g -save-temps -fpic -Wl,-no_pie</b><br /><br />This affects the Intel Composer XE 2011 compilers running on Mac OS* X 10.7 Lion ONLY.  Users of Mac OS* X 10.6 (Snow Leopard) or 10.5 (Leopard) are not affected and need only the -g -save-temps options for creation of debuggable executables.<br /><br /><br /><br /><i>[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.]</i></div> ]]></description>
      <link>http://software.intel.com/en-us/articles/using-the-idb-debugger-under-mac-os-x-107-lion/</link>
      <pubDate>Sun, 15 Jan 2012 23:00:00 -0800</pubDate>
      <comments>http://software.intel.com/en-us/articles/using-the-idb-debugger-under-mac-os-x-107-lion/#comments</comments>
      <guid isPermaLink="true">http://software.intel.com/en-us/articles/using-the-idb-debugger-under-mac-os-x-107-lion/</guid>
      <category>Intel® C++ Compiler for Mac OS X* Knowledge Base</category>
      <category>Intel® Fortran Compiler for Mac OS X* Knowledge Base</category>
    </item>
    <item>
      <title>Mac OS X tip, How to make /opt visible in Finder</title>
      <description><![CDATA[ <br />
<div id="art_pre_template"><b>Introduction : </b>Intel Developer Products tools such as compilers and libraries install by default in folder /opt.  Unfortunately, by default Finder on many versions of Mac OS X hides the /opt folder, that is, it does not show the /opt folder and subdirectories by default.  <br /><br />This can be annoying because Intel installs the HTML documentation along with the product under /opt/intel/...<b></b><br /><br /><b>Making /opt Visible in Finder: </b><br /><br />The following command will make /opt and it's subfolders visible and navigateable under Finder:<br /><br />sudo SetFile  -a  v  /opt<br /><br />After this, open or re-open a Finder window and /opt and it's subfolders should be visible under Finder.  This allows one to quickly navigate the Documentation folder for your Intel product.<br /><br /><b></b><br /><br /><br /></div> ]]></description>
      <link>http://software.intel.com/en-us/articles/mac-os-x-tip-how-to-make-opt-visible-in-finder/</link>
      <pubDate>Sun, 22 May 2011 23:00:00 -0700</pubDate>
      <comments>http://software.intel.com/en-us/articles/mac-os-x-tip-how-to-make-opt-visible-in-finder/#comments</comments>
      <guid isPermaLink="true">http://software.intel.com/en-us/articles/mac-os-x-tip-how-to-make-opt-visible-in-finder/</guid>
      <category>ISN General</category>
      <category>Intel® TBB</category>
      <category>Intel® C++ Compiler for Mac OS X* Knowledge Base</category>
      <category>Intel® Fortran Compiler for Mac OS X* Knowledge Base</category>
    </item>
    <item>
      <title>Description of PARDISO errors and messages</title>
      <description><![CDATA[ <p class="MsoNormal"><span lang="EN-US" >See the table below for the description of the error indicator.<o:p></o:p></span></p>
<p class="MsoNormal"><span lang="EN-US" ><o:p></o:p></span></p>
<table cellpadding="0" cellspacing="0" border="1" class="MsoTableGrid" >
<tbody>
<tr >
<td width="111" valign="top" >
<p class="MsoNormal"><b><i><span lang="EN-US" >Error </span></i></b><i><span lang="EN-US" >( Integer)</span></i><span lang="EN-US" ><o:p></o:p></span></p>
</td>
<td width="527" valign="top" >
<p class="MsoNormal"><b><span lang="EN-US" >Information</span></b><span lang="EN-US" ><o:p></o:p></span></p>
</td>
</tr>
<tr >
<td width="111" valign="top" >
<p class="MsoNormal"><span lang="EN-US" >0</span><span lang="EN-US" ><o:p></o:p></span></p>
</td>
<td width="527" valign="top" >
<p class="MsoNormal"><span lang="EN-US" >no error</span><span lang="EN-US" ><o:p></o:p></span></p>
</td>
</tr>
<tr >
<td width="111" valign="top" >
<p class="MsoNormal"><span lang="EN-US" >-1</span><span lang="EN-US" ><o:p></o:p></span></p>
</td>
<td width="527" valign="top" >
<p class="MsoNormal"><span lang="EN-US" >input inconsistency<o:p></o:p></span></p>
</td>
</tr>
<tr >
<td width="111" valign="top" >
<p class="MsoNormal"><span lang="EN-US" >-2</span><span lang="EN-US" ><o:p></o:p></span></p>
</td>
<td width="527" valign="top" >
<p class="MsoNormal"><span lang="EN-US" >not enough memory<o:p></o:p></span></p>
</td>
</tr>
<tr >
<td width="111" valign="top" >
<p class="MsoNormal"><span lang="EN-US" >-3</span><span lang="EN-US" ><o:p></o:p></span></p>
</td>
<td width="527" valign="top" >
<p class="MsoNormal"><span lang="EN-US" >reordering problem<o:p></o:p></span></p>
</td>
</tr>
<tr >
<td width="111" valign="top" >
<p class="MsoNormal"><span lang="EN-US" >-4<o:p></o:p></span></p>
</td>
<td width="527" valign="top" >
<p class="MsoNormal"><span lang="EN-US" >zero pivot, numerical factorization or<o:p></o:p></span></p>
<p class="MsoNormal"><span lang="EN-US" >iterative refinement problem</span><span lang="EN-US" ><o:p></o:p></span></p>
</td>
</tr>
<tr >
<td width="111" valign="top" >
<p class="MsoNormal"><span lang="EN-US" >-5</span><span lang="EN-US" ><o:p></o:p></span></p>
</td>
<td width="527" valign="top" >
<p class="MsoNormal"><span lang="EN-US" >unclassified (internal) error<o:p></o:p></span></p>
</td>
</tr>
<tr >
<td width="111" valign="top" >
<p class="MsoNormal"><span lang="EN-US" >-6</span><span lang="EN-US" ><o:p></o:p></span></p>
</td>
<td width="527" valign="top" >
<p class="MsoNormal"><span lang="EN-US" >preordering failed (matrix types 11, 13 only)<o:p></o:p></span></p>
</td>
</tr>
<tr >
<td width="111" valign="top" >
<p class="MsoNormal"><span lang="EN-US" >-7<o:p></o:p></span></p>
</td>
<td width="527" valign="top" >
<p class="MsoNormal"><span lang="EN-US" >diagonal matrix is singular<o:p></o:p></span></p>
</td>
</tr>
<tr >
<td width="111" valign="top" >
<p class="MsoNormal"><span lang="EN-US" >-8<o:p></o:p></span></p>
</td>
<td width="527" valign="top" >
<p class="MsoNormal"><span lang="EN-US" >32-bit integer overflow problem<o:p></o:p></span></p>
</td>
</tr>
<tr >
<td width="111" valign="top" >
<p class="MsoNormal"><span lang="EN-US" >-9<o:p></o:p></span></p>
</td>
<td width="527" valign="top" >
<p class="MsoNormal"><span lang="EN-US" >not enough memory for OOC<o:p></o:p></span></p>
</td>
</tr>
<tr >
<td width="111" valign="top" >
<p class="MsoNormal"><span lang="EN-US" >-10<o:p></o:p></span></p>
</td>
<td width="527" valign="top" >
<p class="MsoNormal"><span lang="EN-US" >problems with opening OOC temporary files<o:p></o:p></span></p>
</td>
</tr>
<tr >
<td width="111" valign="top" >
<p class="MsoNormal"><span lang="EN-US" >-11<o:p></o:p></span></p>
</td>
<td width="527" valign="top" >
<p class="MsoNormal"><span lang="EN-US" >read/write problems with the OOC data file<o:p></o:p></span></p>
</td>
</tr>
</tbody>
</table>
<p class="MsoNormal"><span lang="EN-US" ><o:p></o:p></span></p>
<p class="MsoNormal"><span lang="EN-US" ><o:p></o:p></span></p>
<p class="MsoNormal"><span lang="EN-US" >Below each error is described in details:<o:p></o:p></span></p>
<p class="MsoNormal"><b><span lang="EN-US" ><o:p></o:p></span></b></p>
<p class="MsoNormal"><b ><i ><span lang="EN-US" ><span ></span>0: <span ></span></span></i></b><b ><i ><span lang="EN-US" >no error</span></i></b><b ><i ><span lang="EN-US" ><o:p></o:p></span></i></b></p>
<p class="MsoNormal"><b ><i ><span lang="EN-US" ><o:p></o:p></span></i></b></p>
<p class="MsoNormal"><b ><i ><span lang="EN-US" ><span ></span>-1: <span ></span></span></i></b><b ><i ><span lang="EN-US" >Input inconsistency</span></i></b></p>
<p class="MsoNormal"><span lang="EN-US" ><o:p></o:p></span></p>
<span >This error can appear in the following situations:</span><br />
<ul>
</ul>
<p class="MsoNormal"><span lang="EN-US" ><o:p></o:p></span></p>
<ul>
<li>
<div class="MsoListParagraphCxSpFirst"><span lang="EN-US" >Incorrect stage number for PARDISO was called.<o:p></o:p></span></div>
</li>
<li>
<div class="MsoListParagraphCxSpMiddle"><span lang="EN-US" >Incorrect PARDISO calling sequence, e.g. run stage &gt; 1 without initialization results in error reporting.<o:p></o:p></span></div>
</li>
<li><span lang="EN-US" >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 <b>1</b></span><b><samp><span lang="EN-US">≤</span></samp><span lang="EN-US" > … </span><samp><span lang="EN-US">≤</span></samp></b><span lang="EN-US" ><b>maxfct</b> results in error).</span></li>
<li>
<div class="MsoListParagraphCxSpLast"><span lang="EN-US" >PARDISO checks the parameters at each stage for consistency with the parameters at the previous stages. Every disagreement results in error reporting.<o:p></o:p></span></div>
</li>
</ul>
<p class="MsoNormal"><span lang="EN-US" ><o:p></o:p></span></p>
<p class="MsoNormal"><b ><i ><span lang="EN-US" ><span ></span></span></i></b><b ><i ><span lang="EN-US" >-2: <span ></span></span></i></b><b ><i ><span lang="EN-US" >not enough memory</span></i></b><span lang="EN-US" > <o:p></o:p></span></p>
<p class="MsoNormal"><span lang="EN-US" ><o:p></o:p></span></p>
<p class="MsoNormal"><span lang="EN-US" >This error value is returned in the case of any problem with memory allocation inside PARDISO.<o:p></o:p></span></p>
<p class="MsoNormal"><i ><span ><span lang="EN-US" >PARDISO messages:<o:p></o:p></span></span></i></p>
<p class="MsoNormal"><span lang="EN-US" ><span ></span><i >"*** Error in PARDISO memory allocation: [STRUCTURE NAME], size to allocate: %d bytes"<o:p></o:p></i></span></p>
<p class="MsoNormal"><i ><span lang="EN-US" >"total memory wanted here: %d kbyte"<o:p></o:p></span></i></p>
<p class="MsoNormal"><i ><span lang="EN-US" >"symbolic (max): %d symbolic (permanent): %d"<o:p></o:p></span></i></p>
<p class="MsoNormal"><i ><span lang="EN-US" >"real(including 1 factor): %d"<o:p></o:p></span></i></p>
<p class="MsoNormal"><i ><span lang="EN-US" ><o:p></o:p></span></i></p>
<p class="MsoNormal"><span >It describes the issue that arises on allocation of STRUCTURE_NAME inside PARDISO. A additional information about current memory usages is also printed.</span></p>
<p class="MsoNormal"><span lang="EN-US" ><o:p></o:p></span></p>
<p class="MsoNormal"><span lang="EN-US" ><o:p></o:p></span></p>
<p class="MsoNormal"><b ><i ><span lang="EN-US" ><span ></span></span></i></b><b ><i ><span lang="EN-US" >-3</span></i></b><b ><i ><span lang="EN-US" >: </span></i></b><b ><i ><span lang="EN-US" ><span ></span></span></i></b><b ><i ><span lang="EN-US" >reordering problem</span></i></b><span lang="EN-US" > <o:p></o:p></span></p>
<p class="MsoNormal"><span lang="EN-US" ><o:p></o:p></span></p>
<p class="MsoNormal"><span lang="EN-US" >Returned for any problem on a reordering stage (phase 11)<o:p></o:p></span></p>
<p class="MsoNormal"><i ><span ><span lang="EN-US" >PARDISO messages:<o:p></o:p></span></span></i></p>
<p class="MsoNormal"><span lang="EN-US" ><span ></span><i >"*** error PARDISO: reordering, symbolic factorization"<o:p></o:p></i></span></p>
<p class="MsoNormal"><span lang="EN-US" ><o:p></o:p></span></p>
<p class="MsoNormal"><b ><i ><span lang="EN-US" ><span ></span></span></i></b><b ><i ><span lang="EN-US" >-4: <span ></span></span></i></b><b ><i ><span lang="EN-US" >zero pivot, numerical factorization or iterative refinement problem</span></i></b><span lang="EN-US" > <o:p></o:p></span></p>
<p class="MsoNormal"><span lang="EN-US" ><o:p></o:p></span></p>
<p class="MsoNormal"><span lang="EN-US" >Let us start with a citation of the Intel MKL manual:<o:p></o:p></span></p>
<p class="MsoNormal"><span lang="EN-US" ><o:p></o:p></span></p>
<p class="MsoNormal"><i ><span lang="EN-US" >Using </span></i><i><span lang="EN-US" >phase </span></i><i ><span lang="EN-US" >=33 </span></i><i ><span lang="EN-US" >results in an error message (</span></i><b ><i><span lang="EN-US" >error </span></i></b><b ><i ><span lang="EN-US" >=4, should be -4 *</span></i></b><b ><i ><span lang="EN-US" > </span></i></b><i ><span lang="EN-US" >) <span ></span>if the stopping criteria for the Krylow-Subspace iteration cannot be reached. <o:p></o:p></span></i></p>
<p class="MsoNormal"><span lang="EN-US" ><o:p></o:p></span></p>
<p class="MsoNormal"><i ><span lang="EN-US" >If </span></i><i><span lang="EN-US" >phase</span></i><i ><span lang="EN-US" >= 23</span></i><i ><span lang="EN-US" >, then the factors </span></i><i><span lang="EN-US" >L</span></i><i ><span lang="EN-US" >, </span></i><i><span lang="EN-US" >U </span></i><i ><span lang="EN-US" >are recomputed for the matrix </span></i><i><span lang="EN-US" >A </span></i><i ><span lang="EN-US" >and the error flag </span></i><b ><i><span lang="EN-US" >error</span></i></b><b ><i ><span lang="EN-US" >=0 </span></i></b><i ><span lang="EN-US" >in case of a successful factorization. If </span></i><i><span lang="EN-US" >phase </span></i><i ><span lang="EN-US" >=33</span></i><i ><span lang="EN-US" >, then </span></i><b ><i><span lang="EN-US" >error </span></i></b><b ><i ><span lang="EN-US" >= -4</span></i></b><i ><span lang="EN-US" > </span></i><i ><span lang="EN-US" >signals the failure<o:p></o:p></span></i></p>
<p class="MsoNormal"><i ><span lang="EN-US" >If the solver detects a zero or negative pivot for these matrix types, the factorization is stopped, PARDISO returns immediately with an error (</span></i><b ><i><span lang="EN-US" >error </span></i></b><b ><i ><span lang="EN-US" >= -4</span></i></b><i ><span lang="EN-US" >) and </span></i><i><span lang="EN-US" >iparm</span></i><i ><span lang="EN-US" >(30) </span></i><i ><span lang="EN-US" >contains the number of the equation where the first zero or negative pivot is detected.</span></i><span lang="EN-US" ><o:p></o:p></span></p>
<p class="MsoNormal"><span lang="EN-US" ><o:p></o:p></span></p>
<p class="MsoNormal"><span lang="EN-US" >The error returned in the case of any problem at the factorization stage (phase 22) or at the iterative refinement stage of solution. <o:p></o:p></span></p>
<p class="MsoNormal"><span lang="EN-US" ><o:p></o:p></span></p>
<p class="MsoNormal"><i ><span ><span lang="EN-US" >PARDISO messages:<o:p></o:p></span></span></i></p>
<p class="MsoNormal"><i ><span lang="EN-US" >"*** Error in PARDISO: cgs error iparam(20) %d"</span></i><span lang="EN-US" > – prints iparm(20) – see CG / CGS diagnostics in the Intel MKL manual<o:p></o:p></span></p>
<p class="MsoNormal"><i ><span lang="EN-US" ><o:p></o:p></span></i></p>
<p class="MsoNormal"><i ><span lang="EN-US" >"*** error PARDISO: iterative refinement"<o:p></o:p></span></i></p>
<p class="MsoNormal"><span ><span lang="EN-US" ><i>" contraction rate is greater than 0.9, interrupt" – </i>rate of contraction is too small <i><o:p></o:p></i></span></span></p>
<p class="MsoNormal"><i ><span lang="EN-US" ><o:p></o:p></span></i></p>
<p class="MsoNormal"><i ><span lang="EN-US" >"*** error PARDISO: iterative refinement"<o:p></o:p></span></i></p>
<p class="MsoNormal"><i ><span lang="EN-US" >" exceeds max. iteration number %d"<span > </span></span></i><span lang="EN-US" >- prints abs(iparm(8))<o:p></o:p></span></p>
<p class="MsoNormal"><i ><span lang="EN-US" ><o:p></o:p></span></i></p>
<p class="MsoNormal"><i ><span lang="EN-US" >"*** Error in PARDISO: internal error, insufficient memory factorization" – </span></i><span lang="EN-US" >looks like a problem at the factorization stage except for pivoting issues (see errors below)<o:p></o:p></span></p>
<p class="MsoNormal"><i ><span lang="EN-US" ><o:p></o:p></span></i></p>
<p class="MsoNormal"><i ><span lang="EN-US" >"*** Error in PARDISO: zero or negative pivot, A is not SPD-matrix" – </span></i><span lang="EN-US" >original matrix (almost) not SPD one (probably due to computer arithmetic inaccuracies)<o:p></o:p></span></p>
<p class="MsoNormal"><i ><span lang="EN-US" ><o:p></o:p></span></i></p>
<p class="MsoNormal"><i ><span lang="EN-US" >"*** Error in PARDISO: zero pivot" – </span></i><span lang="EN-US" >the same as above but for other matrix types<i ><o:p></o:p></i></span></p>
<p class="MsoNormal"><span lang="EN-US" ><o:p></o:p></span></p>
<p class="MsoNormal"><b ><i ><span lang="EN-US" ><span ></span>-5</span></i></b><b ><i ><span lang="EN-US" >: </span></i></b><b ><i ><span lang="EN-US" ><span ></span></span></i></b><b ><i ><span lang="EN-US" >unclassified (internal) error</span></i></b><b ><i ><span lang="EN-US" ><o:p></o:p></span></i></b></p>
<p class="MsoNormal"><span lang="EN-US" ><o:p></o:p></span></p>
<p class="MsoNormal"><span lang="EN-US" >This error value is not used currently and is reserved for the future use.<o:p></o:p></span></p>
<p class="MsoNormal"><span lang="EN-US" ><o:p></o:p></span></p>
<p class="MsoNormal"><b ><i ><span lang="EN-US" ><span ></span></span></i></b><b ><i ><span lang="EN-US" >-6: <span ></span></span></i></b><b ><i ><span lang="EN-US" >preordering failed (matrix types 11, 13 only)</span></i></b><span lang="EN-US" > <o:p></o:p></span></p>
<p class="MsoNormal"><span lang="EN-US" ><o:p></o:p></span></p>
<p class="MsoNormal"><span lang="EN-US" >This error value is returned in the case of any problem at the stage of preparation for reordering (in matching algorithm).<o:p></o:p></span></p>
<p class="MsoNormal"><span lang="EN-US" ><o:p></o:p></span></p>
<p class="MsoNormal"><i ><span ><span lang="EN-US" >PARDISO messages:<o:p></o:p></span></span></i></p>
<p class="MsoNormal"><span lang="EN-US" ><span ></span><i >"*** Error in PARDISO: preordering failed after %d neqns out of %d"<o:p></o:p></i></span></p>
<p class="MsoNormal"><i ><span lang="EN-US" >"structure singular or input/parameter problem (matrix type 11,13)"<o:p></o:p></span></i></p>
<p class="MsoNormal"><span lang="EN-US" ><o:p></o:p></span></p>
<p class="MsoNormal"><span lang="EN-US" >Looks like the message provides no meaningful information.<o:p></o:p></span></p>
<p class="MsoNormal"><span lang="EN-US" ><o:p></o:p></span></p>
<p class="MsoNormal"><b ><i ><span lang="EN-US" ><span ></span>-7: <span ></span></span></i></b><b ><i ><span lang="EN-US" >diagonal matrix problem</span></i></b><span lang="EN-US" > <o:p></o:p></span></p>
<p class="MsoNormal"><span lang="EN-US" ><o:p></o:p></span></p>
<p class="MsoNormal"><span lang="EN-US" >PARDISO prints no messages. <o:p></o:p></span></p>
<p class="MsoNormal"><span lang="EN-US" ><o:p></o:p></span></p>
<p class="MsoNormal"><b ><i ><span lang="EN-US" ><span ></span></span></i></b><b ><i ><span lang="EN-US" >-8: <span ></span></span></i></b><b ><i ><span lang="EN-US" >32-bit integer overflow problem</span></i></b><span lang="EN-US" > <o:p></o:p></span></p>
<p class="MsoNormal"><span lang="EN-US" ><o:p></o:p></span></p>
<p class="MsoNormal"><span lang="EN-US" >This error value is returned on 32-bit architecture for big matrices when indices become greater than the maximal integer value on this platform. <o:p></o:p></span></p>
<p class="MsoNormal"><span lang="EN-US" ><o:p></o:p></span></p>
<p class="MsoNormal"><i ><span ><span lang="EN-US" >PARDISO messages:<o:p></o:p></span></span></i></p>
<p class="MsoNormal"><span lang="EN-US" ><span ></span><i >"*** error PARDISO: reordering, symbolic factorization"</i><o:p></o:p></span></p>
<p class="MsoNormal"><span lang="EN-US" ><o:p></o:p></span></p>
<p class="MsoNormal"><b ><i ><span lang="EN-US" >-9: </span></i></b><b ><i ><span lang="EN-US" >not enough memory for OOC</span></i></b><span lang="EN-US" > <o:p></o:p></span></p>
<p class="MsoNormal"><span lang="EN-US" ><o:p></o:p></span></p>
<p class="MsoNormal"><span lang="EN-US" >Let us start with a citation of the Intel MKL manual:<o:p></o:p></span></p>
<p class="MsoNormal"><span lang="EN-US" ><o:p></o:p></span></p>
<p class="MsoNormal"><i ><span lang="EN-US" >Note that if </span></i><i><span lang="EN-US" >iparm</span></i><i ><span lang="EN-US" >(60) </span></i><i ><span lang="EN-US" >is equal to 1 or 2, and the total peak memory needed for strong local arrays is more than </span></i><i ><span lang="EN-US" >MKL_PARDISO_OOC_MAX_CORE_SIZE</span></i><i ><span lang="EN-US" >, the program stops with <b >error -9</b>. In this case, increase of </span></i><i ><span lang="EN-US" >MKL_PARDISO_OOC_MAX_CORE_SIZE </span></i><i ><span lang="EN-US" >is recommended.</span></i><i ><span lang="EN-US" ><o:p></o:p></span></i></p>
<p class="MsoNormal"><span lang="EN-US" ><o:p></o:p></span></p>
<p class="MsoNormal"><span lang="EN-US" >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.<o:p></o:p></span></p>
<p class="MsoNormal"><span lang="EN-US" ><o:p></o:p></span></p>
<p class="MsoNormal"><b ><i ><span lang="EN-US" >-10: </span></i></b><b ><i ><span lang="EN-US" >problems with opening OOC temporary files</span></i></b><span lang="EN-US" > <o:p></o:p></span></p>
<p class="MsoNormal"><span lang="EN-US" ><o:p></o:p></span></p>
<p class="MsoNormal"><span lang="EN-US" >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.<o:p></o:p></span></p>
<p class="MsoNormal"><span lang="EN-US" ><o:p></o:p></span></p>
<p class="MsoNormal"><b ><i ><span lang="EN-US" >-11: </span></i></b><b ><i ><span lang="EN-US" >read/write problems with the OOC data file</span></i></b><b ><i ><span lang="EN-US" ><o:p></o:p></span></i></b></p>
<p class="MsoNormal"><span lang="EN-US" ><o:p></o:p></span></p>
<p class="MsoNormal"><span lang="EN-US" ><o:p></o:p></span></p>
<p class="MsoNormal"><span lang="EN-US" >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. <o:p></o:p></span></p>
<p class="MsoNormal"><span lang="EN-US" ><o:p></o:p></span></p>
<p class="MsoNormal"><i><span lang="EN-US" >* - the documentation error. Will be fixed in the version 10.3 Update3.</span></i><span lang="EN-US" ><o:p></o:p></span></p>
<p class="MsoNormal"><i><span lang="EN-US" >** - available memory means the RAM system's memory which is available at the moment of starting the calculations</span></i><i><span lang="EN-US" >.</span></i><span lang="EN-US" ><o:p></o:p></span></p>
<p class="MsoNormal"><span lang="EN-US" ><o:p></o:p></span></p> ]]></description>
      <link>http://software.intel.com/en-us/articles/description-of-pardiso-errors-and-messages/</link>
      <pubDate>Fri, 14 Jan 2011 11:30:00 -0800</pubDate>
      <comments>http://software.intel.com/en-us/articles/description-of-pardiso-errors-and-messages/#comments</comments>
      <guid isPermaLink="true">http://software.intel.com/en-us/articles/description-of-pardiso-errors-and-messages/</guid>
      <category>Intel® C++ Compiler for Linux* Knowledge Base</category>
      <category>Intel® C++ Compiler for Mac OS X* Knowledge Base</category>
      <category>Intel® C++ Compiler for Windows* Knowledge Base</category>
      <category>Intel® Fortran Compiler for Linux* Knowledge Base</category>
      <category>Intel® Fortran Compiler for Mac OS X* Knowledge Base</category>
      <category>Intel® Math Kernel Library Knowledge Base</category>
    </item>
    <item>
      <title>Don&amp;#39;t optimize when using -ftrapuv for uninitialized variable detection</title>
      <description><![CDATA[ <br />
<div id="art_pre_template"><strong>Reference Number :</strong> dpd200139115,  dpd200138937  (documentation).<br /><br /><br /><strong>Version :</strong> 2011, (compiler version 12);  compiler pro versions 10 and 11 <br /><br /><br /><strong>Product : </strong>Intel(R) Composer XE; Intel(R) Compiler Pro<br /><br /><br /><strong>Operating System :</strong> Windows*, Linux*, Mac OS* X<br /><br /><b>Problem Description : </b><br />If the switch /Qftrapuv (-ftrapuv) for run-time detection of uninitialized local scalar variables is used in conjunction with optimization flags such as /O2 (-O2), it may lead to unexpected floating-point exceptions that are not related to uninitialized variables.<br /><br /><b>Explanation : </b><br />The switch /Qftrapuv (-ftrapuv)  sets local, scalar variables that are not otherwise initialized to an "unusual" initial value such as 0xCCCCCCCC. When the main program is compiled with this switch, it also unmasks the "INVALID" floating-point exception. so that exceptions may be raised when the "unusual" values are used in floating-point operations. The switch also changes the default optimization level from /O2 to /Od (from -O2 to -O0). This is so that exceptions will not be raised as a result of speculated floating-point operations or other optimizations. If the new default optimization level of /Od (-O0) is explicitly overridden, optimizations such as floating-point speculation associated with masked vector operations may result in INVALID exceptions that would not otherwise have been raised.<br /><br /><br /><strong>Solution</strong>:<br /><strong>Either</strong>:  Do not override the default /Od (-O0) optimization level when using /Qtrapuv (-ftrapuv).   (Sometimes, it may be sufficient to use /Qfp-speculation:safe (-fp-speculation safe) in conjunction with -O2).<br /><strong>or (Fortran only)</strong>:   Use the switch /check:uninit (-check uninit)  in preference to /Qtrapuv (-ftrapuv) for the run-time detection of uninitialized, local scalar variables. This uses a different mechanism for uninitialized variable detection that is less likely to produce unrelated floating-point exceptions.<br /><br />Intel(R) Inspector XE, a component of Intel(R) Parallel Studio XE,  may also be used for the detection of some instances of uninitialized variables.<br /><br /><br /><br /><i>[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.]</i></div> ]]></description>
      <link>http://software.intel.com/en-us/articles/dont-optimize-when-using-ftrapuv-for-uninitialized-variable-detection/</link>
      <pubDate>Wed, 22 Dec 2010 21:00:00 -0800</pubDate>
      <comments>http://software.intel.com/en-us/articles/dont-optimize-when-using-ftrapuv-for-uninitialized-variable-detection/#comments</comments>
      <guid isPermaLink="true">http://software.intel.com/en-us/articles/dont-optimize-when-using-ftrapuv-for-uninitialized-variable-detection/</guid>
      <category>Intel® C++ Compiler for Linux* Knowledge Base</category>
      <category>Intel® C++ Compiler for Mac OS X* Knowledge Base</category>
      <category>Intel® C++ Compiler for Windows* Knowledge Base</category>
      <category>Intel® Fortran Compiler for Linux* Knowledge Base</category>
      <category>Intel® Fortran Compiler for Mac OS X* Knowledge Base</category>
      <category>Intel® Parallel Composer Knowledge Base</category>
      <category>Intel® Visual Fortran Compiler for Windows* Knowledge Base</category>
    </item>
    <item>
      <title>Array Arguments to memcpy() Should Not Overlap</title>
      <description><![CDATA[ <div id="art_pre_template"><br /><b>Version : 2011  (contains Intel Compiler version 12.0)</b><br /><br /><br /><b>Product : Intel Parallel Composer, Intel Composer XE</b><br /><br /><br /><b>Operating System : Windows, Linux, Mac OS X</b><br /><br /><br /><b>Problem Description : </b><br />The Intel Compilers version 12 contain an optimized implementation of memcpy() that may give unexpected results if the input and output buffers overlap. The semantics of memcpy() specify that the input and output buffers should be independent; however, less optimized versions in earlier Intel compilers gave the expected result, even in the case of overlapping buffers.<br /><br /><b>Solution : <br /></b>If there is a possibility that input and output buffers might overlap, memmove() should be called instead of memcpy().<br /><br />The Fortran language standard does not allow overlapping function arguments; therefore, the Intel Fortran compiler may generate memcpy() calls for simple routines that copy arrays, assuming that this is safe. If your code calls subroutines or functions with array arguments that might overlap, you should build with the option /assume:dummy_aliases (Windows) or -assume dummy_aliases (Linux or Mac OS X). Or better still, restructure your code in compliance with the Fortran standard to avoid any possibility of array argument overlap.<br /><br />The Intel C/C++ compiler assumes by default that function array arguments might overlap. It will protect against overlapping arguments unless you build with /Qalias-args- (Windows)  or  –fargument-noalias (Linux or Mac OS X) or equivalent.<br /><br /><br /><br /><br /><i>[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.]</i></div> ]]></description>
      <link>http://software.intel.com/en-us/articles/array-arguments-to-memcpy-should-not-overlap/</link>
      <pubDate>Wed, 15 Dec 2010 21:00:00 -0800</pubDate>
      <comments>http://software.intel.com/en-us/articles/array-arguments-to-memcpy-should-not-overlap/#comments</comments>
      <guid isPermaLink="true">http://software.intel.com/en-us/articles/array-arguments-to-memcpy-should-not-overlap/</guid>
      <category>Intel® C++ Compiler for Linux* Knowledge Base</category>
      <category>Intel® C++ Compiler for Mac OS X* Knowledge Base</category>
      <category>Intel® C++ Compiler for Windows* Knowledge Base</category>
      <category>Intel® Fortran Compiler for Linux* Knowledge Base</category>
      <category>Intel® Fortran Compiler for Mac OS X* Knowledge Base</category>
      <category>Intel® Parallel Composer Knowledge Base</category>
      <category>Intel® Visual Fortran Compiler for Windows* Knowledge Base</category>
    </item>
    <item>
      <title>True DSS and PARDISO overloaded F90 interfaces are available in Intel®MKL 10.3.1 and 10.2.7.</title>
      <description><![CDATA[ <div><br /></div>
<div><br /></div>
Renewed F90 interfaces for DSS and PARDISO are available in Intel® MKL 10.3.1 and 10.2.7.
<div>There are a few advantages over the previous version.<br /><br /><b><span >DSS: </span></b>
<div><br /></div>
<div>New DSS F90 interfaces allow calling factor and solve routines via short names.</div>
<div>Now there is no need to specify a data type (real/complex) in the name of routines as the interfaces are overloaded.</div>
<div>All data types are supported: real(kind=4), real(kind=8), complex(kind=4) and complex(kind=8).<br /><br /><span ></span></div>
<div>
<table cellpadding="0" bordercolor="#808080" cellspacing="0" border="1">
<tbody>
<tr>
<td width="168" valign="top"><b>Old names</b></td>
<td width="161" valign="top"><b>New names</b></td>
</tr>
<tr>
<td width="168" valign="top"><br />dss_factor_real()<br />dss_factor_complex()<br /><br />dss_solve_real()     <br />dss_solve_complex()<br /><br /></td>
<td width="161" valign="top"><br />dss_factor()     <br /><br /><br />dss_solve()</td>
</tr>
</tbody>
</table>
<br />
<div id="art_pre_template"><b><br /></b></div>
<div id="art_pre_template">Backward compatibility with old names is supported.</div>
<div id="art_pre_template"><span ><br /></span></div>
<div id="art_pre_template"><b><span >PARDISO:</span> </b></div>
<div id="art_pre_template"><br /></div>
<div id="art_pre_template">New PARDISO F90 interface is also overloaded and accepts all data types:</div>
<div id="art_pre_template">real(kind=4), real(kind=8), complex(kind=4) and complex(kind=8).</div>
<div id="art_pre_template"><br /></div>
<div id="art_pre_template"><b><span >NOTE</span>:</b> 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.   <br /></div>
<div id="art_pre_template"><span ><b><br /></b></span></div>
<div id="art_pre_template"><br /></div>
<div id="art_pre_template"><br /></div>
</div>
</div> ]]></description>
      <link>http://software.intel.com/en-us/articles/true-dss-and-pardiso-overloaded-f90-interfaces-are-available-in-intelmkl-1031-and-1027/</link>
      <pubDate>Wed, 08 Dec 2010 11:30:00 -0800</pubDate>
      <comments>http://software.intel.com/en-us/articles/true-dss-and-pardiso-overloaded-f90-interfaces-are-available-in-intelmkl-1031-and-1027/#comments</comments>
      <guid isPermaLink="true">http://software.intel.com/en-us/articles/true-dss-and-pardiso-overloaded-f90-interfaces-are-available-in-intelmkl-1031-and-1027/</guid>
      <category>Intel® C++ Compiler for Linux* Knowledge Base</category>
      <category>Intel® C++ Compiler for Mac OS X* Knowledge Base</category>
      <category>Intel® C++ Compiler for Windows* Knowledge Base</category>
      <category>Intel® Cluster Toolkit for Linux* Knowledge Base</category>
      <category>Intel® Cluster Toolkit for Windows* Knowledge Base</category>
      <category>Intel® Fortran Compiler for Linux* Knowledge Base</category>
      <category>Intel® Fortran Compiler for Mac OS X* Knowledge Base</category>
      <category>Intel® Math Kernel Library Knowledge Base</category>
    </item>
    <item>
      <title>How to select different update of Intel® Composer XE 2011 for Linux* and Mac OS* X</title>
      <description><![CDATA[ <strong>Reference Number</strong> : dpd200194608, dpd200160631<br /><br /><strong>Version</strong> : 2011 (Compiler 12.0)<br /><br /><strong>Product</strong> : Intel Composer XE <br /><br /><strong>Operating System</strong> : Linux, Mac OS X<br /><br /><strong><br />Problem Description</strong> :  When an Intel Composer XE update is installed, the scripts <strong>compilervars.sh [.csh]</strong> 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.<br /><br /><br /><strong>Workaround:</strong> <br />
<div id="art_pre_template">To select a compiler update other than the latest, please use the script <strong>compilervars_arch.sh [.csh] </strong>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.<br /><br /><strong>Resolution Status:<br /></strong>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:<br /><br />&gt; source /opt/intel/composerxe-2011.3.174/bin/compilervars.sh intel64  &lt;&lt;&lt;=== update #3<br /><br />&gt; ifort -V<br />Intel(R) Fortran Intel(R) 64 Compiler XE for applications running on Intel(R) 64, Version 12.0.3.174 Build 20110309<br /><br />&gt; source /opt/intel/composerxe-2011.4.191/bin/compilervars.sh intel64 &lt;&lt;&lt;== update #4<br /><br />&gt; ifort -V<br />Intel(R) Fortran Intel(R) 64 Compiler XE for applications running on Intel(R) 64, Version 12.0.4.191 Build 20110427<br /><br />As before, the script from the generic, non-version specific directory will initialize for the most recent update:<br /><br />&gt; source /opt/intel/composerxe-2011/bin/compilervars.sh intel64  &lt;&lt;&lt;=== non-version specific (most recent update)<br />&gt; ifort -V<br />Intel(R) Fortran Intel(R) 64 Compiler XE for applications running on Intel(R) 64, Version 12.0.4.191 Build 20110427<br /><br /><br /><br /><br /><br /><em>[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.]<br /></em></div> ]]></description>
      <link>http://software.intel.com/en-us/articles/how-to-select-different-update-of-intel-composer-xe-2011-for-linux-and-mac-os-x/</link>
      <pubDate>Mon, 06 Dec 2010 08:00:00 -0800</pubDate>
      <comments>http://software.intel.com/en-us/articles/how-to-select-different-update-of-intel-composer-xe-2011-for-linux-and-mac-os-x/#comments</comments>
      <guid isPermaLink="true">http://software.intel.com/en-us/articles/how-to-select-different-update-of-intel-composer-xe-2011-for-linux-and-mac-os-x/</guid>
      <category>Intel® C++ Compiler for Linux* Knowledge Base</category>
      <category>Intel® C++ Compiler for Mac OS X* Knowledge Base</category>
      <category>Intel® Fortran Compiler for Linux* Knowledge Base</category>
      <category>Intel® Fortran Compiler for Mac OS X* Knowledge Base</category>
      <category>Intel® Integrated Performance Primitives Knowledge Base</category>
      <category>Intel® Math Kernel Library Knowledge Base</category>
      <category>Intel® Threading Building Blocks Knowledge Base</category>
    </item>
    <item>
      <title>Step-by-Step Application Performance Tuning with Intel Compilers</title>
      <description><![CDATA[ <span class="sectionHeading">Application Performance:  A Step-by-Step Introduction to Application Tuning with Intel® Compilers</span><br /><br /><span class="sectionBodyText">Before you begin performance tuning, you may want to check the correctness of your application by building it without optimization using /Od (Windows*) or -O0 (Linux* or Mac OS* X). In compiler versions 11 and later, all optimization levels assume support for the SSE2 instruction set by default. <br /><br /><span class="sectionHeading">1. </span>Use the general optimization options (Windows /O1, /O2 or /O3; Linux and Mac OS X -O1, -O2, or -O3) and determine which one works best for your application by measuring performance with each. Most users should start at /O2 (–O2), the default, before trying more advanced optimizations. Next, for loop-intensive applications, try /O3 (-O3).  These options are available for both Intel® and non-Intel microprocessors but they may perform more optimizations for Intel microprocessors than they perform for non-Intel microprocessors.<br /><br /><span class="sectionHeading">2.</span> Fine-tune performance to target IA-32 and Intel 64-based systems using processor-specific options. Examples are /QxSSE4.2 (–xsse4.2) for the Intel® Core™ processor family, e.g. the Intel Core i7 processor, and /arch:SSE3 (-msse3) for compatible, non-Intel processors that support at least the SSE3 instruction set. Alternatively, you can use /QxHOST (-xhost) which will use the most advanced instruction set for the processor on which you compiled. This option is available for both Intel® and non-Intel microprocessors but it may perform more optimizations for Intel microprocessors than it performs for non-Intel microprocessors. For a more extensive list and description of options that optimize for specific processors or instruction sets, please see the online article “<a href="http://software.intel.com/en-us/articles/performance-tools-for-software-developers-intel-compiler-options-for-sse-generation-and-processor-specific-optimizations/" title="SSE generation and processor-specific optimizations">Intel® compiler options for SSE generation and processor-specific optimizations</a>” and the Intel Compiler User and Reference Guides.<br /><br /><span class="sectionHeadingText">3.</span> Add interprocedural optimization (IPO), /Qipo (-ipo) and/or profile-guided optimization (PGO), /Qprof-gen and /Qprof-use (-prof-gen and -prof-use); then measure performance again to determine whether your application benefits from one or both of them.<br /><br /><span class="sectionHeadingText">4.</span> Optimize your application for vector and parallel execution on multi-threaded, multi-core and multi-processor systems using:<br />advice from the new Guided Auto-Parallelism (GAP) feature, /Qguide (-guide); <br />the Intel® Cilk™ Plus language extensions for C/C++;<br />the parallel performance options /Qparallel (-parallel) or /Qopenmp (-openmp);<br />the CoArray feature of Fortran 2008;<br />or by using the Intel® Performance Libraries included with the product. <br />These optimization steps are applicable to both Intel and non-Intel microprocessors, but may result in a greater performance gain on Intel microprocessors than on non-Intel microprocessors.<br /><br /><span class="sectionHeading">5.</span> Use Intel® VTune™ Amplifier XE to help you identify serial and parallel performance “hotspots” so that you know which specific parts of your application could benefit from further tuning. Use Intel® Inspector XE to reduce the time to market for threaded applications by diagnosing memory and threading errors and speeding up the development process. These products cannot be used on non-Intel microprocessors.<br /></span><br />For more details, please consult the main product documentation, e.g. in the <a href="http://software.intel.com/en-us/articles/intel-software-technical-documentation/">Intel® Software Documentation Library</a>. A brief summary of the major optimization options of the Intel Compiler is available in the <a href="http://software.intel.com/sites/products/collateral/hpc/compilers/compiler_qrg12.pdf" title="Quick-Reference Guide to Optimization with Intel® Compilers version 12">Quick-Reference Guide to Optimization with Intel® Compilers version 12</a>. ]]></description>
      <link>http://software.intel.com/en-us/articles/step-by-step-application-performance-tuning-with-intel-compilers/</link>
      <pubDate>Thu, 11 Nov 2010 21:00:00 -0800</pubDate>
      <comments>http://software.intel.com/en-us/articles/step-by-step-application-performance-tuning-with-intel-compilers/#comments</comments>
      <guid isPermaLink="true">http://software.intel.com/en-us/articles/step-by-step-application-performance-tuning-with-intel-compilers/</guid>
      <category>Intel® C++ Compiler for Linux* Knowledge Base</category>
      <category>Intel® C++ Compiler for Mac OS X* Knowledge Base</category>
      <category>Intel® C++ Compiler for Windows* Knowledge Base</category>
      <category>Intel® Fortran Compiler for Linux* Knowledge Base</category>
      <category>Intel® Fortran Compiler for Mac OS X* Knowledge Base</category>
      <category>Intel® Parallel Composer Knowledge Base</category>
      <category>Intel® Visual Fortran Compiler for Windows* Knowledge Base</category>
      <category>Intel® VTune™ Amplifier XE Knowledge Base</category>
    </item>
    <item>
      <title>Consistency of Floating-Point Results using the Intel® Compiler</title>
      <description><![CDATA[ <p><strong>Consistency of Floating-Point Results using the Intel® Compiler<br />or<br />Why doesn’t my application always give the same answer?</strong><br /><br />Dr. Martyn J. Corden<br />David Kreitzer<br /><br />Software Solutions Group<br />Intel Corporation<br /><br /><br /><strong>Introduction<br /></strong><br />Binary floating-point [FP] representations of most real numbers are inexact, and there is an inherent uncertainty in the result of most calculations involving floating-point numbers. Programmers of floating-point applications typically have the following objectives:<br />   • Accuracy<br />     o Produce results that are “close” to the result of the exact calculation<br />         - Usually measured in fractional error, or sometimes “units in the last place” (ulp).<br />   • Reproducibility<br />      o Produce consistent results:<br />         - From one run to the next;<br />         - From one set of build options to another;<br />         - From one compiler to another<br />         - From one processor or operating system to another<br />   • Performance<br />      o Produce an application that runs as fast as possible<br /><br />These objectives usually conflict! However, good programming practices and judicious use of compiler options allow you to control the tradeoffs.<br /><br />For example, it is sometimes useful to have a degree of reproducibility that goes beyond the inherent accuracy of a computation. Some software quality assurance tests may require close, or even bit-for-bit, agreement between results before and after software changes, even though the mathematical uncertainty in the result of the computation may be considerably larger. The right compiler options can deliver consistent, closely reproducible results while preserving good (though not optimal) performance.<br /><br />....................&lt;omitted&gt;........................<br /><br /><strong>Bottom Line</strong><br /><br />Compiler options let you control the tradeoffs between accuracy, reproducibility and performance. Use /fp:precise /fp:source (Windows) or –fp-model precise –fp-model source (Linux or Mac OS X) to improve the consistency and reproducibility of floating-point results while limiting the impact on performance. If reproducibility between different processor types of the same architecture is important, use also /Qimf-arch-consistency:true (Windows) or -fimf-arch-consistency=true (Linux or Mac OS X).<br /><br /><br /><strong>For the complete article, please open the attached PDF file.<br /></strong>You can't download and save it directly, but you may save it after having opened it.</p>
<br /><br />
<table cellpadding="5" cellspacing="0" rules="none" border="1">
<tbody>
<tr>
<th align="left" valign="middle" >Optimization Notice</th>
</tr>
<tr bgcolor="#ccecff">
<td>
<p>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.</p>
<p align="right">Notice revision #20110804</p>
</td>
</tr>
</tbody>
</table> ]]></description>
      <link>http://software.intel.com/en-us/articles/consistency-of-floating-point-results-using-the-intel-compiler/</link>
      <pubDate>Mon, 08 Nov 2010 00:00:00 -0800</pubDate>
      <comments>http://software.intel.com/en-us/articles/consistency-of-floating-point-results-using-the-intel-compiler/#comments</comments>
      <guid isPermaLink="true">http://software.intel.com/en-us/articles/consistency-of-floating-point-results-using-the-intel-compiler/</guid>
      <category>Intel® C++ Compiler for Linux* Knowledge Base</category>
      <category>Intel® C++ Compiler for Mac OS X* Knowledge Base</category>
      <category>Intel® C++ Compiler for Windows* Knowledge Base</category>
      <category>Intel® Fortran Compiler for Linux* Knowledge Base</category>
      <category>Intel® Fortran Compiler for Mac OS X* Knowledge Base</category>
      <category>Intel® Parallel Composer Knowledge Base</category>
      <category>Intel® Visual Fortran Compiler for Windows* Knowledge Base</category>
    </item>
    <item>
      <title>New matrix vector product BLAS routines</title>
      <description><![CDATA[ <br />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).
<div><br /></div>
<div>The current implementation offers FORTRAN 77 and FORTRAN 95 interfaces only.</div>
<div><br /></div>
<div>This is Fortran77 Syntax for the double precision data type:</div>
<div><br />call dgem2vu(m, n, alpha, a, lda, x1, incx1, x2, incx2, beta, y1, incy1, y2, incy2);<br /></div>
<div><br /></div>
<div>Description<br />The dgem2vu routines perform two matrix-vector operations defined as <br />y1 := alpha*A*x1 + beta*y1,<br />and <br />y2 := alpha*A'*x2 + beta*y2,<br />where:<br />alpha and beta are scalars,<br />x1, x2, y1, and y2 are vectors,<br />A is an m-by-n matrix.<br /></div>
<div><br /></div>
<div>and the output parameters are y1 and y2 correspondingly.</div>
<div><br /></div>
<div>The prototype of the code:</div>
<div>
<div>A prototype code is:<br />do j = 1, N<br />do i = 1, M<br />B1(i) = B1(i) + A(i,j)*V1(j)<br />B2(j) = B2(j) + A(i,j)*V2(i)<br />end do<br />end do</div>
<div><br /></div>
<div>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.</div>
<div><br /></div>
<div><br /></div>
<div>Below is the performance result comparison for  DGEM2VU / ( 2 consecutive calls of DGEMV ) / DSYMV</div>
<div><br /></div>
<div><img src="http://software.intel.com/file/27279" alt="1.bmp" title="1.bmp" /><br /></div>
<div><br /></div>
<div><br /></div>
<div><br /></div>
</div> ]]></description>
      <link>http://software.intel.com/en-us/articles/new-matrix-vector-product-blas-routines/</link>
      <pubDate>Sun, 07 Nov 2010 07:30:00 -0800</pubDate>
      <comments>http://software.intel.com/en-us/articles/new-matrix-vector-product-blas-routines/#comments</comments>
      <guid isPermaLink="true">http://software.intel.com/en-us/articles/new-matrix-vector-product-blas-routines/</guid>
      <category>Intel® C++ Compiler for Linux* Knowledge Base</category>
      <category>Intel® C++ Compiler for Mac OS X* Knowledge Base</category>
      <category>Intel® C++ Compiler for Windows* Knowledge Base</category>
      <category>Intel® Fortran Compiler for Linux* Knowledge Base</category>
      <category>Intel® Fortran Compiler for Mac OS X* Knowledge Base</category>
      <category>Intel® Math Kernel Library Knowledge Base</category>
    </item>
  </channel></rss>
