This chapter gathers frequently asked questions and provides quick answers. When possible, supplementary reference material is provided.

Q. I did not see any references to Java in ProPack. What should I do?

A. Java for IA64 Linux is available from BEA Systems. See their websites:

For Downloads see
http://commerce.bea.com/showallversions.jsp?family=WLJR .

For redistribution terms see:
http://commerce.bea.com/products/weblogicjrockit/support_services.jsp

A version is also available from Sun at: http://java.sun.com/j2se/1.4.2/download.html

Q. I profiled my application, and got a list of functions that I could not find documentation for. The list of functions is:

__kmp_wait_sleep

__kmp_yield

__kmp_static_yield

__kmp_ia64_pause

__kmp_fork_call

__kmp_acquire_bootstrap_lock

What are they?

A. These are internal functions in Intel's libguide. They are not documented.

Q. I want to use a “perfex like” performance analysis tool on Altix. What should I use?

A. Tools such as pfmon, profile.pl and histx fall into this category. See Chapter 5, “Additional Development Tools” for more information.

Q. How do I disassemble my binary? There is no dis(1).

A. Use objdump -d.

Q. Can I read big-endian formatted files with my Fortran program?

A. Yes, set the F_UFMTENDIAN environment variable to big.

Q. Is there the equivalent of the MP_SLAVE_STACKSIZE environment variable on Altix?

A.  KMP_STACKSIZE

see http://developer.intel.com/software/products/kappro/kappro_manual.pdf (page 76)

Q. I have a subroutine that the Intel compiler asserts cannot be optimized at any level (-O0 through -O3 using various 7.1 versions) because of resource constraints. Is there a magic flag, like -OPT:Olimit=0 in the MIPSpro compilers, that I can use to get some optimization out of the compiler for this routine?

A. The - override_limits flag sometimes helps in these cases.

Q. The following fragment of Fortran code compiled with version 7.1 of the Intel compilers (and with MIPSpro) but does not with version 8 of the Intel compilers. What is the matter?

subroutine foo(x, n)
implicit none
real x(n)
integer n
end

A. Version 8 sees the implicit none and determines that n is of an undefined type. Reversing the declarations of x and n will compile.

Q. What tools are available that will help me port my 32-bit application to 64-bits?

A. The compiler helps the most in this regard. Pay special attention to the warnings generated. A script that may help in this is the following:

#!/usr/bin/env python
#
# Copyright (c) 2004 Hewlett-Packard Development Company, L.P.
#       David Mosberger <davidm@hpl.hp.com>
#
# Scan standard input for GCC warning messages that are likely to
# source of real 64-bit problems.  In particular, see whether there
# are any implicitly declared functions whose return values are later
# intepreted as pointers.  Those are almost guaranteed to cause
# crashes.
#
import re
import sys
implicit_pattern = re.compile(“([^:]*):(\d+): warning: implicit declaration “
                               + “of function `([^']*)'”)
pointer_pattern = re.compile(“([^:]*):(\d+): warning: “
                              + “(assignment”
                              + “|initialization”
                              + “|return”
                              + “|passing arg \d+ of `[^']*'”
                              + “|passing arg \d+ of pointer to function”
                              + “) makes pointer from integer without a cast”)
while True:
     line = sys.stdin.readline()
     if line == `':
         break
     m = implicit_pattern.match(line)
     if m:
         last_implicit_filename = m.group(1)
         last_implicit_linenum = int(m.group(2))
         last_implicit_func = m.group(3)
     else:
        m = pointer_pattern.match(line)
         if m:
             pointer_filename = m.group(1)
             pointer_linenum = int(m.group(2))
             if (last_implicit_filename == pointer_filename
                 and last_implicit_linenum == pointer_linenum):
                 print “Function `%s' implicitly converted to pointer at “ \
                       “%s:%d” % (last_implicit_func, last_implicit_filename,
                                  last_implicit_linenum)

This Python script scans the output of gcc -Wall -O for warnings that are almost guaranteed to cause crashes on ia64. This won't help much for applications that are hopelessly 64-bit-dirty, but it will help those applications that are basically 64-bit clean, save for some silly oversights (like missing header file includes).

Here is an example:

$ check-implicit-pointer-functions < ./log
Function `strdup' implicitly converted to pointer at e-pilot-util.c:42
Function `e_path_to_physical' implicitly converted to pointer at mail-importer.c:98 

Q. Does the cpio command on Altix support the -K IRIX feature?

A. The IRIX cpio -K option turns on use of the extended format and is required for files larger than 2 Gigabytes. IRIX cpio gives a warning message whenever a non-standard cpio file is written. This option is not available on Altix. As an alternative there, use the GNU tar command which can archive files up to 64 gigabytes.