第12回配信講義計算科学技術特論A（2021）

富岳での重⼒N体計算
カーネルのチューニング
計算科学技術特論A（2021）
第12回 7⽉1⽇
理化学研究所計算科学研究センター（ R-CCS）
運⽤技術部⾨ソフトウェア開発技術ユニット
技師似⿃啓吾（にたどりけいご）

お知らせ
• 本⽇7/1より「ソフトウェア開発技術ユニット」が発⾜しまし
た
• 旧「チューニング技術ユニット」メンバに加え、幅広い研究分
野の出⾝者が合流します
超⾼速電⼦計算機システムに係るソフトウェア環
境の改善・⾼度化に関する研究開発を⾏うほか、
研究センターにおける次の業務を⾏う。
１）超⾼速電⼦計算機システムへの AI 及び深層
学習機能の最適化等に関すること。
２）ソフトウェア開発環境の整備及び公開・普及
に関すること。

概要
• 富岳で⽤いられているA64FXプロセッサ向けの重⼒N体計算カ
ーネルのチューニング⼿法と結果を紹介する
• SVE (Scalable Vector Extensions)命令拡張を⽤いるために
ACLE (Arm C Language Extensions)の組込関数を⽤いた
• Intel AVX-512を⽤いた同様のコードも作成し、アーキテクチ
ャ間の性能やコンパイラ機能の⽐較した
• 逆数平⽅根の近似命令と収束公式は独⽴した話題とした

