HP Fortran
Release Notes for Tru64 UNIX Systems
Previous Contents

1.10.6 Obsolete Features Deleted

1.10.6.1 GLOBAL_TO_PHYSICAL and GLOBAL_LBOUNDS are Deleted

The following obsolete HPF Local Library routines have been deleted:

1.10.7 Miscellaneous

This section contains miscellaneous release notes relevant to HPF.

1.10.7.1 What To Do When Encountering Unexpected Program Behavior

This section gives some guidelines about what to do when your program displays unexpected behavior at runtime. The two most common problems are incorrect programs that either segmentation fault or hang at runtime.

Before attempting to debug parallel HPF programs, it is important to verify first that the program runs correctly when compiled without the -wsf command line switch.

When the problem occurs only when compiled with the -wsf switch, the best way to debug these programs is to execute them with the -debug command line switch.

In addition, programs with zero sized arrays which were compiled with -fast or -assume nozsize may behave erratically or fail to execute.

1.10.7.1.1 Incompatible or Incomplete Libraries Installed

If your program displays unexpected behavior at runtime, your system might have incomplete or incompatible libraries installed. You must have PSE160 installed on your system to execute programs compiled with the -wsf switch. PSE180 is not sufficient. In addition, for this release, you must have first installed PSE160. Then you must have installed Fortran V5.2, including the HPFLIBS170 subset.

Choose one of the following options to fix an incorrect installation:

For more information about installing PSE160, see the Compaq Parallel Software Environment Release Notes, Version 1.6.

For more information about installing PSE180, see the Compaq Parallel Software Environment Release Notes, Version 1.8.

1.10.7.1.2 Segmentation Faults

When a program segmentation faults at runtime it can be confusing because it may look like the program executed, even though no output is produced. The PSE does not always display an error message when the return status of the executed program is non zero. In particular, if the program segmentation faults it does not display an error message, the program just stops. In this example, program "bad" gets a segmentation fault at runtime. 


# bad -peers 4 
#

To see the execution status, type this csh command (other shells require different commands): 


# echo $status

A status of -117 indicates a segmentation fault. See the section about known problems in the Parallel Software Environment (PSE) Version 1.6 release notes.

Alternatively, you can run the program in the debugger. This is better because it shows what went wrong on each peer. To do this, use the -debug command line switch. 


# bad -peers 4 -debug

See Chapter 9 of the DIGITAL High Performance Fortran 90 HPF and PSE Manual for more information.

Note that some correct programs may segmentation fault at runtime due to lack of stack space and data space. See Section 1.10.7.2 for further details.

1.10.7.1.3 Programs that Hang

If your program hangs at runtime, rerun it in the debugger. You can type <ctrl>/c in the debugger to get it to stop. Then look at the stack frames to determine where and why the program is hanging. Programs can hang for many reasons. Some of the more common reasons are:

It is always best to compile, run, and debug the program without the -wsf switch first to verify program correctness. Since it is easier to debug scalar programs than parallel programs, this should always be done first.

1.10.7.1.4 Programs with Zero Sized Arrays

Programs with zero sized arrays should not be compiled with the -fast or the -assume nozsize command line options; see Chapter 8 in the DIGITAL High Performance Fortran 90 HPF and PSE Manual. If you incorrectly compile this way there are several different types of behavior that might occur. The program might return an error status of -122 or -177 or 64 . It might also hang (or timeout when the -timeout switch is used). Try compiling the program without these options and execute it to see if it works correctly. If it does, there is most likely a zero-sized array in the program.

1.10.7.2 Stack and Data Space Usage

Exceeding the available stack or data space on a processor can cause the program execution to fail. The failure takes the form of a segmentation violation, which results in an error status of -117. (See the section about known problems in the Parallel Software Environment (PSE) Version 1.6 release notes.) This problem can often be corrected by increasing the stack and data space sizes or by reducing the stack and data requirements of the program. The following csh commands increase the sizes of the stack and data space up to system limits (other shells require different commands): 


