Arm Compiler for HPC

See what's new in each release, and access the Release Notes for current and previous versions of Arm Compiler for HPC with Arm Performance Libraries.

To get the latest version, download the Arm Compiler for HPC package, and follow the steps in the installation instructions.

 

Arm Compiler for HPC

Version 18.2

Released: March 22, 2018

What's new in 18.2

Arm Compiler for HPC contains the following packages:

  • Arm Compiler v18.2
  • Arm Performance Libraries v18.2
  • GNU GCC 7.1

New features and enhancements

Arm C/C++/Fortran Compiler 18.2:

  • License management is now switched on by default. Please refer to Arm Allinea Studio licensing for more information about licensing.

  • SIMD math library 'libsimdmath.so' now provides the same set of functions for targeting Vector Length Agnostic (VLA) SVE instructions as it provides for ARM Advanced SIMD instructions. For example, a loop invoking 'double sin(double)' can be auto-vectorized with calls to a VLA implementation of 'sin', which is provided in 'libsimdmath.so'.
    'libsimdmath.so' has increased coverage of vectorized routines from math.h and GLIBC math.h.
    Please refer to Vector math routines for more information about this feature.

  • Debug information has been added for Fortran adjustable arrays and imported modules.

Arm Performance Libraries 18.2:

  • FFT performance improvements. Improvements have been made to a selection of FFTW routines in the library. Users should see enhanced performance for a wide range of transform sizes for 1D complex-to-complex transforms in single and double precision via the basic interface. Improvements have also been made to the advanced interfaces for complex-to-complex, real-to-complex and complex-to-real transforms in single and double precision for transforms of any dimensionality. From this release users are advised to target the FFTW interface in Arm Performance Libraries rather than the FFT routines documented in the Arm Performance Libraries Reference Manual.

  • Thread tuning for level 1 BLAS routines *AXPY, *AXPBY, *SCAL, *COPY. Where possible the number of threads used for these routines may be throttled, compared with the number of threads requested, in order to improve performance.

Refer to the Release Note for details of bug fixes and further information.

Release Note for Release History 18.2

Arm Compiler for HPC 18.2 suite provides a complete compiling environment, with Arm C/C++/Fortran Compiler and Arm Performance Libraries, to develop and tune your HPC applications on Armv8-A based SoCs. This release includes version 18.2 of the Arm Performance Libraries which provides Fortran compatibility with the Arm C/C++/Fortran Compiler. This release also includes GNU GCC 7.1 to provide an optimal experience on the latest Arm HPC systems when using the Arm Performance Libraries and GCC.

It contains the following packages:

  • Arm C/C++/Fortran Compiler 18.2
    Arm Compiler is a Linux user-space C/C++/Fortran compiler tailored for scientific computing, HPC and enterprise workloads. This release includes a number of enhancements and bug fixes.

  • Arm Performance Libraries 18.2
    The Arm Performance Libraries are optimized for AArch64 and for specific AArch64 implementations. These provide BLAS, LAPACK and FFT routines optimized for execution on 64-bit Arm. Please note that there are multiple libraries and module files available for this package. The user should load the most optimal library for their platform.

    This release includes multiple Arm Performance Libraries packages, each of which are optimized for individual Armv8 AArch64 implementations (Cortex-A57, Cortex-A72, Qualcomm Falkor, Cavium ThunderX and ThunderX2CN99). This release includes builds of the libraries which are compatible with GNU GCC 7.1 as well as the Arm Compiler. We recommend you use the version that matches your platform for the best performance. You can also use the generic AArch64 implementation by running:

    GCC 7.1.0 version:
    module load Generic-AArch64/<OS>/<OS_Version>/gcc-7.1.0/<ARMPL_Name>/18.2
    Arm Compiler version:
    module load Generic-AArch64/<OS>/<OS_Version>/arm-hpc-compiler-18.2/<ARMPL_Name>/18.2 
  • GNU GCC 7.1
    A build of GNU's GCC 7.1 release is provided for convenience and for OpenMP/libgfortran compatibility with the Arm Performance Libraries. This is a GNU tool suite and the GPL source code can be downloaded separately. This build is not supported by Arm.