背景・ねらい
• 「富岳」のA64FXプロセッサ：
• 命令セットのがSPARC（＋富⼠通拡張）→ARM（SVE拡張）へ
• アーキテクチャレジスタ数が128→32に減少
• 命令レイテンシが9と⼤きい
• 演算器を埋めきるスケジューリングが難しくなっている
• これまで：レジスタ数を活かしてコンパイル時の静的スケジューリング（
ソフトウェアパイプライニング）
• これから：CPUのOut-of-Order実⾏（動的スケジューリング）に頼らざる
を得ない？
• ⼀般解があるわけではないので実機での事例を積み重ねるものとする
• nbodyカーネル：複雑すぎず簡単すぎない
• メモリネックにならない
• 実⽤性も⾼い（𝑂(𝑁log𝑁）のツリー法もこのカーネルを使う）

構成
1. イントロ
2. 逆数平⽅根カーネル
3. Intel AVX-512でのnbodyチューン
4. A64FX Arm SVEでのnbodyチューン

公開コード、バージョン情報
• https://github.com/nitadori/rsqrtCubed にて
• drsqrt-arm.cpp: 倍精度逆数平⽅根の実験
• nbody.cpp: インテル向けnbody実験
• nbody-arm.cpp: A64FX向けnbody実験
• 単なる作業場です
• 使って何か研究してみたい⽅はご⼀報ください
• 再現実験は断りなくどうぞ
• バージョン情報
• 富⼠通⾔語環境： tcsds-1.2.31, FCC 4.5.0
• インテルコンパイラ（OneAPI）： icpc (ICC) 2021.2.0

N体計算の基礎⽅程式
• εはsofteningといって⻑さの
次元を持つパラメタ
• すべてのN 粒⼦への加速度を
計算するにはN 2回の相互作⽤
計算が必要
• 天体の計算だけでなく、分⼦
動⼒学法なども同じような式
のかたちをしている
<latexit sha1_base64="OA7lYFsX8Xqt787tKzsvFwk+wWE=">AAADWHichVHLbtNAFL2Ogbbm0VA2SGxGRC2pgGicIkBIlSpYwAr1lbZS3Vj2dJJM6lfHk0CZ+gf4ARZdgcQC8Rls2CMW5Q8QyyKxYcGNY1QgapmRZ+7jnOMzun4SiFRRemiUzDNnz42NT1jnL1y8NFm+PLWWxj3JeIPFQSw3fC/lgYh4QwkV8I1Eci/0A77u7zwa9Nf7XKYijlbVXsK3Qq8diZZgnsKSWz5wWtJj2gk91ZEh2W7Ws+NEYUYcPyTSFWSePCZO2gtd3Z23s+ZTkjMtHbrdzNJOwFuqioBdqbTT9yRPUhHEUbNObpL9oUaX3P6ttp8rS9HuqNmmnssyqzqCmXXLFVqj+SKjgV0EFSjWYlz+BA5sQwwMehAChwgUxgF4kOLehBbGHHaxfgtsoJBgfws09iVGIsdyyMBCnR4yOCI8rO7g2cZss6hGmA/005zN8I8BfhKZBKbpZ/qOHtGP9D39Sn+eqKVzjYGvPbz9IZcn7uTLqys//ssK8VbQOWad6lnhy+/nXgV6T/LK4BVsyO+/eHW08mB5Ws/QN/Qb+n9ND+kHfEHU/87eLvHlg1P8RHg+Q73nf3g6Ge0jKsPB2v+OcTRYq9fsu7W5pTuVhYfFiMfhGlyHKs7uHizAE1iEBjDDMG4Y1LBLX0wwx8yJIbRkFJwr8Ncyp34B/2TQWg==</latexit>
d2
dC2
r8 = ⌧
#
’
9=1
<9
⇣p
Y2 + |r9 r8 |2
⌘3
(r9 r8)
<latexit sha1_base64="6nPV07uEIx++bQdcSfomXsZGFL0=">AAADSHichVHLahRBFL3dMSbGaCa6UHBTOkQicYbqUVSEQNCFriQPJwlMzzTVbc2kJtWPVNeMxk7/gH6AC1cKLsTPcCNuxUU+QdwoEYLgwjvd7TMkuUVXnbp1z+lzuW4kRawp3TbMoSPDR0dGj40dHz9xcqI0eWo5DnvK43UvlKFadVnMpQh4XQst+WqkOPNdyVfc9duD95U+V7EIg/t6M+JNn3UC0RYe05hySk9tydt6msySit1WzEvsiCktmEx/I2K7PlGOSElW2yCVO8SOe76TdGettHWP5ETf6SIn3lA6sftM8SgWMgxaNTJDtnKFLqn80tpq1VLUU6KzppvFeckplWmVZkH2AqsAZShiPix9ABseQAge9MAHDgFoxBIYxLga0EbMYQPzl8ECChG+NyHBd4VIZLUcUhhDnR4yOFYwzK7j3sFbo8gGeB/oxxnbwz9K/BQyCUzRj/Q13aHv6Bv6if7YVyvJNAa+NvF0cy6PnIknZ5d2D2X5eGpY+8M60LPGzm9kXgV6j7LMoAsv5/cfP9tZurk4lVykL+ln9P+CbtO32EHQ/+a9WuCLzw/wE+D+EPUe/eVp/2oXq1IcrPX/GPeC5VrVula9snC1PHerGPEonIMLMI2zuw5zcBfmoY7qX40zBjHOm+/NL+au+T0vNY2Ccxr+iSHzJxNc0EU=</latexit>
=
m
mr8
"
⌧
#
’
9=1
<9
p
Y2 + |r9 r8 |2
#!

リファレンスコード
• 最内ループのメモリアクセ
スはbody[j]のみ
• 演算をカウントしてみる
• 3-sub
• 3-mad
• 1-rsqrt
• 3-mul
• 3-mad
• madは積和演算（1命令で2
演算できる）
• rsqrtは逆数平⽅根
include <cmath>
struct Body{
float x, y, z, m;
};
struct Acceleration{
float ax, ay, az;
};
void nbody(
const int n,
const float eps2,
const Body body[],
Acceleration acc[])
{
for(int i=0; i<n; i++){
float xi=body[i].x, yi=body[i].y, zi=body[i].z;
float ax=0, ay=0, az=0;
for(int j=0; j<n; j++){
float dx = body[j].x - xi;
float dy = body[j].y - yi;
float dz = body[j].z - zi;
float r2 = eps2 + dx*dx;
r2 += dy*dy;
r2 += dz*dz;
float ri = 1.f / sqrtf(r2);
float mri = body[j].m * ri;
float ri2 = ri * ri;
float mri3 = mri * ri2;
ax += mri3 * dx;
ay += mri3 * dy;
az += mri3 * dz;
}
acc[i] = {ax, ay, az};
}
return;
}

逆数平⽅根の重要性
• 1/ 𝑥の計算にはnaïveには除算と平⽅根が1回ずつ必要になる
• 除算も平⽅根も加減乗算に⽐べて桁で遅い
• 原理は⼈間の筆算や開平法と同じ
• 加減乗算と積和算は12命令しかないのでこのままでは確実にボトルネ
ック！
• 最近のプロセッサでのアプローチ
• 逆数1/𝑥と逆数平⽅根 1/ 𝑥の近似命令をサポート
（SIMDで1〜2サイクルスループット）
• 加減乗算の組み合わせで有効桁数を倍々に増やせる
• 初期値推定の有効ビット数はアーキテクチャごとにマチマチ
• SSE/AVX: 12-bit、AVX-512F: 14-bit、AVX-512ER (KNL): 28-bit、
Fujitsu (Sparc/Arm): 8-bit
• 収束補助の専⽤命令を備えるものも（3DNOW!、Arm SVE）

収束公式の導出
⼀般にn乗根の逆数に対して公式が存在する
1. ⼩さな値hを求める
（正しく計算できていれば0）
2. 多項式𝑝 ℎ を計算
3. 近似値に𝑝 ℎ を掛ける
k次の多項式なら有効桁数は 𝑘 + 1 倍に
<latexit sha1_base64="F5DMtzbsYhv7gxiFzIVFMUqkK4g=">AAAEC3ichVG9b9NAFH+u+Sjho2lZkFhORI0SlYRzqABFQqpgYUHqB2kr1U1ku5f4VPvs2peQYOUfQGJmYAKJATHChNgQEjtiKCssiLFILAw8OyZt+sVZvnv33vv93u/dM32Hh5LSbWVMPXHy1OnxM5mz585fmMhOTi2HXjuwWM3yHC9YNY2QOVywmuTSYat+wAzXdNiKuXk3jq90WBByTzyQPZ+tu0ZL8Ca3DImuxqRyP096DUqqeshdtkUK2ozeMQLmh9zxRJF061FJuyb6RNczOm82SZ7oDmvKArFJ9TbRSIl0SYQM/bogesBbtiwS9Jf2EcXRIcNICLMLWsku1qND6/TiMrsqhhVSzMAdd4DAuBUtztddQ9qBG0mjhw/QTxWPQP4xDaG67duGkJ6L3WgYH7xHCtXIDLGQ207OCrHrFbR0a8OT4V6qRjZHyzRZ5KChpUYO0jXvZT+DDhvggQVtcIGBAIm2AwaE+K1BE20GW+i/ChpQ8DG+DhHGA7R4ksugDxnkaSOCYYaB3k3cW3hbS70C7zF/mKAtrOjgHyCSwDT9Ql/RHfqJvqY/6J8juaKEI9bVw9McYJnfmHh8aen3f1EunhLsXdSxmiV2fivRylG7n3jiLqwBvvPo6c5SdXE6ytMX9Cfqf0636QfsQHR+WS8X2OKzY/QI3B8iX3ePpqOzTczq42C1/WM8aCxXytqN8vWF2dzcnXTE43AZrkABZ3cT5uAezEMNLOWt8lX5pnxXn6hv1Hfq+0HqmJJiLsLIUj/+BYj8Bq8=</latexit>
H0 :' (1 + Y)G 1/=
() (⌘ := 1 GH0
=
) = 1 (1 + Y)=
() 1 + Y = (1 ⌘)1/=
()
⇣
H := G 1/=
⌘
= (1 ⌘) 1/=
H0
H1 := taylor
⇣
(1 ⌘) 1/=
⌘
H0
' 1 + 21⌘ + 22⌘2
+ · · · H0

具体例
• 逆数
• 逆数平⽅根
<latexit sha1_base64="wiBiQREPOGPZUcJDJhsni7Jlx/c=">AAADG3ichVHLahRREK20rzg+MupGcHNxSIhoxupEVAJC0I3LPJwkkE6a7s6d6Uv6le4744xDfsAfcCEuFFyInxEXIu4ki3yCupyAGxee7mnwERLr0nWrTtWpPpdyk0Blmnl/xDhx8tTpM6NnK+fOX7g4Vr10eTmL26knG14cxOmq62QyUJFsaKUDuZqk0gndQK64W4/y+kpHppmKoye6l8j10GlFqqk8RwOyqxs9m8XErJWpUG4L83ZXWFbFB/JAmGJKdEVeB9SzzQLM05tDMJBNPSl8pP7GdOFn4C1vM9aZsFLV8vUNu1rjOhcmDgdmGdSotPm4+oUs2qSYPGpTSJIi0ogDcijDWaMmYknbwG+RSUwJ6uvURz1FpIpeSTtUwZw2GBIdDtAt+BaytRKNkOfzs4Lt4Y8BvhRMQeO8x+94wB/5PX/ln0fO6hczcl093O6QKxN77PnVpR//ZYW4Nfm/Wcdq1nj5/UKrgvakQPJXeEN+59mLwdLs4nh/gt/wd+h/zfu8ixdEnQPv7YJcfHmMngj+KeZ1/9B0dLeLrh0s1vx3jYeD5em6ebc+s3CnNvewXPEoXaPrNInd3aM5ekzz1MD0D/SNBnRgvDJ2jU/G52GrMVJyrtBfZuz9Aj5kuf0=</latexit>
H0 :' 1/G
⌘ := 1 GH0
H1 := H0 + H0 ⌘ + ⌘2
+ ⌘3
+ · · ·
<latexit sha1_base64="zto1s2pYx8J+JNmHuC//zhtWe8Q=">AAADQHichVHLahRBFL3d8ZGMjxnjJsFN4ZAQUceqGU1CQAi6cZmHkwTSsemu1EwX6ddU14yZNLNy5w+4cKXgQvwL3bgXF/kDgwuRCIK48HZPg4+QWEVXnXvuPbdPcd3Yl4mmdN8wR06dPnN2dKx07vyFi+XKpfG1JOoqLpo88iO14TqJ8GUomlpqX2zESjiB64t1d+d+ll/vCZXIKHyo+7HYCpx2KFuSOxopu/Kkb1MyvWAlMhAdwm5ZSUdpskssq+Qhf5cwchPDFMsGj+oZ3bdZnsiE1/PT8kVLzxCrpRzO6sRDOseNeeKhpojupGx2gEQjI/h2pBNiKdn29DW7UqU1mi9yFLACVKFYS1HlA1iwDRFw6EIAAkLQiH1wIMG9CS3EAjrI3wAGFGLMb0GKeYVI5rUCBlDCPl1UCKxwkN3Bs43RZsGGGGf9k1zN8Y8+fgqVBKboR/qaHtL39A09oD+P7ZXmPTJffbzdoVbEdvnpxOr3/6oCvDV4v1Unetb48vncq0Tvcc5kr+BDfW/v2eHqwspUOk1f0s/o/wXdp+/wBWHvG3+1LFaen+AnxPMx9tv9w9Px1S5WDXCw7N8xHgVr9RqbrTWWb1cX7xUjHoUrcBVmcHZzsAgPYAma2P3AKBsTxqT51vxkfjG/DktNo9Bchr+W+eMXjhfE6g==</latexit>
H0 :' 1/
p
G
⌘ := 1 GH0
2
H1 := H0 + H0
✓
1
2
⌘ +
3
8
⌘2
+
5
16
⌘3
+ · · ·
◆
参考：逆数と平⽅根を求める⾼次収束アルゴリズム
http://www.finetune.co.jp/~lyuka/technote/fract/sqrt-jp.html

Break：
• 係数を求める程度
ならブラウザと⽇
本語でOK
• 昔ならMaxima、
最近ならSymPy
が便利かも

実装例(1)
<latexit sha1_base64="7J5Zyvm7nJ0Gwy5rep5jtOAHPok=">AAAEOXicjVFLb9NAEJ7YFEIoNCkXJC4rokZIKemuy0uVkCq4cOyDtJXqYtnutrXqV+xNSLDyB/gDHDiBxAHxEzhy4Y449AgnHscgceHA2HHs0KqPtb2enZnvsRrDt61QUHpQkORzE+cvFC+WLk1evjJVrkyvhV47MHnT9Gwv2DD0kNuWy5vCEjbf8AOuO4bN1439R3F9vcOD0PLcJ6Ln8y1H33WtHcvUBaa0SiHqaZQsPKixOTVsBYJ0Z4naauvbpKtFc0ofS4Q27hBVWA4PSZeoagnfGNV/qsRAEhOk5SRUS3sjaC3B3hpxpV0jMHb2NJZx1MeZUopMjeVqLFdjZ1NjmVrOUR9nOqym5GpKrqacTU3J1OYzjvo4U6amlau0QZNFjgYsDaqQriWv/BlU2AYPTGiDAxxcEBjboEOIzybsYMyhhflZYEDBx/oWRFgPMLKSXg59KCFPGxEcO3TM7uO+i6fNNOviOeYPE7SJijZ+ASIJzNAv9B0d0E/0Pf1B/x7LFSUcsa8e/o0hlvva1Itrq39ORTn4F7CXo070LPDm9xOvFnr3k0x8C3OI7zx/OVhdWJmJavQN/YX+X9MD+hFv4HZ+m2+X+cqrE/y4uD9Dvu6Yp+O7Dezq42DZ4TEeDdaUBrvbmF++XV18mI64CNfhBtzE2d2DRXgMS9AEs/BNKkoVaVr+IH+Vv8s/h61SIcVchf+WPPgHDAoOZw==</latexit>
H0 :=1/
p
G, G/2 := 0.5 ⇥ G
H0
2
:=H0 ⇥ H0
⌘/2 :=0.5 G/2 ⇥ H0
2
H1 :=H0 + H0 ⇥ ⌘/2
H1
2
:=H1 ⇥ H1
⌘/2 :=0.5 G/2 ⇥ H1
2
H2 :=H1 + H1 ⇥ ⌘/2
H2
2
:=H2 ⇥ H2
⌘/2 :=0.5 G/2 ⇥ H2
2
H3 :=H2 + H2 ⇥ ⌘/2
void drsqrt_nr(
const double * __restrict xs,
double * __restrict ys,
const int N)
{
svbool_t p0 = svptrue_b64();
const svfloat64_t half = svdup_f64(1./2.);
svfloat64_t x = svld1_f64(p0, xs + 0);
for(int i=0; i<N; i+=8){
// svfloat64_t x = svld1_f64(p0, xs + i);
svfloat64_t x2 = svmul_f64_x(p0, x, half);
svfloat64_t y = svrsqrte_f64(x);
x = svld1_f64(p0, &xs[i+8]);
svfloat64_t y2 = svmul_f64_x(p0, y, y);
svfloat64_t h2 = svmsb_f64_x(p0, x2, y2, half);
y = svmad_f64_x(p0, y, h2, y);
y2 = svmul_f64_x(p0, y, y);
h2 = svmsb_f64_x(p0, x2, y2, half);
y2 = svmul_f64_x(p0, y, y);
h2 = svmsb_f64_x(p0, x2, y2, half);
svst1_f64(p0, ys + i, y); // 12 instructions
}
}

補⾜
• 2倍公式を3回繰り返したもの
• 近似命令の8-bitが有効なので倍精度(53-bit)に⼗分
• みみっちいが、x/2の値は再利⽤できる
• 必要な数値定数も0.5のみ
• 実は富⼠通コンパイラの出⼒もほぼ同等
• ただし異常値対応のため⽐較命令がひとつ多い
• （単精度の場合コンパイラは3倍公式を1発出す）
• ストア命令もFPUのパイプを消費する
• ロード命令は消費しない
• これも勘定するとループあたりFPUを12命令消費
理論限界は6 cycle/loop

実装例(2)
• SVEにある収束補助命令を使ってみる
• マニュアルには記述が⾒当たらないがこのような動作になって
いるようだ
• 実質的には単なる積和算
• 数値定数によるレジスタ消費がゼロ
• 積和の後処理として指数部を減じて0.5倍をしているものと思われる
• 𝑦!
は事前に計算しておく必要あり
• mul, rsqrts, mulの3命令で有効ビット数が2倍になる
• (1)の実装と⽐べてxに0.5を掛ける1命令が少なくて済む
<latexit sha1_base64="DwjFhXUY0mcbhL+APUIaOcjUgDI=">AAADB3ichVG/axRBFP6yaoxRk1MbwWbwiFxIPGYvoiIIQRtJlR9eEsgmx+46dzdkf2V27rxz2T9A/wELKwWLYKGV2IqNvSik0lYsI9hY+HZvQZOQ+Iad+ea99337Dc+JPBlrzneGjGPHTwyfHDk1evrM2bHx0rnzy3HYUa6ou6EXqlXHjoUnA1HXUntiNVLC9h1PrDibd7P6SleoWIbBfd2PxLpvtwLZlK6tKdUozVm+rdtaJyreUjpOK71p1t+oTbLbzGoq201m2FXWy1JpUkuZ5YmmrlDRnMrLZo21maVkq60nG6Uyr/I82EFgFqCMIubD0idYeIAQLjrwIRBAE/ZgI6a1hiZhgS3KT8MER0T1dSRUV4Rk3iuQYpR0OsQQ1GFTdpP2Ft3WimxA90w/ztku/dGjTxGTYYJ/5tt8l3/kr/h3/vtQrSTXyHz16XQGXBE1xp9cXPr1X5ZPp0b7L+tIz5pefjP3Ksl7lGeyV7gDfvfR092lW4sTyRX+gv8g/8/5Dv9ALwi6P92XC2Lx2RF+Atofkl7vH0+HdzvUldJgzf1jPAiWa1XzenVm4Vp59k4x4hFcwmVUaHY3MIt7mEed1N/gC77im/HYeG28Nd4NWo2hgnMBe8J4/wenIrem</latexit>
rsqrts(G, H2
) =
3 GH2
2
✓
= 1 +
1
2
⌘
◆

実装例(3), (4)
• ⼀発で7倍の有効桁数を得る公式（実装3、11命令）
• 最後の⾏は直列の命令依存を緩和したもの(実装4)
• Tree height reductionという最適化
• h 2の計算のため演算数が増えて12命令
<latexit sha1_base64="nb4Miix9c99o+AgnGK0jDpuUmfg=">AAADzXicnVFLaxNRFD7T8VHjI2ndCG4uhpYEJdxJYisFoejGnX2YtpBJh5nrTebSeTlzMxpj3Ar+ARe6Uagg/gw37sVFf4K4rODGhedOpthYWsEzzD2v7zv3uxwn8kQiKd3TpvRTp8+cnT5XOH/h4qViaWZ2Iwn7MeMtFnphvOXYCfdEwFtSSI9vRTG3fcfjm87OXdXfTHmciDB4IAcR7/h2LxBdwWyJJWtGKw4sgyzdnicDi5LrxM28KYXPExJV3CoxzYLyCsIQqiCmx7uygml9Mm1Mps3J9GaWMmuBmLHoubK6PTTTyLUDGfrEFKP/Kyt9BE3pqxwIRGVVFWzXx9e3VauRt5oHrcohTdV8XscqlWmNZkaOBkYelCG3lbD0BUx4CCEw6IMPHAKQGHtgQ4JfG7oYc3iE9RtgAIUI+x0YYj/GSGRYDiMo4Jw+MjgibKzu4NnDrJ1XA8zV/CRjM7zRwz9GJoE5+pV+oPv0M/1Iv9Ffx84aZjOUrgF6Z8zlkVV8eWX95z9ZPnoJ7h/WiZolvvxWplWg9iirqFewMT99+mp/fWltbjhP39HvqP8t3aOf8AVB+oPtrvK11yfoCfB8jPOeHNJ0PNpB1AgXa/y9xqPBRr1mLNQaq83y8p18xdNwFa5BBXe3CMtwD1agBUxLtTfarvZev6/39Wf68zF0Sss5l2HC9Be/AfAf7ao=</latexit>
H1 :=H0 + ⌘H0 ⇥ ?(⌘)
?(⌘) :=21 + ⌘ 22 + ⌘ (23 + ⌘ (24 + ⌘ (25 + ⌘26)))
:=(21 + ⌘22) + ⌘2
⇥
(23 + ⌘24) + ⌘2
(25 + ⌘26)
⇤

測定結果
• Software pipeliningを切ったもの（-Kfast,noswp）ではスケジューリ
ングはCPU任せ
• それなりにout-of-orderが効いている(50%程度の効率)
• Software pipeliningが有効（-Kfast）のとき、70〜80%の効率
• やはり命令数が少ないものが速い
• ⾼次の多項式はいまいち（レジスタプレッシャーが原因か？）
• 富⼠通コンパイラはtrad modeでないと良好なswpスケジューリング
は得られない
• clang modeの今後に期待
実装命令数
サイクル数
備考
noswp swp
autovec 13 15.0 8.2 コンパイラ⾃動ベクトル化
(1) NR x3 12 14.8 7.4 2倍公式を3回
(2) rsqrts 11 12.7 7.2 収束補助命令を3回
(3) x7 11 11.9 7.8 6次の多項式
(4) x7 THR 12 11.9 7.9 ↑tree height reduction

ループアンロールと
ソフトウェアパイプライニング
• ループの持つ並列度を利⽤して演算器を飽和させる
• レジスタ本数に対するプレッシャーは増加
A(i);
B(i);
C(i);
}
for(int i=0; i<n; i+=4){
A(i); B(i); C(i);
A(i+1); B(i+1); C(i+1);
A(i+2); B(i+2); C(i+2);
A(i+3); B(i+3); C(i+3);
}
A(i); A(i+1); A(i+2); A(i+3);
B(i); B(i+1); B(i+2); B(i+3);
C(i); C(i+1); C(i+2); C(i+3);
}
A(0);
A(1); B(0);
for(int i=0; i<n-3; i+=3){
A(i+2); B(i+1); C(i);
A(i+3); B(i+2); C(i+1);
A(i+4); B(i+3); C(i+2);
}
A(n-1); B(n-2); C(n-3);
B(n-1); C(n-2);
C(n-1);
基本のループ（擬似コード）
ループアンローリング
アンロール＋スケジューリング
（ストライピング）
ソフトウェアパイプライニング