limit stacksize unlimited 
limit datasize  unlimited

If your system limits are not sufficient, contact your system administrator, and request that maxdsiz (the data space limit) and/or maxssiz (the stack limit) be increased.

1.10.7.3 Non-"-wsf" main programs

The ability to call parallel HPF subprograms from non-parallel (Fortran or non-Fortran) main programs, is supported in this release. For more information, see Chapter 6 of the DIGITAL High Performance Fortran 90 HPF and PSE Manual.

1.10.7.4 Using "-std" Disables HPF Directive Checking

Normally, all HPF directives are checked for syntactic and semantic correctness regardless of whether or not the -wsf switch is specified. To disable this checking, specify the -std option.

1.10.7.5 Use the Extended Form of HPF_ALIGNMENT

Due to an anomaly in the High Performance Fortran Language Specification, the extended version of the HPF_ALIGNMENT library routine (High Performance Fortran Language Specification V.2 Section 12.2) is incompatible with the standard version (High Performance Fortran Language Specification V.2 Section 7.7).

In particular, the DYNAMIC argument, which is valid only in the extended version, is not the final argument in the argument list.

Because each compiler vendor must choose to implement only one version of this library routine, programs that use this routine are not portable from one compiler to another unless keywords are used for each of the optional arguments.

Compaq chooses to support the extended version of this library routine.

1.10.7.6 EXTRINSIC(SCALAR) Changed to EXTRINSIC(HPF_SERIAL)

EXTRINSIC(SCALAR) was renamed to EXTRINSIC(HPF_SERIAL) to be compatible with Versions 1.1 and later of the High Performance Fortran Language Specification. EXTRINSIC(SCALAR) continues to be supported in this release, but may not be supported in future releases.

1.10.8 Example Programs

The /usr/examples/hpf directory contains example Fortran programs. Most of these programs are referred to in the HPF Tutorial section of the DIGITAL High Performance Fortran 90 HPF and PSE Manual. Others are just there to show examples of HPF code and PVM code. The provided makefile can be used to compile all these programs.

1.11 New Features and Corrections in Version 5.1

Version 5.1 is a major release that includes corrections to problems discovered since Version 5.0 was released.

The following topics are discussed:

1.11.1 Version 5.1 New Features

The following new Compaq Fortran (DIGITAL Fortran 90) features are now supported:

1.11.2 Version 5.1 Corrections

Since Version 5.0, the following corrections have been made:

1.11.3 HPF Version 5.1 New Features

1.11.3.1 SHADOW Directive Now Supported

The new SHADOW directive, as defined in Version 2.0 of the High Performance Fortran Language Specification, is now supported. SHADOW is now a separate HPF directive, rather than a keyword inside the DISTRIBUTE directive.

1.11.3.2 Pointers Now Handled in Parallel

Mapped variables with the POINTER attribute are now handled in parallel. This capability is an approved extension of the High Performance Fortran Language Specification.

1.11.3.3 SHADOW Directive Required for Nearest-Neighbor POINTER or TARGET Arrays

The compiler will not generate shadow edges automatically for arrays with the POINTER or TARGET attributes. In order to be eligible for the compiler's nearest-neighbor optimization, POINTER or TARGET arrays must explicitely be given shadow edges using the SHADOW directive. If pointer assignment is done, both the POINTER and the TARGET must have the same mapping, including shadow edges.

For More Information:

1.11.3.4 Descriptive Mapping Directives are Now Obsolescent

In Version 1 of the HPF Language Specification, a special form of the DISTRIBUTE and ALIGN directives was used in interfaces and procedures when mapped arrays were passed to a procedure. Known as descriptive mapping, it was specified by an asterisk (*) appearing before the left parenthesis "(" in a DISTRIBUTE directive, or after the WITH in an ALIGN directive. For example, 


!HPF$ DISTRIBUTE R*(BLOCK, BLOCK) 
!HPF$ ALIGN S WITH *R

