GCC Guide for Ampere Processors

This text was initially revealed by Ampere Computing.

This paper describes methods to successfully use GNU Compiler Assortment (GCC) choices to assist optimize software efficiency on Ampere Processors.

When making an attempt to optimize an software, it’s important to measure if a possible optimization improves efficiency. This contains compiler choices. Utilizing superior compiler choices might lead to higher runtime efficiency, probably at the price of elevated compile time, extra debug difficulties, and infrequently elevated binary dimension. Why compiler choices have an effect on efficiency is past the scope of this paper, though the quick reply is that code technology, fashionable processor architectures and the way they work together are very difficult! One other necessary level is that completely different processors might profit from completely different compiler choices due to variations in laptop structure, and the particular microarchitecture. Repeated experimentation with optimizations is vital to efficiency success.

The best way to measure an software’s efficiency to find out the limiting components, in addition to optimization methods have already been coated in articles beforehand revealed. The paper, The First 10 Questions to Answer While Running on Ampere Altra-Based Instances, describes what efficiency information to gather to know your entire system’s efficiency. A Performance Analysis Methodology for Optimizing Ampere Altra Family Processors explains methods to optimize successfully & effectively utilizing a data-driven strategy.

This paper first summarizes the most typical GCC choices with an outline of how these choices have an effect on purposes. The dialogue then turns to current case research utilizing GCC choices to enhance efficiency of VP9 video encoding software program and MySQL database for Ampere Processors. Related methods have been successfully used to optimize extra software program working on Ampere Processors.

GCC Suggestions

The GCC compiler gives many choices that may enhance software efficiency. See the GCC website for particulars. To generate code that takes benefit of all of the efficiency options out there in Ampere Processors, use the gcc -mcpu choice.

To make use of the gcc -mcpu choice, both set the CPU mannequin or inform GCC to make use of the CPU mannequin based mostly on the machine that GCC is working on through -mcpu=native. Be aware on legacy x86 based systems, gcc -mcpu is a deprecated synonym for -mtune, whereas gcc -mcpu is totally supported on Arm based mostly programs. See Arm’s information to Compiler flags across architectures: -march, -mtune, and -mcpu for particulars.

In abstract, each time attainable, use solely -mcpu and keep away from -march and -mtune when compiling for Arm. Under is a case examine highlighting efficiency good points by setting the gcc -mcpu choice with VP9 video encoding software program.

Setting the -mcpu choice:

• -mcpu=ampere1: Generate code that can run on AmpereOne Processors. AmpereOne is the following technology of Cloud Native Processors from Ampere, extending the household of high-performance processors to new trade main core counts. Be aware, this may generate code that won’t run on Ampere Altra and Altra Max Processors. This selection was initially out there in GCC model 12.1 and later, then backported to GCC 10.5 and GCC 11.3.

• -mcpu=neoverse-n1: Generate code that can run on Ampere Altra, Ampere Altra Max in addition to Ampere AmpereOne. Whereas utilizing this feature for code that can run on Ampere AmpereOne is supported, it would probably not reap the benefits of all the brand new efficiency options out there. Be aware, GCC model 9.1 or larger is required to allow CPU particular tunings for Ampere Altra and Ampere Altra Max processors.

• -mcpu=native: Generate code setting the CPU mannequin based mostly on the CPU GCC is working on. Be aware, GCC model 9.1 or larger is required to allow CPU particular tunings for Ampere Altra and Ampere Altra Max processors.

Utilizing -mcpu=native is probably simpler to make use of, though it has a possible downside if the executable, shared library, or object file are used on a special system. If the construct was executed on an Ampere AmpereOne Processor, the code might not run on an Ampere Altra or Altra Max Processor as a result of the generated code might embody Armv8.6+ directions supported on Ampere AmpereOne Processors. If the construct was executed on an Ampere Altra or Altra Max processor, GCC won’t reap the benefits of the most recent efficiency enhancements out there on Ampere AmpereOne Processors. It is a basic situation when constructing code to reap the benefits of efficiency options for any structure.

The next desk lists what GCC variations that assist Ampere Processor -mcpu values.

Our suggestion is to make use of the gcc -mcpu choice with the suitable worth described above (-mcpu=ampere1, -mcpu=neoverse-n1 or -mcpu=native) with -O2 to ascertain a baseline for efficiency, then discover extra optimization choices and measuring if completely different choices enhance efficiency in comparison with the baseline.

Abstract of widespread GCC choices:

• -mcpu Really useful when constructing on Ampere Processors to allow processor particular tuning and optimizations. (See dialogue “Setting the -mcpu choice” part above for particulars.)

• -Os Optimize to cut back code dimension, probably in case your software is proscribed by fetching directions.

• -O2 Thought of customary GCC optimization choice and good to make use of as a baseline to check with different GCC choices.

• -O3 Provides extra optimizations to generate extra environment friendly codes for loops, helpful to strive in case your software efficiency is dominated by time spent in loops.

• Profile Guided Optimization (PGO): -fprofile-generate & -fprofile-use. Generate profile information that the compiler will use to probably make higher choices on optimizations reminiscent of inlining, loop optimizations and default branches. That is thought of a complicated optimization because it requires modifications to the construct system, see beneath.