レイテンシとスループット
• 最近のCPUの中⾝は流れ作業（パイプライン）
• レイテンシ（Cycle per Instruction, CPI）
• 演算結果が利⽤可能になるまで待つ時間
• ⽐喩：⾞を発注してから納品されるまでの⽇数
• スループット（CPIもしくはIPC, Instruction per Cycle）
• その命令が演算器を専有する時間（CPI）
• ⽐喩：⼀⽇に何台の⾞を⽣産できるか（IPC）
• IPC（⼤きいほど良い）のほうが直感的なこともあるけどレイ
テンシと単位を揃えてCPI（⼩さい⽅が良い）で書くことが多
い
• 例：A64FXのFMA命令ならL-T=9-0.5
（9-1のユニットが2つあるとも）

例：Intel© Intinsic guideより

N体計算に有効な⽅法
• 逆数平⽅根を補正してから3乗するよりは、3乗してから補正す
るほうが少し有利
• 演算数が1つ減る（𝑟!"
に再利⽤性がある）
• 直列な命令依存が減り命令レベル並列度が上がる
• 補正多項式は 1 − ℎ !#/"
のテイラー展開
<latexit sha1_base64="IEVwHqXdim6XAYISwoxcb+FY504=">AAAEunichVFJb9NAFH4xBkpYmsIFicuIqFVR2zB2WKqIShVcOHYhbaW6iWxnEpt4iz0JFCs/AI5w4MAJJA6In8GFO+LQn4A4FolLDzwvTZo4LWPZ8+ab9y3j0TzLDDilBznhnHj+wsWpS/nLV65emy7MXN8K3K6vs6ruWq6/o6kBs0yHVbnJLbbj+Uy1NYtta+0n0f52j/mB6TrP+L7H9my15ZhNU1c5QvWZ3NEcUbhpNRjxa+GS1CcVJTBt1iHSXSXo+Dz0a3KfKEp+pA+hysoYEVc2C0bBRaJ0umqD2OMmKwmUISRORtQgkSUE5Qlt8lC3/vzkRjlWzrhNUkiM7DF2bJwVTQWMY1svOX3TV/WyTBaQNrCIMBJK9/vLxw7DYFnhhQnYQMxLf3tsqVisyeeJnTah2FjEZF9CyUEwY7BIAhk1WfHNlsHvpFO9UKQlGg+SLaS0KEI61tzCD1CgAS7o0AUbGDjAsbZAhQCfXWhizaCD+CJIQMHD/T0Icd/Hyox7GfQhjzpdZDDsUBFt47eFq90UdXAd6QcxW0dHC18fmQRm6U/6hR7S7/Qr/UWPTtUKY40o1z7OWsJlXn36zc3Nv/9l2ThzMIasMzNzPPlynNXE7F6MRKfQE37v1fvDzcrGbDhHP9HfmP8jPaDf8ARO74/+eZ1tfDgjj4PfF6j38kSm07s17OrjxUrj15gttuSS9KBUXr9XXH2cXvEU3ILbMI939xBW4SmsQRV0QRdeC2+Fd+IjURNNsZ20CrmUcwNGhsj/AbX1QQ0=</latexit>
Ã 1
:' 1/
p
A2
Ã 2
:= Ã 1
⇥ Ã 1
, <Ã 1
:= < ⇥ Ã 1
⌘ := 1 A2
⇥ Ã 2
, <9Ã 3
:= <Ã 1
⇥ Ã 2
<Ã 3
⌘ := <9Ã 3
⇥ ⌘, ? := 3
2 + ⌘ ⇥ 15
8
<A 3
:= <9Ã 3
+ <9Ã 3
⌘ ⇥ ?
<A 3
= <Ã 3
1 + 3
2 ⌘ + 15
8 ⌘2
※以降は単精度を仮定します

