[Omp] Error: The PPD directives stack limit has been exceeded.

Mon Apr 17 16:26:48 PDT 2006

This is a compile-time error message, not a runtime error message.
It doesn't have anything to do with the OpenMP stack.
If you have intel support you can submit a problem report.
Also feel free to send me or your favorite Intel contact
a failing test case and we'll make sure it gets to the right
person.

Regards,

Larry Meadows

>-----Original Message-----
>From: omp-bounces at openmp.org [mailto:omp-bounces at openmp.org] 
>On Behalf Of Faustin Roman
>Sent: Monday, April 17, 2006 4:23 PM
>To: omp at openmp.org
>Subject: [Omp] Error: The PPD directives stack limit has been exceeded.
>
>Hi everyone!
>
>I get this message when trying to compile a fortran code with Intel
>Fortran v.9.0.021:
>
>fortcom: Error: mpi_prog.for, line 315: The PPD directives stack limit
>has been exceeded.
>
>Please tell me if I should increase the stack limit (currently 
>at 8192) or the
>KMP_SET_STACKSIZE_S()
>
>I have tried both ways but nothing seems to work...
>
>(I don't know if the version of glibc is built with the
>FLOATING_STACKS parameter defined
>as required by Intel workaround - see below)
>
>Any ideeas?
>
>Thanks,
>Faustin Roman
>
>PS: If it helps someone, here is what I found so far...
>
>Intel(r) Fortran Compiler 9.0 for Linux Release Notes:
>
>"OpenMP Limitations
>
>POSIX threaded programs that require a large stack size may not run
>correctly on some versions of Linux because of hard-coded stack size
>limits in some versions of the Linux POSIX threads libraries. These
>limits also apply to OpenMP programs (-openmp) and automatically
>generated parallel programs (-parallel) with the Intel compilers,
>because the Intel compilers use the POSIX threads library to implement
>OpenMP based and automatically generated parallelism. Threaded
>programs that exceed the stack space limit usually experience
>segmentation violations or addressing errors.
>
>To avoid these limitations, use a version of glibc built with the
>FLOATING_STACKS parameter defined. For some distributions, this
>implies using the shared rather than the static version of the
>pthreads library. Then use the ulimit -s or limit stacksize command to
>set the maximum shell stack size to an explicit large value, in units
>of KBytes, (not unlimited), and also set the KMP_STACKSIZE environment
>variable to the needed thread stacksize in bytes. Note, in the bash
>shell, ulimit -s can be used to set a large maximum stack size only
>once. In the C shell (csh), limit stacksize , with no dash before the
>argument, can be used to reset the maximum stacksize repeatedly.
>
>This solution has been tested on glibc version 2.2.4-13 for IA-32 and
>glibc 2.2.4-19 for Itanium Processor Family as found in the RedHat 7.2
>Linux distribution. For glibc 2.2.4-13 on IA-32, the shared version of
>the POSIX threads library must be used, (there should not be a -static
>flag in the compiler .cfg file or on the command line).
>
>In addition, if a common block is declared as THREADPRIVATE with an
>OpenMP directive, the common block must have the same length in all
>the source files in which it is declared. "
>
>
>Intel Extension Routines/Functions:
>
>Stack Size
>
>In most cases, environment variables can be used in place of the
>extension library routines. For example, the stack size of the
>parallel threads may be set using the KMP_STACKSIZE environment
>variable rather than the KMP_SET_STACKSIZE() or  KMP_SET_STACKSIZE_S()
>library routine.
>
>Note A run-time call to an Intel extension routine takes precedence
>over the corresponding environment variable setting.
>
>The routines KMP_SET_STACKSIZE() and KMP_GET_STACKSIZE() take a 32-bit
>argument only. The routines KMP_SET_STACKSIZE_S() and
>KMP_GET_STACKSIZE_S() take a SIZE_T argument, which can hold 64- bit
>integers.
>
>On Itanium(r)-based systems, it is recommended to always use
>KMP_SET_STACKSIZE_S() and KMP_GET_STACKSIZE_S(). These _S() variants
>must be used if you need to set a stack size 2**32 bytes (4
>gigabytes).
>Stack Size
>Function
>	
>Description
>
>FUNCTION KMP_GET_STACKSIZE_S()
>INTEGER(KIND=KMP_SIZE_T_KIND) &
>KMP_GET_STACKSIZE_S
>
>Returns the number of bytes that will be allocated for each parallel
>thread to use as its private stack. This value can be changed via the
>KMP_SET_STACKSIZE_S routine, prior to the first parallel region or via
>the KMP_STACKSIZE environment variable.
>
>SUBROUTINE KMP_SET_STACKSIZE_S(size)
>INTEGER (KIND=KMP_SIZE_T_KIND) size
>
>Sets to size the number of bytes that will be allocated for each
>parallel thread to use as its private stack. This value can also be
>set via the KMP_STACKSIZE environment variable. In order for
>KMP_SET_STACKSIZE_S to have an effect, it must be called before the
>beginning of the first (dynamically executed) parallel region in the
>program.
>
>--
>----------------------------------------------------------------------
>Faustin Laurentiu Roman,                          Assistant Researcher
>Nuclear Physics Department
>"Horia Hulubei" National Institute for Physics and Nuclear Engineering
>(IFIN-HH), P.O. Box MG-6, 76900 Bucharest-Magurele, Romania
>Tel: 40-21-4042300/ ext. 4315, Fax: 40-21-4574432, Mobile:+40721244414
>E-mail: froman_at_tandem.nipne.ro, faustinroman_at_yahoo.com
>URL: http://tandem.nipne.ro/~vavrig/preeq.html
>----------------------------------------------------------------------
>_______________________________________________
>Omp mailing list
>Omp at openmp.org
>http://openmp.org/mailman/listinfo/omp
>