Changes in this Release

  New features and enhancements:

  • Arm C/C++/Fortran Compiler 18.2:
    • License management is now switched on by default. Please refer to the Arm Allinea Studio licensing page on the Arm Developer website for more information about licensing. If you have difficulty with this feature please contact your ARM representative.
    • SIMD math library 'libsimdmath.so' now provides the same set of functions for targeting Vector Length Agnostic (VLA) SVE instructions as it provides for ARM Advanced SIMD instructions. For example, a loop invoking 'double sin(double )' can be auto-vectorized with calls to a VLA implementation of 'sin', which is provided in 'libsimdmath.so'.
      'libsimdmath.so' has increased coverage of vectorized routines from math.h and GLIBC math.h. Please refer to Vector math routines for more information.
    • Debug information has been added for Fortran adjustable arrays and imported modules.
  • Arm Performance Libraries 18.2:
    • FFT performance improvements. Improvements have been made to a selection of FFTW routines in the library. Users should see enhanced performance for a wide range of transform sizes for 1D complex-to-complex transforms in single and double precision via the basic interface. Improvements have also been made to the advanced interfaces for complex-to-complex, real-to-complex and complex-to-real transforms in single and double precision for transforms of any dimensionality. From this release users are advised to target the FFTW interface in Arm Performance Libraries rather than the FFT routines documented in the Reference Manual.
    • Thread tuning for level 1 BLAS routines *AXPY, *AXPBY, *SCAL, *COPY. Where possible the number of threads used for these routines may be throttled, compared with the number of threads requested, in order to improve performance.

Bug fixes:

  • Arm HPC Compiler 18.2:
    • SC-2094: Support for debugging Fortran adjustable arrays.
    • SC-2379: Support for debugging Fortran imported module variables and functions.
    • SC-2431: Fixed an issue with codegen of LDNT1/STNT1 instructions which previously caused a segmentation fault.
    • SC-2433: Improved compilation times.
    • SC-2454: A bug preventing the vectorization of 'sincos' in QMCPACK has been fixed. The fix has been verified on version 3.1.1 of QMCPACK.
  • Arm Performance Libraries 18.2:
    • A-488: Bug fixes to FFTW routines: handle correctly NULL values passed in for inembed and onembed parameters in the advanced interface.
    • A-487: A number of FFT routines have been fixed to cease modifying input data for out-of-place transforms.
    • A-472, A-484: Instances of the library compiled with the Arm Compiler are now built with the -Mrecursive armflang flag to ensure local arrays are put on the stack and avoid problems with parallel calls into serial versions of the library.

Speculation Barrier Support

The Spectre v1 mitigation at https://github.com/ARM-software/speculation-barrier works with Arm Compiler for HPC 18.2. For further background info see

https://developer.arm.com/support/security-update

System Requirements

This suite is supported on the following Linux platforms:

  • AArch64 Redhat 7
  • AArch64 SUSE 12
  • AArch64 Ubuntu 16.04

Installation Instructions

To install the Arm Compiler for HPC suite, you should run the installation script as a privileged user:

./arm-compiler-for-hpc-18.2*.sh

The installer displays the EULA and prompts you to agree to the terms. Type 'yes' at the prompt to agree.

For headless installation, run the installer with the '--accept' command-line parameter to automatically accept the EULA.

To perform a local install, run the installer with the '--install-to <dir>' option.

All packages are unpacked to /opt/arm/<package_name> with environment module files available under /opt/arm/modulefiles. Extra documentation can be found, for each installed package, at /opt/arm/<package_name>/share/. Local installs have the same directory structure starting from the user's chosen installation root.

Once you have obtained a license file from Arm, follow these steps to make it available for use:

  1. Create a directory called 'licenses' within the /opt/arm directory and copy your client license file to it.
  2. If you are using Arm Forge or Arm Performance Reports, and you do not have a separate license for these tools, set the ALLINEA_LICENSE_DIR environment variable to point to /opt/arm/licenses.
  3. If you have a floating license, add the server license file to the machine where Arm Licence Server is installed. Create a directory called 'licenses' within the /opt/arm/licenceserver directory and copy your license file to it. Restart Arm Licence Server to pick up the new floating license.