外側ループと内側ループの並列度
• 外側ループ
• i-loop、i 並列
• ⼒を受ける粒⼦についての並
列度
• 可能ならこちらでのSIMD化
が望ましい
• j 粒⼦を1つ読んでくると
SIMD幅（16）の分再利⽤性
がある
• 内側ループ
• j-loop、j 並列
• ⼒を及ぼす粒⼦についての並
列度
• こちらでSIMD化すると、
ループの最後に縮約（総和）
演算が必要
• AoSからSoAへ変更しないと
性能を出しづらい
void nbody(
const int n,
const float eps2,
const Body body[],
Acceleration acc[])
{
float xi=body[i].x, yi=body[i].y, zi=body[i].z;
float r2 = eps2 + dx*dx;
r2 += dy*dy;
r2 += dz*dz;
float ri = 1.f / sqrtf(r2);
float mri = body[j].m * ri;
float ri2 = ri * ri;
float mri3 = mri * ri2;
ax += mri3 * dx;
ay += mri3 * dy;
az += mri3 * dz;
}
}
return;
}

コンパイラの対応状況
• Intel
• ディレクティブを付けることで外側（i ）ループのSIMD化にも対応
• 富⼠通
• 最内（j ）ループのみ⾃動的にSIMD化
• 最後の⽔平総和も出⼒してくれる
• 今回は双⽅のアーキテクチャに向けて外側ループの⼿動SIMD
化を⾏った