• Hyperlink-Time Optimization (LTO): -flto. Allow link-time optimizations, permitting the compiler to optimize throughout particular person supply information. This allows features to be inlined throughout supply information amongst different compiler optimizations. That is additionally thought of a complicated optimization and probably requires modifications to the construct system. This selection will increase total construct time, which will be dramatic for giant purposes. It’s attainable to make use of LTO simply on efficiency essential supply information to probably lower construct occasions.

VP9 Video Encoding Case Research with gcc -mcpu

VP9 is a video coding format developed by Google. libvpx is the open-source reference software program implementation for the VP8 and VP9 video codecs from Google and the Alliance for Open Media (AOMedia). libvpx gives vital enchancment in video compression over x264 with the expense of extra computation time. Extra info on VP9 and libvpx is accessible on Wikipedia.

On this case examine, the VP9 construct is configured to make use of the gcc -mcpu=native choice to enhance efficiency. As talked about above, use the -mcpu choice when compiling on Ampere Processors to allow CPU particular tuning and optimizations. Initially libvpx was constructed utilizing the default configuration after which rebuilt utilizing -mcpu=native. To judge VP9 efficiency, a 1080P enter video file, original_videos_Sports_1080P_Sports_1080P-0063.mkv from the YouTube’s User Generated Content Dataset was used. See Ampere’s ffmpeg tuning and build guide for particulars on methods to construct ffmpeg and varied codecs together with VP9 for Ampere Processors.

Default libvpx Construct:

$ git clone https://chromium.googlesource.com/webm/libvpx
$ cd libvpx/
$ export CFLAGS="-mcpu=native -DNDEBUG -O3 -U_FORTIFY_SOURCE -D_FORTIFY_SOURCE=0 -D_LARGEFILE_SOURCE -D_FILE_OFFSET_BITS=64 -Wall -Wdeclaration-after-statement -Wdisabled-optimization -Wfloat-conversion -Wformat=2 -Wpointer-arith -Wtype-limits -Wcast-qual -Wvla -Wimplicit-function-declaration -Wmissing-declarations -Wmissing-prototypes -Wuninitialized -Wunused -Wextra -Wundef -Wframe-larger-than=52000 -std=gnu89"
$ export CXXFLAGS="-mcpu=native -DNDEBUG -O3 -U_FORTIFY_SOURCE -D_FORTIFY_SOURCE=0 -D_LARGEFILE_SOURCE -D_FILE_OFFSET_BITS=64 -Wall -Wdisabled-optimization -Wextra-semi -Wfloat-conversion -Wformat=2 -Wpointer-arith -Wtype-limits -Wcast-qual -Wvla -Wmissing-declarations -Wuninitialized -Wunused -Wextra -Wno-psabi -Wc++14-extensions -Wc++17-extensions -Wc++20-extensions -std=gnu++11 -std=gnu++11"
$ ./configure
$ make verbose=1 
$ ./vpxenc --codec=vp9 --profile=0 --height=1080 --width=1920 --fps=25/1 --limit=100 -o output.mkv /dwelling/joneill/Movies/original_videos_Sports_1080P_Sports_1080P-0063.mkv --target-bitrate=2073600 --good --passes=1 --threads=1 –debug

The best way to Optimize libvpx Construct with -mcpu=native

$ # rebuild with -mcpu=native
$ make clear
$ export CFLAGS="-mcpu=native -DNDEBUG -O3 -U_FORTIFY_SOURCE -D_FORTIFY_SOURCE=0 -D_LARGEFILE_SOURCE -D_FILE_OFFSET_BITS=64 -Wall -Wdeclaration-after-statement -Wdisabled-optimization -Wfloat-conversion -Wformat=2 -Wpointer-arith -Wtype-limits -Wcast-qual -Wvla -Wimplicit-function-declaration -Wmissing-declarations -Wmissing-prototypes -Wuninitialized -Wunused -Wextra -Wundef -Wframe-larger-than=52000 -std=gnu89"
$ export CXXFLAGS="-mcpu=native -DNDEBUG -O3 -U_FORTIFY_SOURCE -D_FORTIFY_SOURCE=0 -D_LARGEFILE_SOURCE -D_FILE_OFFSET_BITS=64 -Wall -Wdisabled-optimization -Wextra-semi -Wfloat-conversion -Wformat=2 -Wpointer-arith -Wtype-limits -Wcast-qual -Wvla -Wmissing-declarations -Wuninitialized -Wunused -Wextra -Wno-psabi -Wc++14-extensions -Wc++17-extensions -Wc++20-extensions -std=gnu++11 -std=gnu++11"
$ ./configure 
$ make verbose=1 
# confirm the construct makes use of the sdot dot product instruction:
$ objdump -d vpxenc | grep sdot | wc -l
128
$ ./vpxenc --codec=vp9 --profile=0 --height=1080 --width=1920 --fps=25/1 --limit=100 -o output.mkv /dwelling/joneill/Movies/original_videos_Sports_1080P_Sports_1080P-0063.mkv --target-bitrate=2073600 --good --passes=1 --threads=1 --debug