Please refer to the Arm Allinea Studio licensing page for more information about licensing.

RPMs

The installed packages are shipped as RPMs for RPM based Linux distributions. These RPMs are signed by Arm's HPC GPG key. The public key can be downloaded from:

https://developer.arm.com/-/media/files/keys/GPG-PUB-KEY-ARM-HPC-SW-TOOLS.PUB

This key can be imported by running:

rpm --import GPG-PUB-KEY-ARM-HPC-SW-TOOLS.PUB

Environment Modules

Each installed package has an Environment Module file installed under /opt/arm/modulefiles. You can add this directory to your ${MODULESHOME}/init/.modulespath file or to your $MODULEPATH environment variable. For example:

For SH or BASH shells:

export MODULEPATH=$MODULEPATH:/opt/arm/modulefiles

Alternatively you can use the 'module use' command:

module use /opt/arm/modulefiles

Once your environment has been configured to use the module files, use the 'module avail' command to list the available modules and the 'module load' command to set up your environment to use them.

The main module file for this release is loaded by running:

module load Generic-AArch64/<OS>/<OS_Version>/suites/<SUITE_Mod_Name>/18.2

This will load all of the modules belonging to the packages included with this product with the exception of the Arm Performance Libraries. You can also module load the individual components:

  • Arm C/C++/Fortran Compiler 18.2:
    Generic-AArch64/<OS>/<OS_Version>/arm-hpc-compiler/18.2
  • Arm Performance Libraries 18.2
    GCC 7.1.0 version:

    <Specific_Core>/<OS>/<OS_Version>/gcc-7.1.0/<ARMPL_Name>/18.2

    Arm C/C++/Fortran Compiler version:
    <Specific_Core>/<OS>/<OS_Version>/arm-hpc-compiler-18.2/<ARMPL_Name>/18.2

     

  • GNU GCC 7.1

    Generic-AArch64/<OS>/<OS_Version>/gcc/7.1.0

More information about Environment Modules can be found at http://modules.sourceforge.net

C Libraries

The compilers included with this suite are built to use the C Libraries provided by your linux distribution. If errors such as "ld: cannot find crt1.o" are reported, you will need to install the libraries on your system.

The package names for these libraries are:

  • SUSE and RHEL: glibc-devel
  • Ubuntu: libc6-dev

Known Issues

Arm Compiler 18.2:

  • SC-2540: The vectorization of math routines via -fsimdmath can fail in some cases when targeting SVE.

Documentation

Once installed, each package has a README and Release Notes located at /opt/arm/<package_name>/share.

See Help and tutorials on the Arm Developer website for usage instructions about all the components.

If you require support please contact support-hpc-sw@arm.com

Example Code

There is example code included in this suite as part of the Arm Performance Libraries. This code can be found at /opt/arm/<ARMPL_Name>*<ARMPL_Version>*/examples.

You will need to copy this to a writeable directory and load both the Arm Compiler and Arm Performance Libraries environment modules for the examples to build.

For example:

  1. Copy the examples somewhere writeable:
    cp -r /opt/arm/<ARMPL_Name>-<ARMPL_Version>_Generic-AArch64_<OS>-<OS_Version>_arm-hpc-compiler_18.2_aarch64-linux/examples 
    /some/writable/directory/examples
  2. Change to the directory:
    cd /some/writeable/directory/examples
  3. Load the correct environment modules:
    module load Generic-AArch64/<OS>/<OS_Version>/suites/<SUITE_Mod_Name>/<SUITE_Version>
    module load Generic-AArch64/<OS>/<OS_Version>/arm-hpc-compiler-18.2/<ARMPL_Name>/<ARMPL_Version>
  4. Build it:
    make
    

Uninstalling

For convenience, this package includes an "uninstall.sh" script at /opt/arm/arm-compiler-for-hpc-18.2*/uninstall.sh.

This script attempts to uninstall all the packages supplied as part of this suite. Note that this may not be possible if other packages, outside of this suite, depend on them. You will need to uninstall the dependant packages as well.

Please note that, if you used the --install-to option provided by the installer, you will need to uninstall the packages by manually removing their directories.