Intel編
• oneAPIとして今年から無償提供されるようになったコンパイ
ラを利⽤
• icpc -fast -qopt-zmm-usage=high -qopenmp nbody.cpp –S
icpx -fopenmp nbody.s
• デフォルトで256-bitのymmレジスタコードを出すので512-bitのzmm
レジスタを使うように
• OpenMPはHyper-Threadingのテスト⽤
• CascadeLake Xeonのクロックを2.0 GHzに固定して計測
• $ sudo cpupower frequency-set --min 2.0GHz --max 2.0GHz
• 外側もしくは内側もループにSIMD化ディレクティブを付けた
• #pragma omp simd
をループの前に付けるだけ

ソースコードの微変更
#pragma omp simd
const float xi=body[i].x, yi=body[i].y,
zi=body[i].z;
...
ax += mri3 * dx;
ay += mri3 * dy;
az += mri3 * dz;
}
}
#pragma omp simd
const float xi=body[i].x, yi=body[i].y,
zi=body[i].z;
float dx = xi - body[j].x;
float dy = yi - body[j].y;
float dz = zi - body[j].z;
...
ax -= mri3 * dx;
ay -= mri3 * dy;
az -= mri3 * dz;
}
}
broadcastss (%rsi,%r14), %zmm1
vbroadcastss 4(%rsi,%r14), %zmm2
vbroadcastss 8(%rsi,%r14), %zmm3
vsubps %zmm28, %zmm1, %zmm18
vsubps (%rsi,%r14){1to16}, %zmm28, %zmm19
vsubps 4(%rsi,%r14){1to16}, %zmm25, %zmm20
vsubps 8(%rsi,%r14){1to16}, %zmm26, %zmm22
放送ロードがメモリオペランドになっている
Before After

