SVE Hackathon SC18

Introduction

The information here is provided to support the participants of the Arm SVE Hackathon at the Supercomputing Conference 2018.

• Presentations
• Hackathon materials
• Arm Architecture Reference Manual Supplement for the Scalable Vector Extension (SVE)
• SVE ACLE Specification
• Building and running a basic SVE example
• Training systems
• Related information

Hackathon materials

You'll need the following materials for this hackathon:

• ArmIE SVE emulator tutorial
• ArmIE demos package

Arm Architecture Reference Manual Supplement for the Scalable Vector Extension (SVE)

This supplement describes the Scalable Vector Extension to the ARMv8-A architecture profile. This is an EAC release.

Download the SVE supplement

This documentation package contains 3 folders:

• PDF - contains a PDF file describing the Scalable Vector Extension. This PDF is the primary product document.
• SVE_SysReg - contains the System register descriptions in XML and HTML formats.
• SVE_xml - contains the instruction descriptions in XML and HTML formats.

In a number of places, the PDF file contains links to files in one of the other folders. These links are formatted with blue text and underlining in order to make them clearly identifiable. Clicking on a link in the PDF file will open the corresponding HTML file, which will render in your default browser.

To browse the HTML files for the instructions directly, navigate to the folder SVE-xml/xhtml and open the file index.html.

Building and running a basic SVE example

In this example we show how to add two C arrays with the SVE Arm C language Extension (ACLE) intrinsics, using the Vector Length Agnostic (VLA) programming model. Step-by-step instructions on how to build the code with an SVE compiler and run the executable with Arm Instruction Emulator (ArmIE) are shown after the code.

#include <stdlib.h>
#include <stdio.h>
#include <arm_sve.h>

// Scalar version.
void add_arrays(double * restrict dst, double *src, double c, const int N) {
  for (int i = 0; i < N; i++)
    dst[i] = src[i] + c;
}

// Vector version
void vla_add_arrays(double * restrict dst, double *src, double c, const int N) {
  int64_t i = 0;

  svbool_t pg = svwhilelt_b64(i, (int64_t)N);
  while (svptest_any(svptrue_b64(), pg)) {
    svfloat64_t vsrc = svld1(pg, src + i);
    svfloat64_t vdst = svadd_x(pg, vsrc, c);
    svst1(pg, dst + i, vdst);

    i += svcntd();
    pg = svwhilelt_b64(i, (int64_t)N);
  }
}

int main(void) {
  double src[100];
  double c;
  double dst_serial[100], dst_vla[100];
  for (int i = 0; i < 100; ++i) {
    src[i] = (double) i / ((double) i + 1);
  }

  c = src[rand() % 100];

  add_arrays(dst_serial, src, c, 100);
  vla_add_arrays(dst_vla, src, c, 100);

  for (int i = 0; i < 100; ++i) {
    printf("%f %f\n", dst_serial[i], dst_vla[i]);
  }
  return 0; 
}

Procedure

1. Load the required compiler module. To use Arm Compiler for HPC:
   module load Generic-AArch64/RHEL/7/suites/arm-compiler-for-hpc/19.0
   Or, to use GCC:
   module load Generic-AArch64/RHEL/7/gcc/8.2.0
   
   Note: If you encounter an error, check that the required environment module is available, by typing module avail. You may need to configure the MODULEPATH environment variable to include the installation directory:
   export MODULEPATH=$MODULEPATH:/opt/arm/modulefiles/

2. Load the Arm Instruction Emulator module:
   module load Generic-AArch64/SUSE/12/suites/arm-instruction-emulator/18.4
3. Compile the example program:
   {armclang|gcc} -O2  -march=armv8-a+sve -o program example.c 
4. Run Arm Instruction Emulator on the generated binary:
   armie -msve-vector-bits=1024 ./program

Training systems

This hackathon is graciously supported by hardware and software from Arm's partners. Instructors will provide login information for each of the systems on the day of the event.

Related information

For a more detailed description of SVE, why it is useful for HPC, or to see some example code, see the following additional resources on SVE:

• What is SVE?
  A brief introduction to Scalable Vector Extension (SVE)
• Why SVE for HPC?
  A short introduction as to why SVE is beneficial for HPC.
• White Paper: A sneak peek into SVE and VLA programming 
  An overview of SVE with information on the new registers, the new instructions, and the Vector Length Agnostic (VLA) programming technique, with some examples.
• White Paper: Arm Scalable Vector Extension and application to Machine Learning 
  In this white paper, code examples are presented that show how to vectorize some of the core computational kernels that are part of machine learning system. These examples  are written with the Vector Length Agnostic (VLA) approach introduced by the Scalable Vector Extension (SVE).
• ARM C Language Extensions for SVE
  The SVE ACLE defines a set of C and C++ types and accessors for SVE vectors and predicates.
• DWARF for the ARM® 64-bit Architecture (AArch64) with SVE support 
  This document describes the use of the DWARF debug table format in the Application Binary Interface (ABI) for the Arm 64-bit architecture.
• Procedure Call Standard for the ARM 64-bit Architecture (AArch64) with SVE support
  This document describes the Procedure Call Standard use by the Application Binary Interface (ABI) for the Arm 64-bit architecture.
• ARM Architecture Reference Manual Supplement - The Scalable Vector Extension (SVE), for ARMv8-A
  This supplement describes the Scalable Vector Extension to the Armv8-A architecture profile.
• Arm Instruction Emulator
  Arm Instruction Emulator (ArmIE) runs on AArch64 platforms and emulates SVE instructions.
• Arm HPC tools
  Learn more about Arm's compilers, math libraries, debugging and profiling tools.