Beginning with version 2.0 of the High Performance Fortran Language Specification (DIGITAL Fortran 90 Version 5.0), the meaning of descriptive syntax has changed. Descriptive mapping is now a weak assertion that the programmer believes that no data communication is required at the procedure interface. If this assertion is wrong, the data communication will in fact occur.

Although there is now no semantic difference between the descriptive form and the ordinary prescriptive form, there is still some benefit in using the descriptive form. Compaq Fortran generates informational messages when a descriptive directive is specified if the compiler is unable to confirm that there will in fact be no communication. These messages can uncover subtle programming mistakes that cause performance degradation.

Existing programs with descriptive mapping directives will continue to compile and run with no modification.

In the future, DIGITAL may provide a command-line option that specifies that descriptive directives be treated as strong assertions that data communication will not be necessary at the procedure interface. This would allow the compiler to omit checking whether the mappings of the actual and dummy agree, leading to performance improvement in some cases.

1.11.3.5 New support for HPF Local Library Routines GLOBAL_LBOUND and GLOBAL_UBOUND

The following HPF Local Library routines are now supported:

1.11.3.6 REDUCTION Clause in INDEPENDENT Directives

The REDUCTION clause in INDEPENDENT directives is now supported.

1.11.3.7 HPF_SERIAL Restriction Lifted for Procedures Called from INDEPENDENT DO Loops

Previous versions required procedures called from inside INDEPENDENT DO loops to HPF_SERIAL in order to obtain parallel execution. This restriction is now lifted.

For More Information:

1.11.4 HPF Version 5.1 Corrections

This section lists problems in previous versions that have been fixed in this version.

1.12 New Features and Corrections in Version 5.0

Version 5.0 is a major release that also includes corrections to problems discovered since Version 4.1 was released.

The following topics are discussed:

1.12.1 Version 5.0 New Features

The following new Compaq Fortran (DIGITAL Fortran 90) features are now supported:

The following new High Performance Fortran (HPF) features and corrections have been added for DIGITAL Fortran Version 5.0:

1.12.2 Version 5.0 Corrections

Since Version 4.1, the following corrections have been made:

1.13 Additional Information

This section contains information that supplements the HP Fortran documentation.

1.13.1 HP Fortran Home Page

The HP Fortran Web site is located at: 


http://www.hp.com/software/fortran

1.13.2 Support for the Fortran 95 Standard Features

This section briefly describes the Fortran 95 language features that have been added to Compaq Fortran:

1.13.3 Preliminary Information on Support for Big Objects

Big objects are data items whose size cannot be represented by a signed 32 bit integer. Compaq Fortran supports larger objects than Compaq Fortran 77.

Big objects are good for massive machines and clusters used for numerical analysis, such as weather forecasting and high energy physics problems. Both special knowledge and very large hardware configurations are needed to use this feature.

Your system and its operating system must be configured to:

For more information, see the Compaq Tru64 UNIX system management documentation. For Compaq Tru64 UNIX Version 4.0, you can use the following check list:

  1. Either have a large swap space or use deferred swap allocation. This involves either:
  2. Reconfigure the UNIX kernel (for Version 4.0 or later) to change the following parameters as desired. For example, on one system, all values were set to 16 GB:
    Parameter Explanation
    max-per-proc-address-space Largest address space
    max-per-proc-data-size Largest data size
    max-per-proc-stack-size Largest stack size
    vm-maxvas Largest virtual-memory

    Also set the following per-process values:
    Parameter Explanation
    per-proc-address-space Default address space
    per-proc-data-size Default data size
    per-proc-stack-size Default stack size

    The per-process limits can be checked and increased with the limit or ulimit commands.

You can create big objects as static data, automatic data (stack), or dynamically allocated data (ALLOCATE statement or other means).

The address space limitations depends on the Alpha processor generation in use:

Although the compiler produces code that computes 63-bit signed addresses, objects and addresses larger than the hardware limitations will not work.

Limitations of using big objects include:

The following small example program allocates a big character object: 


    character xx(2_8**31+100_8) 
    integer*8 i 
    i = 10 
    xx(i) = 'A' 
    i = 2_8**31 + 100_8 
    xx(i) = 'B' 
    print *,xx(10_8) 
    print *,xx(i) 
    end

1.13.4 New Random Number Algorithm

A new random_number intrinsic (Version 4.0 or later) uses a different algorithm than the one previously used.

The test program below shows the use of the random_seed and random_number intrinsics. 


     program testrand 
        intrinsic random_seed, random_number 
        integer size, seed(2), gseed(2), hiseed(2), zseed(2) 
        real harvest(10) 
        data seed /123456789, 987654321/ 
        data hiseed /-1, -1/ 
        data zseed /0, 0/ 
        call random_seed(SIZE=size) 
        print *,"size ",size 
        call random_seed(PUT=hiseed(1:size)) 
        call random_seed(GET=gseed(1:size)) 
        print *,"hiseed gseed", hiseed, gseed 
        call random_seed(PUT=zseed(1:size)) 
        call random_seed(GET=gseed(1:size)) 
        print *,"zseed gseed ", zseed, gseed 
        call random_seed(PUT=seed(1:size)) 
        call random_seed(GET=gseed(1:size)) 
        call random_number(HARVEST=harvest) 
        print *, "seed gseed ", seed, gseed 
        print *, "harvest" 
        print *, harvest 
        call random_seed(GET=gseed(1:size)) 
        print *,"gseed after harvest ", gseed 
     end program testrand

When executed, the program produces the following output: 


%  testrand
 size            2 
 hiseed gseed          -1          -1         171         499 
 zseed gseed            0           0  2147483562  2147483398 
 seed gseed    123456789   987654321   123456789   987654321 
 harvest 
  0.6099895      0.9807594      0.2936640      0.9100146      0.8464803 
  0.4358687      2.5444610E-02  0.5457680      0.6483381      0.3045360 
 gseed after harvest    375533067  1869030476

1.13.5 Compaq Fortran 77 Pointers

Compaq Fortran 77 pointers are CRAY® style pointers, an extension to the Fortran 90 standard. The POINTER statement establishes pairs of variables and pointers, as described in the Compaq Fortran Language Reference Manual.

1.13.6 Extended Precision REAL (KIND=16) Floating-Point Data

The X_float data type is a little endian IEEE-based format that provides extended precision. It supports the REAL*16 Compaq Fortran Q intrinsic procedures. For example, the QCOS intrinsic procedure for the generic COS intrinsic procedure.

The value of REAL (KIND=16) data is in the approximate range: 6.475175119438025110924438958227647Q-4966 to 1.189731495357231765085759326628007Q4932.

Unlike other floating-point formats, there is little if any performance penalty from using denormalized extended-precision numbers, since accessing denormalized numbers do not result in an arithmetic trap (extended-precision is emulated in software). (The smallest normalized number is 3.362103143112093506262677817321753Q-4932.)

The precision is approximately one part in 2**112 or typically 33 decimal digits.

The X_float format is emulated in software. Although there is no standard IEEE little endian 16-byte REAL data type, the X_float format supports IEEE exceptional values.

For more information, see the revised Compaq Fortran User Manual for Tru64 UNIX and Linux Alpha Systems and the Compaq Fortran Language Reference Manual.

1.13.7 Variable Format Expressions (VFEs)

By enclosing an arithmetic expression in angle brackets, you can use it in a FORMAT statement wherever you can use an integer (except as the specification of the number of characters in the H field). For example: 


 J = 5 
 FORMAT (I<J+1>)

For more information, see the Compaq Fortran Language Reference Manual.

1.13.8 Notes on Debugger Support

Compaq Tru64 UNIX provides both the dbx and the Compaq Ladebug (formerly DECladebug) debuggers in the programming environment subsets.

These debuggers are very similar and use almost identical set of commands and command syntax. Both have a command-line interface as well as a Motif® windowing interface.