改善できそうな点
• 逆数平⽅根が
SVML callにな
っている
• Short Vector
Math Library
• KNLのときは
vrsqrt28ps⼀発
だった
..B2.6: # Preds ..B2.6 ..B2.5
# Execution count [1.25e+01]
vbroadcastss (%rsi,%r14), %zmm1 #24.15
incq %r12 #23.3
vbroadcastss 4(%rsi,%r14), %zmm2 #25.15
vbroadcastss 8(%rsi,%r14), %zmm3 #26.15
vmovaps %zmm20, %zmm0 #28.25
vsubps %zmm28, %zmm1, %zmm18 #24.27
vfmadd231ps %zmm18, %zmm18, %zmm0 #28.25
..___tag_value__Z11nbody_ipar0ifPK4BodyP12Acceleration.77:
call *__svml_invsqrtf16_z0@GOTPCREL(%rip) #32.21
..___tag_value__Z11nbody_ipar0ifPK4BodyP12Acceleration.78:
vmulps 12(%rsi,%r14){1to16}, %zmm0, %zmm4 #34.28
addq $16, %r14 #23.3
vmulps %zmm0, %zmm0, %zmm5 #35.21
vmulps %zmm5, %zmm4, %zmm6 #37.23
cmpq %r15, %r12 #23.3
jb ..B2.6 # Prob 82% #23.3

Intrinsic版
• ⼿動でSIMD化したもの
• rsqrtCubedは7命令、計
16命令
• GCCやClangもこのコー
ドを受け付ける（はず）
• #include <x86intrin.h>
が必要
{
const __m512 eps2 = _mm512_set1_ps(eps2_ss);
__m512 xi, yi, zi, mi;
transpose_4AoStoSoA(body+i, xi, yi, zi, mi);
__m512 ax, ay, az;
ax = ay = az = _mm512_set1_ps(0);
__m512 xj = _mm512_set1_ps(body[j].x);
__m512 yj = _mm512_set1_ps(body[j].y);
__m512 zj = _mm512_set1_ps(body[j].z);
__m512 mj = _mm512_set1_ps(body[j].m);
__m512 dx = _mm512_sub_ps(xi, xj);
__m512 dy = _mm512_sub_ps(yi, yj);
__m512 dz = _mm512_sub_ps(zi, zj);
__m512 r2 = _mm512_fmadd_ps(dx, dx, eps2);
r2 = _mm512_fmadd_ps(dy, dy, r2);
r2 = _mm512_fmadd_ps(dz, dz, r2);
__m512 mri3 = rsqrtCubed(r2, mj);
ax = _mm512_fnmadd_ps(mri3, dx, ax);
ay = _mm512_fnmadd_ps(mri3, dy, ay);
az = _mm512_fnmadd_ps(mri3, dz, az);
}
transpose_3SoAtoAoS(ax, ay, az, acc+i);
}
}

性能値
• 内側ループSIMD化ではgathe命令が出ているが性能は良好
• 理論限界8.5 cycleに対して⼿動版は71%の効率
• Gflops値は相互作⽤数あたり「歴史的な係数38」を掛けたもの
、実際の演算数は24程度（ FMAを２演算それ以外を１演算）
cycle Gflops Remark
i-par 16.9 71.9 外側ループSIMD
j-par 16.9 71.9 内側ループSIMD
intrin 11.9 102.6 ⼿動SIMD（外側）