An investigation utilizing Linux perf to measure the variety of CPU cycles within the features that took probably the most time embody the features vpx_convolve8_horiz_neon and vpx_convolve8_vert_neon. The libvpx git repository reveals these features have been optimized by Arm to make use of the Armv8.6-A USDOT (mixed-sign dot-product) instruction which is supported by Ampere Processors.

The CPU cycles spent in vpx_convolve8_horiz_neon was decreased from 6.07E+11 to 2.52E+11 utilizing gcc -mcpu=native to allow the dot product optimization on an Ampere Altra processor, lowering the CPU cycles by an element of two.4x.

For vpx_convolve8_vert_neon, the CPU cycles have been decreased from 2.46E+11 to 2.07E+11, for a 16% discount.

Total, utilizing -mcpu=native to allow the dot product instruction sped up transcoding the file original_videos_Sports_1080P_Sports_1080P-0063.mkv by 7% on an Ampere Altra processor by enhancing the applying throughput. The next desk reveals information collected utilizing the perf file and perf report utilities to measure CPU cycles and directions retired.

GCC Profile Guided Optimization

This part gives an summary of GCC’s Profile Guided Optimization (PGO) and a case examine of optimizing MySQL with PGO. Profile Information Optimizations allow GCC to make higher optimization choices, together with optimizing branches, code block reordering, inlining features and loops optimizations through loop unrolling, loop peeling and vectorization. Utilizing PGO requires modifying the construct setting to do a 3-part construct.

1. Construct software with Profile Guided Optimization, gcc -fprofile-generate.
2. Run software on consultant workloads to generate the profile information.
3. Rebuild software utilizing the profile information, gcc -fprofile-use.

A problem of utilizing PGO is the extraordinarily excessive efficiency overhead in step 2 above. Because of the gradual efficiency working an software constructed with gcc -fprofile-generate, it is probably not sensible to run on programs working in a manufacturing setting. See the GCC handbook’s Program Instrumentation Options part to construct purposes with run-time instrumentation and the part Options That Control Optimization for rebuilding utilizing the generated profile info for added particulars.

As described within the GCC handbook, -fprofile-update=atomic is beneficial for multi-threaded purposes, and might enhance efficiency by amassing improved profile information.

When to Use PGO?

With PGO, GCC can higher optimize purposes by offering extra info reminiscent of measuring branches taken vs. not taken and measuring loop journey counts. PGO is a helpful optimization to attempt to see if it improves efficiency. Efficiency signatures the place PGO might assist embody purposes with a major proportion of department mispredictions, which will be measured utilizing the perf utility to learn the CPU’s Efficiency Monitoring Unit (PMU) counter BR_MIS_PRED_RETIRED. Giant numbers of department mispredictions result in a excessive proportion of front-end stalls, which will be measured by the STALL_FRONTEND PMU counter. Functions with a excessive L2 instruction cache miss price might also profit from PGO, probably associated to mis-predicted branches. In abstract, a big proportion of department mispredictions, CPU entrance finish stalls and L2 instruction cache misses are efficiency signatures the place PGO can enhance efficiency.

MySQL database GCC PGO Case Research

MySQL is the world’s hottest open-source database and because of the big MySQL binary dimension, is a perfect candidate for utilizing GCC PGO optimization. With out PGO info, it’s inconceivable for GCC to accurately predict the various completely different code paths executed. Utilizing PGO vastly reduces department misprediction, L2 instruction cache miss price and CPU entrance finish stalls on Ampere Altra Max Processor.

Summarizing how MySQL is optimized utilizing GCC PGO:

1. sysbench was used to judge MySQL efficiency
2. GCC PGO was skilled utilizing MySQL MTR (mysql-test-run) test suite
3. Sysbench’s oltp_point_select and oltp_read_only checks have been used to measure efficiency with PGO construct in comparison with the default construct
4. The variety of threads used have been then various from 1 to 1024, giving a median pace up of 29% for the oltp_point_select and 20% for the oltp_read_only take a look at on an Ampere Altra Max M128-30 processor
5. With 64 threads, PGO improved efficiency by 32% by enhancing MySQL’s throughput

Extra particulars will be discovered on the Ampere Developer’s web site within the MySQL Tuning Guide.

Abstract

Optimizing purposes requires experimenting with completely different methods to find out what works finest. This paper gives suggestions for various GCC compiler optimizations to generate excessive performing purposes working on Ampere Processors. It highlights utilizing the -mcpu choice as the simplest approach to generate code that takes benefit of all of the options supported by Ampere Cloud Native Processors. Two case research, for MySQL database and VP9 video encoder, present the usage of GCC choices to optimize these purposes the place efficiency is essential.

Constructed for sustainable cloud computing, Ampere’s first Cloud Native Processors ship predictable excessive efficiency, platform scalability, and energy effectivity unprecedented within the trade. We invite you to study extra about our developer efforts and discover finest practices at developer.amperecomputing.com and be a part of the dialog at community.amperecomputing.com.