A character-cell Ladebug (ladebug) interface is provided with Ladebug in the Compaq Tru64 UNIX operating system Programmer's Development Toolkit. To use the character-cell interface, use the ladebug command.

When using Ladebug with certain versions of the UNIX operating system, be aware that a trailing underscore may be needed to display module variables. For example, to display variable X in module MOD, type: 


print $MOD$X$_

The Parallel Software Environment supports debugging parallel HPF programs (see the DIGITAL High Performance Fortran 90 HPF and PSE Manual). This section addresses scalar (nonparallel) debugging.

When using the f90 command to create a program to be debugged using dbx or ladebug , consider using the following options:

For example, the following command creates the executable program proj_dbg.out for debugging with Ladebug: 


% f90 -g -ladebug -o proj_dbg.out file.f90

You invoke the character-cell Ladebug debugger by using the ladebug command.

For more information, see the debugger chapter in the revised Compaq Fortran User Manual for Tru64 UNIX and Linux Alpha Systems (Chapter 4).

1.13.8.1 Ladebug Debugger Support Notes

The following improvements in Ladebug support for the Compaq Fortran language were added for DIGITAL UNIX Version 4.0:

The following improvements in Ladebug support for the Fortran 90 language were added for DEC OSF/1 Version 3.2 (DECladebug V3.0-16):

For more information on using Ladebug, see the debugger chapter in the revised Compaq Fortran User Manual for Tru64 UNIX and Linux Alpha Systems (Chapter 4).

1.13.8.2 dbx Debugger Support Notes

When using dbx with HP Fortran programs, certain differences exist. For example, in dbx , assumed-shape arguments, allocatable arrays, and pointers to arrays are printed as a derived type. Consider the following program: 


    module foo 
          real x 
    contains 
          subroutine bar(a) 
          integer a(:) 
          a(1) = 1 
          end subroutine bar 
    end module foo 
 
    use foo 
    integer b(100) 
    call bar(b) 
    end

If the above program were stopped inside BAR, the following would occur: 


    (dbx) print a 
       common / 
         dim = 1 
         element_length = 4 
         ptr = 0x140000244 
         ies1 = 4 
         ub1 = 10 
         lb1 = 1 
       /

The meaning of the fields are:

dim - dimension of the object
element_length - the length of each element in bytes
ptr - the address of the object
iesn - distance (in bytes) between elements in the nth dimension
ubn - upper bound in the nth dimension
lbn - lower bound in the nth dimension

1.13.9 Notes on Fast Math Library Routines

The f90 option -math_library fast provides alternate math routine entry points to the following:

1.13.10 The HP Fortran Array Descriptor Format

In the Compaq Fortran User Manual for Tru64 UNIX and Linux Alpha Systems, Chapter 10, Section 10.1.7 describes the Compaq Fortran array descriptor format.

These notes are an initial attempt to provide a template for those C programmers creating an a .h file that lays out the Fortran array descriptor format.

There are two varying parameters for this descriptor format:

Common information for all descriptors is the general layout of the header and the information for each dimension.

One possible C @codefont(struct) definition for the per-dimension information is: 


 struct _f90_array_dim_info { 
   int inter_element_spacing; 
   int pad1; 
   int upper_bound; 
   int pad2; 
   int lower_bound; 
   int pad3; 
 };

The inter-element spacing is measured in 8-bit bytes, not in array elements. This presents a challenge in designing array descriptor definitions in C, since there is no completely clean way to interact with C's pointer arithmetic.

One way to design the struct definition for an array descriptor is to use the template: 


 
 struct _f90_array_desc_rank<RANK>_<NAME_TOKEN> { 
   unsigned   char   dim; 
   unsigned   char   flags; 
   unsigned   char   dtype; 
   unsigned   char   class; 
   int               pad; 
   long              length; 
   <ELEMENT_TYPE> *  pointer; 
   long              arrsize; 
   void *            addr_a0; 
   struct _f90_array_dim_info dim_info[<RANK>]; 
 };