Hyper-Threading
• 1コアで2スレッド⾛らせることでスケジューリングを改善でき
る可能性がある
• 2スレッドがひとつのコアに当たるように以下の環境変数に
export KMP_AFFINITY=granularity=fine,compact
export OMP_NUM_THREADS=2
• 1割弱の改善はあったのだが、2スレッド実⾏環境でシングルス
レッド実⾏が遅くなってしまった
（裏で待機しているスレッドのせい？）
• 実アプリでは⾜を引っ張りそう
cycle(nt=1) cycle(nt=2)
ipar 16.9 21.4
jpar 16.9 21.4
intrin 11.9 15.0
intrin+omp 11.9 11.0

構造体アクセス命令とレジスタ内転置
• 外側ループであるが、
{x,y,z,m}[16] -> {x[16],y[16],z[16],m[16]}
{ax[16],ay[16],az[16]} –> {ax,ay,az}[16]
のような転置がある
• SVEにはld4、st3のようなstructure load/store命令がある
• AVX-512にそういうのはないのでレジスタ内で転置する
• 今回はボトルネックではないけどgather/scatteするのも悔しいので
• ⼀度作っておくと使い回しが効く
• 命令セットの格好の練習問題
• MDなど粒⼦をリストアクセスするケース、body[j]ではなく
body[idx[j]]が必要になるケースには有⽤

Transpose_4AoStoSoA
• 2つのレジスタを連結さ
せて任意の要素を取り
出してくるという強⼒
な命令がある
c[i] = (a~b)[idx[i]]
• この命令でちょとした
テーブル参照もできる
r0 x0 y0 z0 m0 ・・・ x3 y3 z3 m3
r1 x4 y4 z4 m4 ・・・ x7 y7 z7 m7
r2 x8 x8 z8 m8 ・・・ x11 y11 z11 m11
r3 x12 y12 z12 m12 ・・・ x15 y11 z11 m15
xzlo x0 x4 z0 z4 ・・・ x3 x7 z3 z7 unpcklo(r0,r1)
ymlo y0 y4 m0 m4 ・・・ y3 y7 m3 m3 unpckhi(r0,r1)
xzhi x8 x12 z8 z12 ・・・ x11 x11 z11 z11 unpcklo(r2,r3)
ymhi x8 x8 m8 m12 y11 y11 m11 m11 unpckhi(r2,r3)
xv x0 x1 x2 x3 ・・・ x12 x13 x14 x15 vpermt2ps(xzlo,xzhi)
yv y0 y1 y2 y3 ・・・ y12 y13 y14 y15 vpermt2ps(ymlo,ymhi)
zv z0 z1 z2 z3 ・・・ z12 z13 z14 z15 vpermt2ps(xzlo,xzhi)
mv m0 m1 m2 m3 ・・・ m12 m13 m14 m15 vpermt2ps(ymlo,ymhi)

Transpose_3SoAtoAoS
• 128-bit単位のシャッ
フル命令を使⽤
ax x[0-3] x[4-7] x[8-11] x[12-15]
ay y[0-3] x[4-7] y[8-11] y[12-15]
az x[0-3] z[4-7] z[8-11] z[12-15]
xylow x[0-3] x[4-7] y[0-3] x[4-7] vshuff32x4(ax,ay)
xymid x[4-7] x[8-11] x[4-7] y[8-11] vshuff32x4(ax,ay)
xyhig x[8-11] x[12-15] y[8-11] y[12-15] vshuff32x4(ax,ay)
az z0 z1 z2 z3 ・・・ z12 z13 z14 z15
a0 x0 y0 z0 ・・・ x5 vpermt2ps(xlow,az)
a1 y5 z5 ・・・ x10 y10 vpermt2ps(xmid,az)
a2 z10 ・・・ x15 y15 z15 vpermt2ps(xhig,az)

Fujitsu ARM編
• とりあえずコンパイラの⾃動SIMD化から
• 性能が出るのはtradモード、clangモードはまだまだこれから
• 内側ループを⾃動SIMD化、gather命令が出てしまう
• Structure load命令は出してくれないようだ
（構造体をfloat[n][4]の配列に書き換えても出ない）
• SoA（x[n], y[n], z[n], m[n]）に並び替えた版も作ってみた
• ソフトウェアパイプライニングが効いている
• コンパイルオプションは単に-Kfastもしくは-Kfast,noswp
• 18命令のループなのでコンパイラ任せで理論限界の半分
Cycle(noswp) Cycle(swp)
Gather 39.7 32.0
SoA 25.7 17.9

ACLE版
• Structure load/store命令を
外側ループに使⽤
• 外側ループを更にハンドア
ンロールしたバージョンも
作成した（ni32）
• ソフトウェアパイプライニン
グはそれでも効いた
void nbody_sve(
const int n,
const float eps2_ss,
const Body body[],
Acceleration acc[])
{
const svfloat32_t eps2 = svdup_f32(eps2_ss);
const svfloat32_t one = svdup_f32(1.0);
const svfloat32_t a = svdup_f32( 3./2.);
const svfloat32_t b = svdup_f32(15./8.);
const svbool_t p0 = svptrue_b32();
svfloat32x4_t ibody = svld4_f32(p0, (const float *)(body+i));
svfloat32_t xi = svget4_f32(ibody, 0);
svfloat32_t yi = svget4_f32(ibody, 1);
svfloat32_t zi = svget4_f32(ibody, 2);
svfloat32_t ax, ay, az;
ax = ay = az = svdup_f32(0);
svfloat32_t xj = svdup_f32(body[j].x);
svfloat32_t yj = svdup_f32(body[j].y);
svfloat32_t zj = svdup_f32(body[j].z);
svfloat32_t mj = svdup_f32(body[j].m);
svfloat32_t dx = svsub_f32_x(p0, xj, xi);
svfloat32_t dy = svsub_f32_x(p0, yj, yi);
svfloat32_t dz = svsub_f32_x(p0, zj, zi);
svfloat32_t r2 = svmad_f32_x(p0, dx, dx, eps2);
r2 = svmad_f32_x(p0, dy, dy, r2);
r2 = svmad_f32_x(p0, dz, dz, r2);
svfloat32_t mri3 = rsqrtCubed(r2, mj, p0, one, a, b);
ax = svmla_f32_x(p0, ax, mri3, dx);
ay = svmla_f32_x(p0, ay, mri3, dy);
az = svmla_f32_x(p0, az, mri3, dz); // 17-ops
}
svfloat32x3_t acci = svcreate3_f32(ax, ay, az);
svst3_f32(p0, (float *)(acc+i), acci);
}
}
cycle eff. Gflops
ACLE 16.1 52.8 75.5
ni32 14.8 57.6 82.3
理論限界を8.5 cycle/loop
相互作⽤あたり38 flopと仮定

