<?xml version="1.0" encoding="UTF-8"?>
<!-- Generated on Fri, 25 May 2012 15:23:18 -0700 -->
<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-increased-stack-usage-of-80-or-higher-compilers-causes-segmentation-fault/feed/" rel="self" type="application/rss+xml" />
    <title>Intel Software Network Comments Feed</title>
    <link>http://software.intel.com/en-us/articles/intel-fortran-compiler-increased-stack-usage-of-80-or-higher-compilers-causes-segmentation-fault</link>
    <description></description>
    <language>en-us</language>
    <item>
      <title>By Philippe</title>
      <description><![CDATA[ I had this problem under Linux with ifort above 10.0, and I used both solutions:
-> the "ulimit -s unlimited" bash option was clearly the best choice for the program I am using, rather than "ifort ... -heap-arrays". I don't know why but it is between 10 and 100 times quicker with ulimit -s unlimited than with -heap-arrays.

Thanks for the solution ]]></description>
      <link>http://software.intel.com/en-us/articles/intel-fortran-compiler-increased-stack-usage-of-80-or-higher-compilers-causes-segmentation-fault/#comment-47153</link>
      <pubDate>Mon, 09 Aug 2010 10:47:52 -0700</pubDate>
      <guid isPermaLink="true">http://software.intel.com/en-us/articles/intel-fortran-compiler-increased-stack-usage-of-80-or-higher-compilers-causes-segmentation-fault/#comment-47153</guid>
    </item>
    <item>
      <title>By john hamrick</title>
      <description><![CDATA[ I am implementing some high level parallelism in a production CFD code, by 
calling big subroutines form openmp parallel do loop.   I have tested the approach
with simple code and find that F0x10000000 is required to to elimanate stack overflow.
i have gone up to 0x100000000 in the production code and still have a problem.  
Interestingly the PG Fortran compiler does no require this type of intervention and works
fine for the test case.  However PG code is slow compared to Intel both serial and 
parallel (likely due to vectorization).   I have noticed that many large parallel codes
with OpenMP use PG fortran,  probably for this reason.   I would like to stick with Intel
but there seems to be no guidance.   I am going to buy PG Fortran as well as test Oracale/Sun Fortran ]]></description>
      <link>http://software.intel.com/en-us/articles/intel-fortran-compiler-increased-stack-usage-of-80-or-higher-compilers-causes-segmentation-fault/#comment-53677</link>
      <pubDate>Fri, 17 Dec 2010 09:14:56 -0800</pubDate>
      <guid isPermaLink="true">http://software.intel.com/en-us/articles/intel-fortran-compiler-increased-stack-usage-of-80-or-higher-compilers-causes-segmentation-fault/#comment-53677</guid>
    </item>
    <item>
      <title>By Wendy Doerner (Intel)</title>
      <description><![CDATA[ We put some arrays on the stack for performance reasons. (It is faster to access them from stack). You can always use -heaparrays if you want to put them in the heap (at performance loss). It is a tradeoff you get to make.  ]]></description>
      <link>http://software.intel.com/en-us/articles/intel-fortran-compiler-increased-stack-usage-of-80-or-higher-compilers-causes-segmentation-fault/#comment-54896</link>
      <pubDate>Fri, 14 Jan 2011 13:38:11 -0800</pubDate>
      <guid isPermaLink="true">http://software.intel.com/en-us/articles/intel-fortran-compiler-increased-stack-usage-of-80-or-higher-compilers-causes-segmentation-fault/#comment-54896</guid>
    </item>
    <item>
      <title>By aLI</title>
      <description><![CDATA[ IT REALLY HELPED ME THANKS ALOT!!!!! ]]></description>
      <link>http://software.intel.com/en-us/articles/intel-fortran-compiler-increased-stack-usage-of-80-or-higher-compilers-causes-segmentation-fault/#comment-66326</link>
      <pubDate>Sat, 05 Nov 2011 05:31:33 -0700</pubDate>
      <guid isPermaLink="true">http://software.intel.com/en-us/articles/intel-fortran-compiler-increased-stack-usage-of-80-or-higher-compilers-causes-segmentation-fault/#comment-66326</guid>
    </item>
    <item>
      <title>By Bob Evans</title>
      <description><![CDATA[ Hi

   In a very small program when I debug the program with the "Heap Array" being without a number or with number '0' there is no problem. But when in my large program which consists of subroutines with large-size ARGUMENT arrays, when the "Heap Array" is blank I get an error about stack overflow. As I have read through other threads one way is to change the "Heap array " number to '0' to solve this problem. But when I do so my output would only be 'NaN'. I don't know how to solve this problem.
BUT when I run my large program without SUBROUTINES I do not get any error with stack overflow when the "Heap Array" is blank. But when I change the "heap array" to '0' or '25' I again get "NaN" .

How can I solve this problem?

Thanks
 ]]></description>
      <link>http://software.intel.com/en-us/articles/intel-fortran-compiler-increased-stack-usage-of-80-or-higher-compilers-causes-segmentation-fault/#comment-67317</link>
      <pubDate>Fri, 25 Nov 2011 00:38:52 -0800</pubDate>
      <guid isPermaLink="true">http://software.intel.com/en-us/articles/intel-fortran-compiler-increased-stack-usage-of-80-or-higher-compilers-causes-segmentation-fault/#comment-67317</guid>
    </item>
    <item>
      <title>By Wendy Doerner (Intel)</title>
      <description><![CDATA[ Bob, This comment field is not for technical support. It would be best to report this with a test case to premier.intel.com or on our forums at http://software.intel.com/en-us/forums/intel-visual-fortran-compiler-for-windows/.  The number you give to heap-arrays determines what size arrays get put on the heap. With no number or 0 all temporary or automatic arrays are put in the heap. - Wendy ]]></description>
      <link>http://software.intel.com/en-us/articles/intel-fortran-compiler-increased-stack-usage-of-80-or-higher-compilers-causes-segmentation-fault/#comment-67535</link>
      <pubDate>Mon, 28 Nov 2011 09:47:35 -0800</pubDate>
      <guid isPermaLink="true">http://software.intel.com/en-us/articles/intel-fortran-compiler-increased-stack-usage-of-80-or-higher-compilers-causes-segmentation-fault/#comment-67535</guid>
    </item>
    <item>
      <title>By Nat</title>
      <description><![CDATA[ I was trying to compile my core in an MacOS X and it did not allowed me to change the stack size form the prompt as I always did in linux before. Thanks for posting this finally had the issue resolved ]]></description>
      <link>http://software.intel.com/en-us/articles/intel-fortran-compiler-increased-stack-usage-of-80-or-higher-compilers-causes-segmentation-fault/#comment-71448</link>
      <pubDate>Mon, 12 Mar 2012 12:23:55 -0700</pubDate>
      <guid isPermaLink="true">http://software.intel.com/en-us/articles/intel-fortran-compiler-increased-stack-usage-of-80-or-higher-compilers-causes-segmentation-fault/#comment-71448</guid>
    </item>
  </channel></rss>