Where <RANK>, <NAME_TOKEN> and <ELEMENT_TYPE> are the template parameters. Often <NAME_TOKEN> and <ELEMENT_TYPE> can be the same, but in cases where <ELEMENT_TYPE> has non-identifier characters in it (for example, space or star) then a suitable <NAME_TOKEN> should be devised.

The problem with this approach is that the element addressing, which uses the inter-element spacing, generates an offset in bytes. In order to use C's native pointer arithmetic, either casts need to be done or a division. For example:

Another way to design the struct definition for an array descriptor is to use the template: 


 
struct _f90_array_desc_rank<RANK>_general { 
  unsigned char  dim; 
  unsigned char  flags; 
  unsigned char  dtype; 
  unsigned char  class; 
  int            pad; 
  long           length; 
  char *         pointer; 
  long           arrsize; 
  void *         addr_a0; 
  struct _f90_array_dim_info dim_info[<RANK>]; 
};

An advantage to this approach is that the same definition can be used for all arrays of the same rank. The problem with this approach is that it forces the programmer to cast: 


 
*((<ELEMENT_TYPE> *) (desc->pointer + byte_offset))

Another approach is to remove <RANK> from the template as well, yielding: 


 
struct _f90_array_desc_general { 
   unsigned char  dim; 
   unsigned char  flags; 
   unsigned char  dtype; 
   unsigned char  class; 
   int            pad; 
   long           length; 
   char *         pointer; 
   long           arrsize; 
   void *         addr_a0; 
   struct _f90_array_dim_info dim_info[7]; 
};

On the last line, 7 is used since that is the maximum rank allowed by Fortran. Since the dim field should be checked, this definition can be used in many (perhaps most) of the places a rank-specific definition would be used, provided the programmer is aware that the dim_info fields beyond the actual rank are undefined.

One place such a definition should NOT be used is when an object of this definition is used as part of an assignment. This usage is considered rare. For example: 


 
  void 
  ptr_assign_buggy(struct _f90_array_desc_general * ptr, 
  struct _f90_array_desc_general * tgt) 
  { 
  *ptr = *tgt; 
  }

Example of Array Descriptor Format Use

In this example, we have a 'struct tree' and a procedure prune_some_trees_() that takes a descriptor of a rank=3 array of such structs and calls prune_one_tree_() on each individual tree (by reference): 


 
void 
prune_some_trees(struct _f90_array_desc_general * trees) 
{ 
  if (trees->dim != 3) { 
      raise_an_error(); 
      return; 
    } else { 
      int x,y,z; 
      int xmin = trees->dim_info[0].lower_bound; 
      int xmax = trees->dim_info[0].upper_bound; 
      int xstp = trees->dim_info[0].inter_element_spacing; 
      int ymin = trees->dim_info[1].lower_bound; 
      int ymax = trees->dim_info[1].upper_bound; 
      int ystp = trees->dim_info[1].inter_element_spacing; 
      int zmin = trees->dim_info[2].lower_bound; 
      int zmax = trees->dim_info[2].upper_bound; 
      int zstp = trees->dim_info[2].inter_element_spacing; 
      int xoffset,yoffset,zoffset; 
    for (z = zmin, zoffset = 0; z <= zmax; z+= 1, zoffset += zstp) { 
      for (y = ymin, yoffset = 0; y <= ymax; y+= 1, yoffset += ystp) { 
       for (x = xmin, xoffset = 0; x <= xmax; x+= 1, xoffset += xstp) { 
           struct tree * this_tree = 
            (struct tree *) (trees->pointer + xoffset+yoffset+zoffset); 
         prune_one_tree_(this_tree); 
        } 
      } 
    } 
  } 
}

Compaq would appreciate feedback on which definitions of array descriptors users have found most useful.

Note that the format for array descriptors used by HPF is more complicated and is not described at this time.

Previous Next Contents