スケジューリングの
為の再計算
• 正直こんなことをやって速くな
るとは思わなかった
• ループ分割することになったらや
ろうと思っていたアイデア
• 座標の差分（dx, dy, dz）は⻑
寿命の変数
• 再計算すれば使い捨てにできる
• *bodyと*body2を別引数として渡
しておけばコンパイラに⾒抜かれ
ずに再計算させられる
svfloat32_t xj = svdup_f32(body[j].x);
svfloat32_t yj = svdup_f32(body[j].y);
svfloat32_t zj = svdup_f32(body[j].z);
svfloat32_t mj = svdup_f32(body[j].m);
svfloat32_t dx_0 = svsub_f32_x(p0, xj, xi_0);
svfloat32_t dy_0 = svsub_f32_x(p0, yj, yi_0);
svfloat32_t dz_0 = svsub_f32_x(p0, zj, zi_0);
svfloat32_t dx_1 = svsub_f32_x(p0, xj, xi_1);
svfloat32_t dy_1 = svsub_f32_x(p0, yj, yi_1);
svfloat32_t dz_1 = svsub_f32_x(p0, zj, zi_1);
svfloat32_t r2_0 = svmad_f32_x(p0, dx_0, dx_0, eps2);
r2_0 = svmad_f32_x(p0, dy_0, dy_0, r2_0);
r2_0 = svmad_f32_x(p0, dz_0, dz_0, r2_0);
svfloat32_t r2_1 = svmad_f32_x(p0, dx_1, dx_1, eps2);
r2_1 = svmad_f32_x(p0, dy_1, dy_1, r2_1);
r2_1 = svmad_f32_x(p0, dz_1, dz_1, r2_1);
svfloat32_t mri3_0 = rsqrtCubed(r2_0, mj, p0, one, a, b);
svfloat32_t mri3_1 = rsqrtCubed(r2_1, mj, p0, one, a, b);
// load again
xj = svdup_f32(body2[j].x);
yj = svdup_f32(body2[j].y);
zj = svdup_f32(body2[j].z);
mj = svdup_f32(body2[j].m);
// subtract again
dx_0 = svsub_f32_x(p0, xj, xi_0);
dy_0 = svsub_f32_x(p0, yj, yi_0);
dz_0 = svsub_f32_x(p0, zj, zi_0);
dx_1 = svsub_f32_x(p0, xj, xi_1);
dy_1 = svsub_f32_x(p0, yj, yi_1);
dz_1 = svsub_f32_x(p0, zj, zi_1);
ax_0 = svmla_f32_x(p0, ax_0, mri3_0, dx_0);
ay_0 = svmla_f32_x(p0, ay_0, mri3_0, dy_0);
az_0 = svmla_f32_x(p0, az_0, mri3_0, dz_0);
ax_1 = svmla_f32_x(p0, ax_1, mri3_1, dx_1);
ay_1 = svmla_f32_x(p0, ay_1, mri3_1, dy_1);
az_1 = svmla_f32_x(p0, az_1, mri3_1, dz_1);
}
cycle eff. Gflops
ACLE 16.1 52.8 75.5
ni32 14.8 57.6 82.3
recalc 14.3 59.5 85.1
この段階で理論限界は10 cycleにな
っているが8.5 cycleで効率は計算

無駄命令の削減
• svdup_f32()に対して2種類の出⼒が混ざっ
ている
• 良い例：
• ld1rw {z25.s}, p0/z, [x4]
• 放送ロード命令、演算パイプを消費しない
• 悪い例：
• ldr s30, [x4, 4]
dup z0.s, z0.s[0]
• スカラロードとレジスタ間放送、演算パイプを消費する
• 仕⽅ないので⼿動で置換した
• ldrで取れた負のオフセットがld1rwでは取れない
のが⾯倒
• 18箇所修正、休憩と検証を⼊れて1箇所数分程度
cycle eff. Gflops
ACLE 16.1 52.8 75.5
ni32 14.8 57.6 82.3
recalc 14.3 59.5 85.1
asmtune 13.6 62.6 89.5

まとめ
• 性能値まとめ
• Intel: 12.0 cycle, 71.2%, 102 Gflops (+10% w/ HT)
• A64FX: 13.6 cycle, 62.6%, 89.5 Gflops
• 理想値は共に8.5 cycle、共に2.0 GHzで実⾏
相互作⽤あたり38演算換算
• チューニングのエフォート率は7:3でA64FX重視
• A64FXの性能に効くのは変わらずソフトウェアパイプライニング
• 素直に書いたnbodyコードにもACLE版にもコンパイラはswpを適⽤できた
• コンパイラとは仲良くしよう
• 式変形で演算数や命令レベル並列を改善できると気持ちがいい
• コンパイラの知らない情報を活⽤する
• ⾃動チューニングを研究する⼈には未開の探索空間を提供できたと思
う

第12回配信講義計算科学技術特論A（2021）

Empfohlen

Empfohlen

Weitere ähnliche Inhalte

Was ist angesagt?

Was ist angesagt? (20)

Ähnlich wie 第12回配信講義計算科学技術特論A（2021）

Ähnlich wie 第12回配信講義計算科学技術特論A（2021） (20)

Mehr von RCCSRENKEI

Mehr von RCCSRENKEI (20)

Kürzlich hochgeladen

Kürzlich hochgeladen (20)