ホイール欲しい ハンドル欲しい

ARM Cortex-A7 は big.LITTLE で用いられる場合、省電力側の CPU core に相当します。
消費電力が少ない代わりに、高性能側の CPU core より性能は劣ります。
VFP Benchmark の結果を送ってもらいました。

結果を見ると、Cortex-A7 の NEON は 32bit 単位で実行していることがわかります。
演算速度は NEON 無しの CPU と変わらないのですが、Cortex-A15 のペアとして
機能できるよう NEON 命令セットに対応しているものと考えられます。

SIMD (Vector)         SIMD4 single fp (32bit x4)
CPU                   mul    add     mad     fma
------------------------------------------------------
ARM Cortex-A7         1      1       2       2
ARM Cortex-A8         2      2       4       –
ARM Cortex-A9         2      2       4       –
ARM Cortex-A15        4      4       8       8
Qualcomm Scorpion     4      4       8       –
Qualcomm Krait 400    4      4       8       8
Apple A6 Swift        4      4       8       8
Apple A7 Cyclone 32   8      12      16      16
Apple A7 Cyclone 64   8      12      –       16

  * 数値は 1 cycle あたりの演算数、大きい方が速い

・FPU の演算能力 (上記以外の結果はこちら)

big.LITTLE で用いる場合は、この手の演算は Cortex-A15 の担当なので
おそらく表に出ることは無いでしょう。
単独で用いられている場合は、同じ Quad core CPU と書かれていても
かなり性能差が開いていることを考慮した方が良いかもしれません。
浮動小数点演算速度だけ見てもピーク演算速度で Cortex-A9 の半分、
Krait/Cortex-A15 の 1/4 (同一クロック時) となっています。

以下詳細

Lenovo YOGA TABLET 8 (3G)
MediaTek MT8389 1.2GHz Cortex-A7 Quad core

SingleT SP max: 2.374 GFLOPS
SingleT DP max: 1.165 GFLOPS
MultiT  SP max: 9.474 GFLOPS
MultiT  DP max: 4.653 GFLOPS

* VFP/NEON (single fp)
VFP fmuls (32bit x1) n8       :    3.634     1100.7     1100.7
VFP fadds (32bit x1) n8       :    3.450     1159.3     1159.3
VFP fmacs (32bit x1) n8       :    3.451     2318.1     2318.1
VFP vfma.f32 (32bit x1) n8    :    3.448     2319.9     2319.9
NEON vmul.f32 (32bit x2) n8   :    6.795     1177.3     1177.3
NEON vadd.f32 (32bit x2) n8   :    6.828     1171.7     1171.7
NEON vmla.f32 (32bit x2) n8   :    6.810     2349.6     2349.6
NEON vfma.f32 (32bit x2) n8   :    6.797     2354.1     2354.1
NEON vmul.f32 (32bit x4) n8   :   13.529     1182.7     1182.7
NEON vadd.f32 (32bit x4) n8   :   13.511     1184.2     1184.2
NEON vmla.f32 (32bit x4) n8   :   13.498     2370.7     2370.7
NEON vfma.f32 (32bit x4) n8   :   13.549     2361.8     2361.8

倍精度の場合はさらに差が広がっており、加算は 1 cycle で実行できますが乗算は 4 倍低速です。
さらに fmacd (積和) は乗算と同等の速度で演算しているものの、
vfma (FMA) は並列化されておらず 5倍 (1 add + 4 mul cycle) かかっているようです。

* VFP/NEON (double fp)
VFP fmuld (64bit x1) n8       :   13.628      293.5      293.5
VFP faddd (64bit x1) n8       :    3.439     1163.0     1163.0
VFP fmacd (64bit x1) n8       :   13.508      592.2      592.2
VFP vfma.f64 (64bit x1) n8    :   16.895      473.5      473.5
VFP fmuld (64bit x1) ns4      :   13.434      297.8      297.8
VFP faddd (64bit x1) ns4      :    3.435     1164.6     1164.6
VFP fmacd (64bit x1) ns4      :   13.430      595.7      595.7
VFP vfma.f64 (64bit x1) ns4   :   16.823      475.5      475.5
VFP fmuld (64bit x1) n1       :   13.439      297.6      297.6
VFP faddd (64bit x1) n1       :    3.447     1160.6     1160.6
VFP fmacd (64bit x1) n1       :   26.856      297.9      297.9
VFP vfma.f64 (64bit x1) n1    :   26.860      297.8      297.8

関連エントリ
・VFP Benchmark v1.1 浮動小数点演算命令の速度 (NEON/SSE/AVX)
・ARM CPU の VFP Benchmark アプリ 浮動小数点演算速度の計測
・iPhone 5s A7 CPU の浮動小数点演算速度 (2) (arm64/AArch64/64bit)
・iPhone 5s A7 CPU の浮動小数点演算速度 (32bit)
・Nexus 10 CPU Cortex-A15 の速度
・Nexus 10 CPU Cortex-A15 の浮動小数点演算速度
・Qualcomm APQ8064 GPU Adreno 320 の速度
・benchmark 関連

VFP Benchmark を走らせてみました。

ARCH: ARMv7A
FPU: VFPv4-D32 NEON
SingleT SP max: 0.951 GFLOPS
SingleT DP max: 0.470 GFLOPS
MultiT  SP max: 0.945 GFLOPS
MultiT  DP max: 0.469 GFLOPS
CPU core: 1
NEON: yes
FMA: yes

詳細な結果はこちら。

・VFP Benchmark Log

下記は抜粋です。

* VFP/NEON (single fp)               sec     MFLOPS     MFLOPS
--------------------------------------------------------------
VFP fmuls (32bit x1) n8       :    2.649      453.0      453.0
VFP fadds (32bit x1) n8       :    2.557      469.3      469.3
VFP fmacs (32bit x1) n8       :    2.586      928.2      928.2
NEON vmul.f32 (32bit x4) n8   :   10.097      475.4      475.4
NEON vadd.f32 (32bit x4) n8   :   10.182      471.4      471.4
NEON vmla.f32 (32bit x4) n8   :   10.165      944.4      944.4

* VFP/NEON (double fp)               sec     MFLOPS     MFLOPS
--------------------------------------------------------------
VFP fmuld (64bit x1) n8       :   10.164      118.1      118.1
VFP faddd (64bit x1) n8       :    2.554      469.8      469.8
VFP fmacd (64bit x1) n8       :   10.746      223.3      223.3

Single core で VFPv4 と NEON に対応していることがわかります。
ただし NEON でも結果はスカラーと同じ速度しか出ていません。(上の表の MFLOPS)
また倍精度の乗算速度も加算の 1/4 まで落ちています。

これらの特徴を踏まえると Cortex-A7 が使われているものと思われます。速度を見る限り実行クロックは 500MHz 程度でしょう。CPU core 毎の浮動小数点演算能力 (特徴) は下記にまとめています。

・CPU の浮動小数点演算能力の詳細

Apple S1 のアプリケーションプロセッサは Android Wear に使われている Snapdragon 400 と比べると少々非力です。CPU core は同じですがクロックはおよそ半分で Single core になります。

↓ 一応 Apple Watch で ChiRaKS 動きました。まだ操作と速度に問題があります。




関連エントリ
・iPod touch 6 の浮動小数点演算速度は Core 2 Duo ライン超え
・Android Wear Sony SmartWatch 3 SWR50 は速い
・iPad Air 2 (Apple A8X) の浮動小数点演算能力
・Android Wear VFP Benchmark
・ndroid Wear LG G Watch (LG-W100) の速度(実測)
・VFP Benchmark 関連

今まで ARM CPU の浮動小数点演算速度について調べてきましたが、
その計測プログラムをアプリにしてみました。

・VFP Benchmark (Android)

今までの測定結果のまとめは下記の通り。

・ARM CPU core 毎の浮動小数点演算速度の比較 (VFP/NEON)

VFP Benchmark アプリの表示結果は上記の表と互換性があります。
さらに FLOPS 表示、倍精度浮動小数点演算の計測、マルチスレッド実行に
対応しました。
下記は幾つかの端末の結果(一部)です。

MSN8974 Krait 400 2.2GHz x4 quad
---------------------------------------
SingleT SP max : 16.619 GFLOPS
MultiT  SP max : 67.185 GFLOPS (理論値: 70.4 GFLOPS)
                               = 2(mad) x 4(simd) x 4(core) x 2.2(clock)


Tegra4 Cortex-A15 1.8GHz x4 quad
---------------------------------------
SingleT SP max: 13.371 GFLOPS
MultiT  SP max: 51.345 GFLOPS  (理論値: 57.6 GFLOPS)
                        = 2(mad) x 2(simd) x 2(unit) x 4(core) x 1.8(clock)


APQ8064 Krait 1.5GHz x4 quad
---------------------------------------
SingleT SP max: 11.947 GFLOPS
MultiT  SP max: 47.808 GFLOPS  (理論値: 48.0 GFLOPS)
                               = 2(mad) x 4(simd) x 4(core) x 1.5(clock)

Exynos5D Cortex-A15 1.7GHz x2 dual
---------------------------------------
SingleT SP max: 13.483 GFLOPS
MultiT  SP max: 26.724 GFLOPS  (理論値: 27.2 GFLOPS)
                        = 2(mad) x 2(simd) x 2(unit) x 2(core) x 1.7(clock)


Tegra3 Cortex-A9 1.2GHz x4 quad (TB1.3GHz)
---------------------------------------
SingleT SP max:  4.783 GFLOPS  (理論値:  5.2 GFLOPS
MultiT  SP max: 18.905 GFLOPS  (理論値: 19.2 GFLOPS)
                               = 2(mad) x 2(simd) x 4(core) x 1.2(clock)

K3V2 Cortex-A9 1.2GHz x4 quad
---------------------------------------
SingleT SP max:  4.694 GFLOPS
MultiT  SP max: 18.662 GFLOPS  (理論値: 19.2 GFLOPS)
                               = 2(mad) x 2(simd) x 4(core) x 1.2(clock)


MSN8260 Scorpion 1.2GHz x2 dual
---------------------------------------
SingleT SP max:  8.898 GFLOPS
MultiT  SP max: 16.560 GFLOPS  (理論値: 19.2 GFLOPS)
                               = 2(mad) x 4(simd) x 2(core) x 1.2(clock)


QSD8250 Scorpion 1.0GHz x1
---------------------------------------
SingleT SP max:  7.098 GFLOPS  (理論値:  8.0 GFLOPS)
                               = 2(mad) x 4(simd) x 1.0(clock)

Tegra 2 Cortex-A9 1.0GHz x2 dual
---------------------------------------
SingleT SP max:  1.973 GFLOPS
MultiT  SP max:  3.913 GFLOPS  (理論値:  4.0 GFLOPS)
                               = 2(mad) x 2(core) x 1.0(clock)

比較的理論値に近い数値が出ています。
各 CPU の理論値は下記にまとめました。

・CPU FLOPS

この出力結果はあくまでピーク値による比較なので、
実際のアプリケーションの実行速度とは異なります。

例えばスカラ VFP 演算で n8 と n1 の結果を比べると、
Cortex-A9 では命令の並び順によって 5倍も速度が落ちるケースがあります。
同じ条件でも Krait / Cortex-A15 はほとんど速度が落ちていないので、
パイプラインの実行効率が向上していることがわかります。

よって実際のアプリケーションでは、Cortex-A9 と Krait/Cortex-A15 では
ピーク値よりもさらに差が開くことが予想されます。

multi-thread は同じテストを CPU core の数だけ走らせています。
Tegra 3 のように single thread 時に動作クロックが上がるものがあるので、
single-thread の値を core 数倍しても正しい値にならないためです。

アプリの出力結果を見ると、Cortex-A15 は VFP のスカラ演算よりも
NEON の 64bit (float x2) の方が 2倍速く実行できることがわかります。

// Exynos 5 Dual Cortex-A15 1.7GHz dual (Nexus 10)

* VFP/NEON (single fp)         sec    MFLOPS    最大
----------------------------------------------------
VFP fmuls     (32bit x1) n8 :  2.675  1495.4  1555.9
VFP fadds     (32bit x1) n8 :  2.392  1672.1  1672.1
VFP fmacs     (32bit x1) n8 :  3.171  2523.2  2523.2
VFP vfma.f32  (32bit x1) n8 :  2.985  2679.9  2679.9
NEON vmul.f32 (32bit x2) n8 :  1.187  6740.5  6740.5  **
NEON vadd.f32 (32bit x2) n8 :  1.187  6740.7  6740.7  **
NEON vmla.f32 (32bit x2) n8 :  1.187 13480.8 13480.8  **
NEON vfma.f32 (32bit x2) n8 :  1.187 13480.3 13480.3  **
NEON vmul.f32 (32bit x4) n8 :  2.373  6741.8  6741.8
NEON vadd.f32 (32bit x4) n8 :  2.374  6740.7  6740.7
NEON vmla.f32 (32bit x4) n8 :  2.373 13482.7 13482.7
NEON vfma.f32 (32bit x4) n8 :  2.373 13482.3 13482.3

以前予想したようにおそらく NEON の演算 unit は 64bit の 2 pipe ですが、
VFP は 1命令しか実行できない可能性があります。
Cortex-A8 で行ったように、VFP 命令を NEON 演算に置換する
Cortex-A15 最適化ができるかもしれません。


関連エントリ
・iPhone 5s A7 CPU の浮動小数点演算速度 (2) (arm64/AArch64/64bit)
・iPhone 5s A7 CPU の浮動小数点演算速度 (32bit)
・Nexus 10 CPU Cortex-A15 の速度
・Nexus 10 CPU Cortex-A15 の浮動小数点演算速度
・Qualcomm APQ8064 GPU Adreno 320 の速度
・Qualcomm APQ8064 Krait/A6 swift の浮動小数点演算能力
・iPad 4/iPad mini A6X/A5 の CPU/GPU 速度
・iPhone 5 / A6 の CPU 速度 その 3
・ARM Cortex-A8 の NEON と浮動小数演算最適化
・benchmark 関連

最近の Windows Tablet 等に使われている Bay Trail は、
新しい世代の Atom CPU core (Silvermont) を搭載しています。
HT 無しの 2/4 core で Out-of-Order となり、
旧 Atom と比べて実行性能が大きく向上しています。

Bay Trail の浮動小数点演算能力を調べてみました。
テスト環境は Bay Trail-D (Celeron J1900) なので厳密には Celeron となります。

結果、単精度の浮動小数点演算能力は 旧 Atom と変わらず、
1 core あたり 6 fop (add 4 + mul 2) / clock であることがわかりました。
旧 Atom 同様 add, mul の非対称な interleave が良い結果となっています。
その代わり倍精度演算は強化されており、旧 Atom の 2倍に相当します。

VFP Benchmark の結果から求めた cycle あたりの演算 (1coreあたり)

                       Single FP   Double FP
---------------------------------------------------------
Atom Bonnell (旧Atom)     6          1.5
Atom Silvermont (新)      6            3 1.5     (Bay Trail)
Core 2 Duo                8            4
Core i7 Sandy Bridge     16            8
Core i7 Ivy Bridge       16            8
Core i7 Haswell          32           16     (未計測,予想値)

Cortex-A9                 4            1
Cortex-A15                8          1.4
Krait                     8            2     (Snapdragon 800)
Swift                     8            1     (iPhone 5)
Cyclone ARM64            16            8     (iPhone 5s)

演算内容の内訳は次の通り

                       Single FP         Double FP
SIMD(Vector)           mul  add  mad     mul  add  mad
-------------------------------------------------------
Atom Bonnell (旧Atom)   2    4   (6)     0.4  0.5    ?
Atom Silvermont (新)    2    4   (6)       1    2   (3)  0.5  1.0  (1.5)
Core 2 Duo              4    4   (8)       2    2  (3?)
Core i7 Sandy Bridge    8    8  (16)       4    4   (8)
Core i7 Ivy Bridge      8    8  (16)       4    4   (8)

Cortex-A9               2    2    4       --   --   --
Cortex-A15              4    4    8       --   --   --
Krait                   4    4    8       --   --   --
Swift                   4    4    8       --   --   --
Cyclone ARM64           8   12   16        4    6    8

Scalar 時の結果など、より詳しくまとめた表を下記に載せています。

・cycle あたりの演算命令の詳細

以下は実際の J1900 の VFP Benchmark の結果です。
演算命令単位など、より詳細な結果をご覧になりたい方は こちら よりどうぞ。
各種 CPU のログを載せています。

Bay Traild-D Celeron J1900 2.0GHz (TB:2.5GHz 2.41GHz)

ARCH: x64
FPU: SSSE3 SSE4.1 SSE4.2
SingleT SP max: 14.477 GFLOPS
SingleT DP max:  3.619 GFLOPS
MultiT  SP max: 57.902 GFLOPS
MultiT  DP max: 14.471 GFLOPS
CPU core: 4
SSE: yes
AVX: no
FMA: no
～

理論値は 2GHz 4core で 48 GFLOPS なので、計測結果はより高い数値が出ています。
Turbo Boost が効いているためで、57.902 / 24 = 2.41 から
Multi Thread 時におよそ 2.4GHz で動作していることがわかります。

他の CPU との比較。

VFP Benchmark 実測値        clock core    Single FP     Double FP
-------------------------------------------------------------------
Bay Trail-D  J1900           2.0GHz x4    57.9 GFLOPS   14.5 GFLOPS
Menlow       Atom Z540       1.9GHz x1    10.9 GFLOPS    1.9 GFLOPS
Core 2 Duo   P7350           2.0GHz x2    31.7 GFLOPS   12.7 GFLOPS
Ivy Birdge   Core i5-3210M   2.5GHz x2    90.2 GFLOPS   45.2 GFLOPS
Sandy Bridge Core i7-2720QM  2.2GHz x4   162.3 GFLOPS   74.0 GFLOPS

Kindle HDX 7 Krait 400       2.2GHz x4    67.5 GFLOPS   16.9 GFLOPS
Tegra Note 7 Cortex-A15      1.8GHz x4    51.3 GFLOPS    9.8 GFLOPS
iPhone 5s    Cyclone         1.3GHz x2    40.9 GFLOPS   20.5 GFLOPS

・ピーク値による比較、GFLOPS が大きい方が速い

↑ Multi Thread 時の比較なので、Core 数が多く Clock が高い方が良い結果になります。

Mobile 向け CPU の性能向上が著しく、旧 Atom (Bonnell/Saltwell) では
ハイエンドの Quad core ARM に太刀打ちできませんでした。
新しい Atom Silvermont は十分な性能を有しています。
ただ浮動小数点演算はそれほど得意ではないようです。
おそらく AVX にも対応している Jaguar の方が上でしょう。

なお Tablet 向け Bay Trail-T は動作クロックが下がるため、
上記の表よりも低い値になると考えられます。

また、あくまで浮動小数点演算に特化した数値なので、
実際のアプリケーションの動作速度とは異なる点にご注意ください。
当 blog が浮動小数点演算能力のデータを集めているのは、ゲーム開発時の最適化が目的となります。

2014/05/15 訂正:
　・Celeron J1900 の TB Clock の間違いを訂正いたしました 2.5GHz → 2.41GHz
　・倍精度演算で旧 Atom の 2倍は間違いでした。旧 Atom と同等の性能と思われます。
申し訳ありませんでした。


関連ページ
・VFP Benchmark
・VFP Benchmark の計測結果
・CPU FLOPS 理論値と、cycle ごとの演算数まとめ

関連エントリ
・VFP Benchmark v1.1 浮動小数点演算命令の速度 (NEON/SSE/AVX)

x86 の SSE/AVX 命令に対応しました。
ARM CPU と同じように SSE/AVX の命令速度を計測することができます。

・VFP Benchmark v1.1
・VFP Benchmark Android (Google play)
・VFP Benchmark iOS (AppStore)

上記は Android ですが iOS 版では ARMv8A (arm64) に対応しています。(2014/02/05 iOS 版追加)
下記は手持ちのデバイスでの結果。

Device           CPU                             sp GFLOPS  dp GFLOPS
---------------------------------------------------------------------
MacBookRetina13  Core i5-3210M Ivy    2.5GHz x2       90.2       45.2
Kindle HDX 7     MSN8974  Krait 400   2.2GHz x4       67.5       16.9
Tegra Note 7     Tegra4   Cortex-A15  1.8GHz x4       51.3        9.8
Nexus 7 (2013)   AQP8064  Krait       1.5GHz x4       47.8       11.8
iPhone 5s        A7 arm64 Cyclone     1.3GHz x2       40.9       20.5
iPhone 5s        A7 arm7s Cyclone     1.3GHz x2       40.9        8.0
Mac mini 2009    Core2 Duo P7350      2.0GHz x2       31.7       12.7
Nexus 10         Exynos5D Cortex-A15  1.7GHz x2       26.7        5.3
iPad 4           A6X      Swift       1.4GHz x2       21.5        3.6
iPhone 5         A6       Swift       1.3GHz x2       20.1        3.4
Nexus 7 (2012)   Tegra3   Cortex-A9   1.3GHz x4       18.9        4.7
EVO 3D ISW12HT   MSM8660  Scorpion    1.2GHz x2       16.6        1.3
VAIO Type P      Atom Z540 Bonnell    1.8GHz x1       10.9        1.9
Desire X06HT     QSD8250  Scorpion    1.0GHz x1        7.1        0.9
iPad 2           A5       Cortex-A9   1.0GHz x2        7.8        2.0
iPod touch 4     A4       Cortex-A8   0.8GHz x1        3.1        0.1
Raspberry Pi     BCM2835  ARM1176JZFS 0.7GHz x1        0.7        0.7

 * 数値が大きい方が速い。
 * sp= 単精度, dp= 倍精度

ピーク値の測定なので実アプリケーションの速度とは異なります。
詳しくはこちらを参照してください。
下記のページのほぼ理論値通りの傾向が出ています。

・CPU FLOPS 理論値

倍精度のテストはまだ改良の余地があります。
スカラーで mul+add のペアリングを測定していないので、
一部の CPU でもう少しスコアが伸びると考えられます。

Core i5 Ivy Bridge は想定より高い数値が出ていますが、TurboBoost の効果で
より高いクロックで走っているようです。single-thread 時は 3.0GHz、
mult-thread 時は 2.85GHz 相当の結果となっています。

実際の測定結果は命令単位の数値を出すので、より細かく CPU の動作を
調べることができます。

SSE2/AVX1 には積和命令がありませんが、Intel CPU は加算と乗算命令が
並列に実行できるようです。
↓ 実際に addps/mulps の Interleave は半分の時間で実行しています。

Ivy Bridge Core i5-3210M
* SSE/AVX (single fp)                sec     MFLOPS     MFLOPS
AVX vmulps (32bit x8) n8      :    1.322    24205.7    24205.7
AVX vaddps (32bit x8) n8      :    1.319    24256.0    24256.0
AVX vmul+addps (32bit x8) n8  :    0.658    48604.4    48604.4

↓ Atom (Bonnell) は場合少々特殊です。
SSE 命令の乗算は加算よりも 2倍時間がかかっています。
動作クロックを考えると SSE の add が 128bit で mul が 64bit 幅で
演算していると考えられます。

Atom Z540 (Bonnell)
* SSE/AVX (single fp)                sec     MFLOPS     MFLOPS
SSE mulps (32bit x4) n8       :    4.307     3715.2     3715.2
SSE addps (32bit x4) n8       :    2.207     7248.1     7248.1
SSE mul+addps (32bit x4) n8   :    2.155     7424.2     7424.2

ARM NEON の場合は、同じ SIMD でも 64bit 命令があります。
例えば「 vadd.f32 d0,d1,d2 」は単精度 32bit x2 の 64bit 加算を行うので、
Cortex-A8/A9 のように 64bit 幅でも 1cycle で実行します。
128bit 命令「 vadd.f32 q0,q1,q1 」の場合は 2cycle かかります。

SSE は常に 4要素 = 128bit 単位なので Pentium 3 等 64bit 幅の
SIMD Unit では最小でも 2cycle かかることになります。
同様に Atom の乗算も最小値は 2cycle です。
ただし mulps + addps の Interleave でも、addps のみの場合と同じ時間で
完了するため、加算と乗算は非対称ながら Overlap できるようです。

Atom には HT があるので、Multi-thread 時は無駄な隙間を埋められます。
メインスレッドで mulps + addps のペアを実行し、サブスレッドで addps のみ
走らせるとおそらく 128bit + 64bit の非対称なパイプラインが埋まります。

mulps + addps + addps 組み合わせを 2スレッド走らせたのが下記の結果で、
スコアが伸びていることがわかります。

Atom Z540 (Bonnell)
* SSE/AVX (single fp) multi-thread   sec     MFLOPS     MFLOPS
SSE ml+ad+addps (32bit x4) n6 :    3.075    10926.6    10926.6

これらの測定結果から、CPU の個別の演算能力をまとめたのが下記の表です。
倍精度の値はもう少し変動する可能性があります。

・スカラー

                  単精度                      倍精度
CPU               mul    add    mad   fma     mul    add    mad    fma
-----------------------------------------    -------------------------
ARM1176JZF-S      0.5    0.5      1    --     0.5    0.5      1     --
Cortex-A8        0.14   0.14   0.18    --     0.1    0.1    0.1     --
Cortex-A9           1      1      2    --     0.5      1      1     --
Cortex-A15          1      1    1.4     2       1      1    1.4    1.4
Scorpion            1      1      2    --     0.5      1      1     --
Krait 400           1      1      2     2       1      1    1.6      2
A6 Swift            1      1      1     1       1      1      1      1
A7 Cyclone arm7s    1      1      2     2       2      3      3      3
A7 Cyclone arm64    2      3     --     4       2      3     --    1.6
Atom Bonnell        1      1     --    --     0.5      1     --     --
Core2 Penryn        1      1     --    --       1      1     --     --
Core i5 Ivy Bridge  1      1     --    --       1      1     --     --

 * 数値は 1 cycle に実行可能な演算数
 * 値が大きい方が高速

ARM11 の mul は 0.5演算/cycle となっています。
つまり単精度の加算や乗算は 2cycle かかります。

mad/fma は命令あたり 2 演算なので、この欄が 2 の場合に 1 cycle で
実行できることを意味しています。

Cortex-A8 のピーク FLOPS は NEON のおかげで ARM11 より高いですが、
上記のように VFP のスカラー演算では ARM11 に負けています。

A7 Cyclone (ARMv8A) は AArch32 (32bit mode) と AArch64 (64bit mode) で
かなり違いがあります。
単精度演算は 64bit mode の方が数倍速く実行できるようです。
おそらく VFP が要求する仕様が NEON と異なっているためだと考えられます。
AArch64 は NEON と統一されたので、NEON と同等の速度で動作できるようです。
VFP が足を引っ張る似たような傾向は、Cortex-A15 など他の ARMv7A CPU にも
見られます。

・SIMD 単精度

                   SIMD2 (32bit x 2)         SIMD4 (32bit x4)
CPU                mul   add   mad   fma     mul   add   mad   fma  
----------------------------------------    ----------------------
ARM1176JZF-S        --    --    --    --      --    --    --    --
Cortex-A8            2     2     4    --       2     2     4    --
Cortex-A9            2     2     4    --       2     2     4    --
Cortex-A15           4     4     8     8       4     4     8     8 
Scorpion             2     2     4    --       4     4     8    -- 
Krait 400            2     2     4     4       4     4     8     8 
A6 Swift             2     2     4     4       4     4     8     8 
A7 Cyclone arm7s     4     6     8     8       8    12    16    16 
A7 Cyclone arm64     4     6    --     8       8    12    --    16
Atom Bonnell        --    --    --    --       2     4    (6)   --
Core2 Penryn        --    --    --    --       4     4    (8)   --
Core i5 Ivy Bridge  --    --    --    --       4     4    (8)   --

Cortex-A8/A9 は 64bit 幅なので、SIMD2 では Scorpion/Krait/Swift と
差がありません。
SIMD4 では 128bit の Scorpion/Krait/Swift の半分であることがわかります。

ユニークなのは Cortex-A15 で、SIMD4 では同じ 128bit の
Scorpion/Krait/Swift と同等ですが SIMD2 では 2倍の数値となっています。
Cortex-A15 は 64bit 幅 2 pipe なので、2命令同時実行できるためです。
スカラーでは単精度でも 1命令/cycle だったので、半分しか使わなくても
NEON の方が速いことになります。

Ivy Bridge は AVX に対応しているので、上の表では省略していますが SIMD8
があります。下記のページに SIMD8 や倍精度 SIMD 含めて表にまとめています。

・CPU FLOPS : FPU

一番最初の GFLOPS のリストでは、Quad core かつ動作クロックの高い
Snapdragon 800 (MSM8974) が上位でした。
CPU の cycle 単位の命令数を出してみると、唯一の ARMv8 CPU でもある
A7 Cyclone が群を抜いて高性能であることがわかります。

計測結果から、mul, mad/fma で 2命令、add では 3命令を同時に実行できるようです。
NEON の場合は AArch32 と AArch64 特に違いはありませんでした。

A7 Cyclone の設計は DEC Alpha や StrongARM に由来するエンジニアが
関わっているとのこと。(Wikipedia P.A.Semi)

Benchmark はあくまで浮動小数点演算能力のピーク値を実測することが目的なので、
必ずしも総合的な優劣には一致しないことを予めご了承ください。


関連エントリ
・ARM CPU の VFP Benchmark アプリ 浮動小数点演算速度の計測
・iPhone 5s A7 CPU の浮動小数点演算速度 (2) (arm64/AArch64/64bit)
・iPhone 5s A7 CPU の浮動小数点演算速度 (32bit)
・Nexus 10 CPU Cortex-A15 の速度
・Nexus 10 CPU Cortex-A15 の浮動小数点演算速度
・Qualcomm APQ8064 GPU Adreno 320 の速度
・Qualcomm APQ8064 Krait/A6 swift の浮動小数点演算能力
・ARM Cortex-A8 の NEON と浮動小数演算最適化
・benchmark 関連

VFP Benchmark の Android 版も 64bit 対応になりました。
対応していれば arm64 (arm64-v8a), x86_64 (x64), mips64 で計測を行います。
なお iOS 版はすでに 64bit (arm64) に対応しています。

・VFP Benchmark v1.3
・VFP Benchmark (Google Play)

下記は Nexus 9 (Tegra K1 64) での結果の比較です。

NVIDIA Denver            ST-SP    ST-DP   MT-SP   MT-DP
----------------------------------------------------------------
AArch32 32bit armv7a     17.799   4.423   34.582   8.719  GFLOPS
AArch64 64bit arm64      17.906   8.762   34.888  17.601  GFLOPS

 * ST=Single thread, MT=Multi thread
 * SP=Single precision fp, DP=Double precision fp
 * 単位は GFLOPS, 数値が大きい方が高速

AArch64 は倍精度 NEON 命令が使えるため DP の速度が 2倍になっています。
より詳しい結果は下記ページに載せています。

・VFP Benchmark Log

// Tegra K1 Denver arm64
                                  時間(sec)  MFLOPS
---------------------------------------------------
FPU fmul (32bit x1) n8        :    2.049     1952.1
FPU fadd (32bit x1) n8        :    1.000     3998.3
FPU fmadd (32bit x1) n8       :    1.849     4326.0
NEON fmul.2s (32bit x2) n8    :    1.842     4343.8
NEON fadd.2s (32bit x2) n8    :    1.259     6356.0
NEON fmla.2s (32bit x2) n8    :    1.900     8420.3
NEON fmul.4s (32bit x4) n8    :    1.837     8711.7
NEON fadd.4s (32bit x4) n8    :    1.179    13570.5
NEON fmla.4s (32bit x4) n8    :    1.831    17475.0

FPU fmul (64bit x1) n8        :    1.930     2072.7
FPU fadd (64bit x1) n8        :    0.929     4306.0
FPU fmadd (64bit x1) n8       :    1.798     4450.2
NEON fmul.2d (64bit x2) n8    :    1.809     4422.6
NEON fadd.2d (64bit x2) n8    :    1.195     6695.8
NEON fmla.2d (64bit x2) n8    :    1.826     8762.0

fmul.2s, fmul.4s の速度差が無いため、Cortex-A15 と異なり NEON 命令の実行は
128bit 単位と思われます。
おそらく Nexus 9 の Denver は 2.2GHz 前後で動作しており、
1 cycle あたりスカラー乗算 で 1、加算が 2。
SIMD ではこの割合が 4 mul, 6 add, 4 mad となっています。
表にまとめると下記の通り。(数値が大きい方が cycle あたりの演算能力が高い)

                 Scalar SP       Scalar DP
                 mul add mad     mul add mad
----------------------------------------------
Cortex-A9  32      1   1   2     0.5   1   1
Cortex-A15 32      1   1   2       1   1 1.4
Krait 400  32      1   1   2       1   1   2  (Qualcomm)
Swift      32      1   1   1       1   1   1  (Apple A6)
Denver     64      1   2   2       1   2   2  (NVIDIA Tegra) ←
Cyclone    64      2   3   4       2   3   4  (Apple A7/A8)
Silvermont 64      1   1   -     0.5   1   -  (Intel BayTrail Atom)
Jaguar     64      1   1   2     0.5   1   -  (AMD Kabini)

               SIMD2(32x2) SP    SIMD4(32x4) SP    SIMD2(64x2) DP
                mul add mad       mul add mad       mul add mad
------------------------------------------------------------------
Cortex-A9  32     2   2   4         2   2   4         -   -   -
Cortex-A15 32     4   4   8         4   4   8         -   -   -
Krait 400  32     2   2   4         4   4   8         -   -   -
Swift      32     2   2   4         4   4   8         -   -   -
Denver     64     2   3   4         4   6   8         2   3   4  ←
Cyclone    64     4   6   8         8  12  16         4   6   8
Silvermont 64     -   -   -         2   4   6       0.5   1 1.5
Jaguar     64     -   -   -         4   4   8         2   2   4

↑この表は命令あたりの演算個数で、積和を 2とみなしています。
より詳しい表は下記ページに載せています。

・CPU の浮動小数点演算能力の詳細

Denver は CPU core と比べても比較的おとなしい結果となっています。
浮動小数点演算において特に突出した特徴は持っていないので、
core の数が少ない分だけ Multi-Thread 時のピーク値が低くなっています。
下の表は 32bit 版 Tegra K1 を搭載した SHILD Tablet との比較です。

Tegra K1 (数値はGFLOPS)          ST-SP   ST-DP  MT-SP    MT-DP
---------------------------------------------------------------
Denver     AArch32 32bit armv7a  17.799  4.423  34.582   8.719  Nexus 9
Denver     AArch64 64bit arm64   17.906  8.762  34.888  17.601  Nexus 9
Cortex-A15 ARMv7A  32bit armv7a  17.136  3.431  70.174  14.036  SHIELD Tab

これだけ見ると Cortex-A15 版の方が優れているように見えますが、
あくまで浮動小数点演算命令だけの結果です。
実際には ARM の 64bit 命令セットが使えるメリットは大きく、
アプリケーションの動作速度ではこれらと大きく異なった結果になると思われます。

↓の表は WebGL (Emscripten) 物理エンジン ベンチマークの結果比較で、
Nexus 9 はかなり高速に実行できています。

Nexus 9        Tegra K1  Denver     64  Android 5.0  Firefox 33  13体
iPad Air 2     Apple A8X Cyclone    64  iOS 8.1      Safari      13体
MeMO Pad ME176 Z3740     Silvermont 32  Android 4.4  Firefox 33   9体
Tegra Note 7   Tegra 4   Cortex-A15 32  Android 4.4  Firefox 33   8体
Nexus 5        MSM8974   Krait 400  32  Android 4.4  Firefox 33   8体
Nexus 7        APQ8064   Krait      32  Android 5.0  Firefox 33   5体

詳しくは下記ページで。現在は Firefox でも正しく描画されるようになっています。

・iOS8 で WebGL ＆ 物理エンジンのベンチマーク結果


● Android NDK のアセンブラ命令

clang と gcc4.9 の違いかもしれませんが、左側の省略記法が使えなかったので
右のようにレジスタ名への展開が必要でした。

orr.16b  v1, v0, v0      →     orr   v1.16b, v0.16b, v0.16b
fmla.4s  v0, v8, v4      →     fmla  v0.4s,  v8.4s,  v4.4s

関連エントリ
・iPad Air 2 (Apple A8X) の浮動小数点演算能力
・Android x86 Binary Translator を試してみる
・Atom Bay Trail の浮動小数点演算能力
・VFP Benchmark v1.1 浮動小数点演算命令の速度 (NEON/SSE/AVX)
・ARM CPU の VFP Benchmark アプリ 浮動小数点演算速度の計測
・iPhone 5s A7 CPU の浮動小数点演算速度 (2) (arm64/AArch64/64bit)
・iPhone 5s A7 CPU の浮動小数点演算速度 (32bit)
・Nexus 10 CPU Cortex-A15 の速度
・Nexus 10 CPU Cortex-A15 の浮動小数点演算速度
・Qualcomm APQ8064 GPU Adreno 320 の速度
・Qualcomm APQ8064 Krait/A6 swift の浮動小数点演算能力
・ARM Cortex-A8 の NEON と浮動小数演算最適化
・benchmark 関連

「Android Wear LG G Watch (LG-W100) の速度(実測)」で計測に使ったアプリを公開しました。

・VFP Benchmark
・Google Play: VFP Benchmark for Android Wear

命令単位の実行速度など、詳細な表は Smartphone/Tablet 側で表示することができます。
ログの書き出しも可能です。
よろしければどなたか Galaxy Gear Live の結果を教えて下さい。

Android Wear と Smartphone/Tablet の通信 API は対称で、どちらも同じコードになります。
Smartphone 側からデータを送ったり Android Wear の Activity を起動することができますし、
逆も同様に可能です。
Android Wear は Android を搭載した独立したデバイスなので、対等な扱いになっていることがわかります。
このアプリはログのビューアとして Smartphone/Tablet を利用しています。


関連エントリ
・Android Wear 3D のアナログ時計 (Watch Face)
・Android Wear の 3D 描画 と NDK r10
・Android Wear にゲームを移植
・Android Wear LG G Watch (LG-W100) の速度(実測)
・Android Wear LG G Watch (LG-W100)
・Android Wear LG G Watch の GPU

iPad Air 2 (A8X) の浮動小数点演算能力を調べてみました。
より詳細なログは下記ページに乗せています。

・VFP Benchmark Log

// iPad 2 Air (Apple A8X)

ARCH: ARMv8A
VFP: AArch64 NEON
SingleT SP max:  23.568 GFLOPS
SingleT DP max:  11.751 GFLOPS
MultiT  SP max:  68.591 GFLOPS
MultiT  DP max:  33.968 GFLOPS
CPU core: 3
FMA: Yes
NEON: Yes

↑本当に CPU が 3 core でした。
モバイルデバイスではあまり見かけませんが Xbox360 や Wii U など
ゲーム機に多い印象です。

もともと Cyclone は Apple A7 でも浮動小数点演算能力が突出していた CPU
でしたが、A8X でもほぼ同様の傾向が出ています。
浮動小数点演算命令はスカラーベクター共に 2 命令同時に実行可能で、
NEON の 128bit 積和も並列に走ります。
動作クロックは低いものの、3 core になったことで他の ARM Core の
4 core に匹敵する数値となってます。(下記表の (*1) )

	      Apple A8X   Snapdragon 800   Tegra K1    Atom Z3745
               Cyclone      Krait 400     Cortex-A15   Silvermont
	      1.5GHz x3     2.2GHz x4     2.2GHz x4    1.83GHz x4
------------------------------------------------------------------
SingleT SP      23.568       17.128        17.136        8.946
SingleT DP      11.751        4.289         3.431        2.797
MultiT  SP(*1)  68.591       67.539        70.174       35.473
MultiT  DP      33.968       16.874        14.036       11.060

 * 数値は GFLOPS 、値が大きい方が速い
 * 倍精度 (DP) で大きく差が付いているのは ARMv7A (32bit) に NEON が無いため
 * ピーク値なので実際のアプリケーション動作速度とは異なります

さらに命令毎のログを詳しく見ていくと、A7 で何故か遅かった
倍精度演算のスカラー積和が改善されていることがわかります。

// iPhone 5s (Apple A7)
倍精度演算
                             実行時間　演算数   演算数
---------------------------------------------------------------
FPU fmul (64bit x1) n8      :  1.642   2436.1   2436.1
FPU fadd (64bit x1) n8      :  1.045   3827.0   3827.0
FPU fmadd (64bit x1) n8     :  3.915   2043.6   2043.6 --- (A-7)
NEON fmul.2d (64bit x2) n8  :  1.567   5105.1   5105.1
NEON fadd.2d (64bit x2) n8  :  1.034   7736.5   7736.5
NEON fmla.2d (64bit x2) n8  :  1.958   8172.1   8172.1 --- (B-7)

↑ Apple A7 では、FPU fmadd の積和 (A-7) だけ 3.915 と実行時間が
余計にかかっていました。
同じ積和でも NEON fmla はそこまでの落ち込みはなく、
(B-7) 見てわかるようにむしろスカラーよりも高速に実行できています。

// iPad Air 2 (Apple A8X)
倍精度演算
                             実行時間　演算数   演算数
---------------------------------------------------------------
VFP fmul (64bit x1) n8      :  1.442   2773.8   2773.8
VFP fadd (64bit x1) n8      :  0.926   4321.2   4321.2
VFP fmadd (64bit x1) n8     :  1.772   4513.6   4513.6 --- (A-8)
NEON fmul.2d (64bit x2) n8  :  1.408   5681.0   5681.0
NEON fadd.2d (64bit x2) n8  :  0.922   8680.2   8680.2
NEON fmla.2d (64bit x2) n8  :  1.744   9175.5   9175.5 --- (B-8)

↑ Apple A8X ではスカラーの倍精度積和 (A-8) も NEON (B-8) と変わらない
速度で実行できており、Apple A7 の弱点が克服されていることになります。

この辺りの演算能力の違いをまとめたのが下記ページの表です。

・CPU の浮動小数点演算能力の詳細


関連エントリ
・Android x86 Binary Translator を試してみる
・Atom Bay Trail の浮動小数点演算能力
・VFP Benchmark v1.1 浮動小数点演算命令の速度 (NEON/SSE/AVX)
・ARM CPU の VFP Benchmark アプリ 浮動小数点演算速度の計測
・iPhone 5s A7 CPU の浮動小数点演算速度 (2) (arm64/AArch64/64bit)
・iPhone 5s A7 CPU の浮動小数点演算速度 (32bit)
・Nexus 10 CPU Cortex-A15 の速度
・Nexus 10 CPU Cortex-A15 の浮動小数点演算速度
・Qualcomm APQ8064 GPU Adreno 320 の速度
・Qualcomm APQ8064 Krait/A6 swift の浮動小数点演算能力
・ARM Cortex-A8 の NEON と浮動小数演算最適化
・benchmark 関連

Sony SmartWatch3 の vfpbench スコアを送っていただきました。
LG G Watch (LG-W100) よりも速く、実際に 1.2GHz 出ているものと思われます。
またきちんと確認していませんが 2 core 生きている可能性もあります。

// SmartWatch 3 SWR50
// MSM8226 Cortex-A7 1.2GHz x4 (1.2GHz x2?)

ARCH: ARMv7A
CPU core: 4
VFP: VFPv4-D32 NEON
FMA: Yes
NEON: Yes
Result
  SingleT SP max:  2.257 GFLOPS
  SingleT DP max:  1.144 GFLOPS
  MultiT  SP max:  4.946 GFLOPS
  MultiT  DP max:  2.278 GFLOPS

Motorola Moto 360 以外はどれも同じ Snapdragon 400 (MSM8226) の
横並びですが、予想外に違いがあるようです。

device                SoC             CPU       SoCのspec   実質
----------------------------------------------------------------------
LG G Watch   LG-W100  Snapdragon 400  Cortex-A7 1.2GHz x4   0.8GHz x1
LG G Watch R LG-W110  Snapdragon 400  Cortex-A7 1.2GHz x4   ?
Galaxy Gear Live      Snapdragon 400  Cortex-A7 1.2GHz x4   ?
ASUS ZenWatch WI500Q  Snapdragon 400  Cortex-A7 1.2GHz x4   ?
SmartWatch 3 SWR50    Snapdragon 400  Cortex-A7 1.2GHz x4   1.2GHz x2?
Motolora Moto 360     TI OMAP3630     Cortex-A8 1.0GHz x1   1.0GHz x1

同様に Motorola Moto 360 の結果も頂いたので下記にまとめます。
スコアから見てこちらは Cortex-A8 の 1.0GHz で動いているものと見られます。

device (4.4W.2)       SP-ST   DP-ST   SP-MT   DP-MT
-----------------------------------------------------------
LG G Watch LG-W100    1.419   0.742   1.367   0.676  GFLOPS
SmartWatch 3 SWR50    2.257   1.144   4.946   2.278  GFLOPS
Motolora Moto 360     3.739   0.126   3.376   0.125  GFLOPS

  * SP=単精度, DP=倍精度, ST=SingleThread, MT=MultiThread

一見 Moto 360 が一番速いようにみえるかもしれません。
ピーク値で突出しているのは Cortex-A8 が 64bit 幅の NEON ALU を
持っているからです。(Cortex-A7 は 32bit幅)

実際は世代の古い SoC を採用しており Moto360 の CPU Core も数世代前のものです。
倍精度(DP)の結果を見てわかるように、VFP 演算では他の CPU の 1/5 以下の速度となります。
浮動小数点演算を多用している一般的なアプリケーション (NEON未使用) では
おそらく Moto 360 の方が低速でしょう。
この辺りは VFP Bencmark で命令毎の数値を比較するとよくわかります。

詳しいログを下記ページに追加しました

・VFP Benchmark Log

もし他のデバイスのログをお持ちの方がいましたらぜひ送ってください。


関連エントリ
・Android Wear VFP Benchmark
・ndroid Wear LG G Watch (LG-W100) の速度(実測)

Amazon Fire TV (2015) で vfpbench を走らせてみました。下記表の MT8173C (上 2つ) が Fire TV です。

(SP/DP/SP-MT/DP-MT の単位は MFLOPS GFLOPS,数値が大きい方が高速)

詳細な結果は下記に追加しています。(big core のみ計測しています)

・VFP Benchmark Log

Cortex-A72 はピーク性能に突出したところはなく core あたり 8 fop (単精度 SIMD4 FMA) と標準的。SIMD2 の結果から Cortex-A15 同様 64bit 2pipe の構成であることもわかります。

ただしスカラー命令にはかなり違いがあるようです。Cortex-A72 では NEON だけでなくスカラー命令も 2 pipe 並列に実行できるらしく、加算で Cortex-A15 のおよそ 2倍。これは AArch32 mode でも有効なので、ARMv7A でビルドしたバイナリでも 64bit CPU の方が高速に演算できることになります。

倍精度でも少々面白い結果になっています。AArch64 には倍精度浮動小数点演算の NEON 命令があるものの SIMD でも 2並列です。Cortex-A72 は 64bit x 2pipe なので、ピーク性能において NEON とスカラーの差がなくなっています。

AArch32 でも同じなので、倍精度 NEON 命令が使えない ARMv7A もピーク速度が落ちておらず AArch64 の NEON 相当の速度を維持しています。

下記は倍精度のみの抜粋です。AppleA7/TegraK1 は AArch32 と AArch64 で差が開いていますが Cortex-A72 はスコア差がありません。A7/K1 比でピーク速度で負けているものの AArch32 では逆転していることがわかります。


・CPU の浮動小数点演算能力の詳細


関連エントリ
・iPod touch 6 の浮動小数点演算速度は Core 2 Duo ライン超え
・iPad Air 2 (Apple A8X) の浮動小数点演算能力
・Android x86 Binary Translator を試してみる
・iPhone 5s A7 CPU の浮動小数点演算速度 (2) (arm64/AArch64/64bit)
・VFP Benchmark 関連

G Watch のスペックは Cortex-A7 1.2GHz Quad core ですが、
アプリケーションの実際のパフォーマンスは予想を大きく下回るものでした。
今回の計測結果から逆算すると 700MHz の Single core 相当となります。

VFP Benchmark による計測結果

SingleThread SP 最大  : 1.360 GFLOPS
MultiThread  SP 最大  : 1.360 GFLOPS

同じ Cortex-A7 1.2GHz Quad core (MT8125) の Tablet との比較は下記の通り。

単精度 Float        LG G Watch        Yoga Tablet
                    MSM8226           MT8125
----------------------------------------------------------
Single Thread       1.360 GFLOPS      2.374 GFLOPS  (x1.7)
Multi Thread        1.360 GFLOPS      9.474 GFLOPS  (x7.0)

・GFLOPS の数値が大きいほうが高速

MT8125 の計測結果は 1.2GHz ほぼ想定通りの速度が出ています。
1.2(GHz) * 4(core) / 0.7(GHz) = 6.9 倍

以下詳細データ

SingleSP  Single-Thread
命令                   時間(sec)       MFLOPS
---------------------------------------------
VFP    mul              6.331           631.8
VFP    add              6.011           665.5
VFP    fmacs            6.062          1319.7
VFP    vfma.f32 s       6.032          1326.4
NEONx2 vmla.f32 d      11.833          1352.1
NEONx2 vfma.f32 d      11.859          1349.2
NEONx4 vmla.f32 q      23.621          1354.8
NEONx4 vfma.f32 q      23.542          1359.3

・MFLOPS の数値が大きいほうが高速

SingleSP  Multi-Thread (4 Thread)
命令                   時間(sec)       MFLOPS
---------------------------------------------
VFP    mul             24.405           655.6
VFP    add             24.063           664.9
VFP    fmacs           24.109          1327.3
VFP    vfma.f32 s      24.049          1330.6
NEONx2 vmla.f32 d      47.458          1348.6
NEONx2 vfma.f32 d      47.653          1343.0
NEONx4 vmla.f32 q      94.490          1354.6
NEONx4 vfma.f32 q      98.163          1304.0

・MFLOPS の数値が大きいほうが高速

Cortex-A7 は NEON も 32bit 単位なので VFP と同じ速度になります。
(Cortex-A7 の浮動小数点演算速度)
Krait ではなく Cortex-A7 が使われていることが結果からもわかります。

やはり cpu0 だけが 787MHz で動いているようです。(cpu1-3 は idle 状態)

cat /sys/devices/system/cpu/cpu0/cpufreq/stats/time_in_state

300000 0
384000 4
600000 73
787200 8799475
998400 174
1094400 109
1190400 2280

ポリゴンの表示は可能です。



関連エントリ
・Android Wear LG G Watch (LG-W100)
・Android Wear LG G Watch の GPU
・MediaTek MT8125/8389 Cortex-A7 の浮動小数点演算速度

Google の Android TV 端末、Nexus Player を使ってみました。
UI は一般の Android とは大きく異なり TV を意識したもの。
操作は付属のリモコンを使うので Apple TV に似ています。

・Google Nexus Player

大きく異なっているのは単体でアプリが動作することで、Google Play Store からダウンロードできます。
ただし専用＆対応アプリしか出てこないらしく検索してもタイトルは多くありません。
HOME に並んでるものもゲームとムービー等のコンテンツのみで実用系アプリは無し。
Chrome や GMail なども無く、検索でもこの辺りのアプリが見当たりませんでした。

micro USB 端子があるので PC につなげば adb 接続できます。
開発者メニューを有効にするには設定の端末情報から「 ビルド 」を何度も選択する必要あり。
USB 経由で install した場合は普通の Android アプリも動くようです。
ただし HOME 画面にはアイコンが表示されないため、実行には少々手間がかかります。

　1. 設定 → アプリ → ダウンロードしたアプリ
　2. 一覧から選択してから「開く」

HOME画面に表示させる場合は intent-filter の設定が必要です。


application に isGame="true" があるとアプリではなくゲーム側に分類されます。


通常の Android アプリを走らせた場合タッチ操作はできませんが、
vfpbenchmark のように標準の UI を使ったものはリモコンだけで操作できました。
(vfp benchmark の結果はこちら)

また USB Host が有効なので、タッチ操作が必要なアプリでもマウスを繋げばそれなりに使用することが出来ます。
BACK や HOME ボタンはないので、マウスの場合もリモコンは必要になります。

同様に USB を使った接続では PS3 や Xbox360 (USB版) のゲームコントローラも使うことが出来ました。
この辺りも通常の Android 端末と同様です。
専用のゲームパッドがなくてもひと通りゲーム操作できます。
ただし USB 接続は adb と併用できないので、ゲーム開発にはワイヤレスのコントローラが欲しくなります。

下記追加しました

・VFP Benchmark Log
・CPU/GPU OpenGL ES Extension (Mobile GPU)

GPU は Intel HD Graphics ではなく Apple A7 世代と同じ PowerVR G6430 です。


関連エントリ
・Android 5.0 Nexus Player x86 と対応 ABI
・iOS7 対応 SteelSeries Stratus ワイヤレスゲームコントローラー
・Android 用ゲームパッド BUFFALO Zeemote JS1 H
・Android 3.1 と GamePad のイベントの詳細 (2)
・Android 3.1 と GamePad のイベントコード

x86 の Atom を搭載した Android Tablet も増えてきました。
本来なら NDK を使用したアプリケーションの互換性が気になるところです。
ところが実際はほとんど問題が起こらず、想像以上にそのまま動作するものが多いようです。
最初から複数のアーキテクチャに対応しているアプリももちろんありますが、
x86 未対応でも動く仕組みが用意されています。

・Bay Trailが実現する、WindowsとAndroidが共存するタブレット

x86 の Android 端末は armeabi-v7a のコードを x86 に変換して実行することができます。
実際に試してみました。


ASUS MeMO Pad 7 ME176 (BayTrail-T Atom Z3745) を使い、
ARMv7A のバイナリ (so) だけ含んだ VFP Benchmark を走らせてみました。
NDK かつ assembler を使ったプログラムながら、きちんと動作していることがわかります。

下記はそれぞれのスクリーンショット。
CPU/FPU の種類も正しく判別している点に注目です。(理由は後述)

↓armeabi-v7a バイナリのみ含む場合


↓x86 バイナリのみ含む場合


結果のまとめ

                          Z3745 x86      Z3745 ARM-BT
---------------------------------------------------------
SingleFP Single-thread      8.95           6.14      69%
DoubleFP Single-thread      2.80           1.48      53%
SingleFP MultiT-hread      35.37          24.33      69%
DoubleFP MultiT-tread      11.06           5.91      53%
Matrix 4x4 Single-thread    3.06           1.79      59%
Matrix 4x4 Multi-thread    12.26           7.23      59%

・プロセッサのピーク演算能力
・単位は GFLOPS、数値が大きい方が高速
・ARM-BT = ARM Binary Translation

ARM コードは単精度浮動小数点数命令で x86 の 69%、
倍精度でおよそ 53% の速度となっています。
ただしこれは最善ケースのみです。
Matrix の方が比較的現実的な数値に近いと思われます。


↓他の CPU との比較。

                              clock      SP     DP     SP-MT  DP-MT
-------------------------------------------------------------------
BayTrail Z3745 ARM-BT      x4 1.86GHz    6.14   1.48   24.33   5.91 **
BayTrail Z3745 x86         x4 1.86GHz    8.95   2.80   35.37  11.06
BayTrail J1900 x64         x4 2.41GHz   14.48   3.62   57.90  14.47
Atom z540                  x1 1.86GHz    8.92   1.81   10.93   1.85
Tegra3 Cortex-A9           x4 1.30GHz    4.78   1.20   18.91   4.72
Tegra4 Cortex-A15          x4 1.80GHz   13.37   2.66   51.35   9.86
Snapdragon S4 Pro Krait    x4 1.50GHz   11.95   3.01   47.81  11.75
Snapdragon 800 MSM8974     x4 2.20GHz   17.13   4.29   67.54  16.87
Rockchip RK3066 Cortex-A9  x2 1.60GHz    6.35   1.59   12.66   3.14
MediaTek MT8125 Cortex-A7  x4 1.20GHz    2.37   1.17    9.47   4.65
Apple A5 (iPad2) Cortex-A9 x2 1.00GHz    3.97   0.99    7.83   1.96
Apple A6 (iPad4) Swift     x2 1.30GHz   10.86   1.82   21.50   3.57
Apple A7 (5s) Cyclone      x2 1.40GHz   20.62  10.31   40.87  20.48

上の表では ARM Binary Translation は同クロックの Cortex-A9 よりも
若干遅い程度、動作クロックの分だけ Cortex-A9 よりも高速な結果となっています。
最近増えてきた低価格帯デバイスの Cortex-A7 Quad core よりは、
ずっと高速に演算できるでしょう。

ただしあくまでピーク演算能力の比較なので、
実アプリケーションに則した結果ではない点に注意してください。
演算命令の分布次第で速度が異なります。
例えば下の命令単位の結果を見ると変換された vmla が特に低速であることがわかります。
vmla を多用した最適化されたプログラムほど速度が遅くなるかもしれません。

上の表は今回の用途では適切なベンチマークではないので、参考程度にお願いします。

// armeabi-v7a (Binary Translation)
* VFP/NEON (単精度 fp) single-thread
                                     sec     MFLOPS     MFLOPS
----------------------------------------------------------------
VFP fmuls (32bit x1) n8       :    3.954     1011.6     1011.6
VFP fadds (32bit x1) n8       :    3.332     1200.6     1200.6
VFP fmacs (32bit x1) n8       :    8.371      955.7      955.7
VFP vfma.f32 (32bit x1) n8    :        -          -          -
NEON vmul.f32 (32bit x2) n8   :    6.009     1331.4     1331.4
NEON vadd.f32 (32bit x2) n8   :    3.816     2096.6     2096.6
NEON vmla.f32 (32bit x2) n8   :   22.824      701.0      701.0
NEON vfma.f32 (32bit x2) n8   :        -          -          -
NEON vmul.f32 (32bit x4) n8   :    6.012     2661.2     2661.2
NEON vadd.f32 (32bit x4) n8   :    3.347     4780.6     4780.6
NEON vmla.f32 (32bit x4) n8   :   16.516     1937.5     1937.5
NEON vfma.f32 (32bit x4) n8   :        -          -          -

↑ FMA は無く VFPv3-D32 NEON 相当。

// x86
* SSE/AVX (単精度 fp) single-thread
                                     sec     MFLOPS     MFLOPS
----------------------------------------------------------------
SSE mulss (32bit x1) n8       :    2.203     1816.0     1816.0
SSE addss (32bit x1) n8       :    2.152     1858.6     1858.6
SSE mulps (32bit x4) n8       :    4.292     3728.2     3728.2
SSE addps (32bit x4) n8       :    2.146     7457.2     7457.2
SSE mul+addps (32bit x4) n8   :    2.146     7456.3     7456.3
SSE ml+ad+addps (32bit x4) n6 :    1.877     8949.5     8949.5
SSE mulss (32bit x1) ns4      :    2.145     1864.4     1864.4
SSE addss (32bit x1) ns4      :    2.145     1864.7     1864.7
SSE mulps (32bit x4) ns4      :    4.291     3728.9     3728.9
SSE addps (32bit x4) ns4      :    2.153     7430.9     7430.9
AVX vmulps (32bit x8) n8      :        -          -          -
AVX vaddps (32bit x8) n8      :        -          -          -
AVX vmul+addps (32bit x8) n8  :        -          -          -
AVX vml+ad+adps (32bit x8) n6 :        -          -          -

● ABI

ro.product.cpu.abi=x86
ro.product.cpu.abi2=armeabi-v7a

第二 ABI として armeabi-v7a が指定されています。
同じ ARM でも armeabi (ARMv5TE) は変換対象とならないようです。
実際に armeabi だけのプログラムを走らせましたが実行できませんでした。
armeabi-v7a ではなく armeabi でビルドしている古いプログラムは
動作しないことになります。
対応アプリが 100% にならない理由の一つだと思われます。


● CPU Features

NDK に付属している CPU Features Library は、SSE,NEON 等の CPU 拡張命令が
使えるかどうかを返します。
このライブラリは Hardware Register MVFR (CPUID相当) を見ているのではなく、
基本的には /proc/cpuinfo から判断しています。
そのため lib (so) バイナリを x86 に変換するだけでは互換性が不十分です。

x86 の Binary Translator は ARM コードからアクセスした場合
/proc/cpuinfo も ARM 相当に置き換えているようです。
CPU Feature を正しく認識できているのはこの機能のおかげでしょう。
armeabi-v7a のコードから見える cpuinfo は下記の通りです。

Processor	: ARMv7 processor rev 1 (v7l) 
BogoMIPS	: 1500.0 
Features	: neon vfp swp half thumb fastmult edsp vfpv3 
Processor	: ARMv7 processor rev 1 (v7l) 
BogoMIPS	: 1500.0 
Features	: neon vfp swp half thumb fastmult edsp vfpv3 

Apple Watch Series 6 に乗り換えました。4年前のモデル Apple Watch Series 2 からの移行です。4世代分の変化は極めて大きく、その性能の差をを思い知らされました。

Series 2 は操作していて待たされることが結構あります。

アプリ起動には時間がかかり、画面中央でドットの輪が回転する画面をしばらく見続けることになります。地図を起動しても最初に地形が出てくるまで 10秒以上かかりますしスクロールには読み込みが追いついていません。ワークアウトのメニューも画面切り替え直後に一瞬固まっていてタッチの反応が悪いこともあります。SIri の反応も遅く、きちんと聞こえているのか不安になって何度も話しかけがちです。スマートフォンと比べると制約も多いため、ある程度仕方がない部分もあるでしょう。

ところが、Apple Watch Series 6 は画面も操作もハイエンドスマートフォンのように滑らかで快適です。

アプリも即座に起動するし、地図の読み込みもスクロールに追従しており、Siri の呼びかけもすぐに応えてくれます。ワークアウトのメニューも固まらずにタッチに反応しており、操作にストレスがありません。

本当に快適になったので、どれくらいハードウエア性能が上がっているか調べてみました。vfpbench を移植し、実際に測定した結果をまとめています。


Series 6 は RAM を 1.5GB 搭載していることがわかりました。Series 2 と比べると容量は 3倍になっておりだいぶ余裕があります。Series 2 は watchOS 7 から対象外となっており、やはり RAM 容量に無理があったのではないかと思います。

CPU も 64bit (?) になり Clock も上がっています。fp32 の演算速度に限ってみるとピークで 14倍の速度が出ています。


●ログの詳細より

以前も書いていますが Series 2 の CPU core はおそらく Cortex-A7 だと思われます。個々の浮動小数点演算命令のスループットやレイテンシの傾向が Cortex-A7 によく似ているからです。

同時に CPU の clock も推測できます。スカラー命令の MOPS からおよそ 450MHz 前後であることがわかります。

下記はその抜粋です。

Apple Watch Series 2 (Apple S2) fp32

                                      TIME(s)   MFLOPS      MOPS     FOP   IPC
VFP fmuls (32bit x1) n8           :    1.387      432.5      432.5  (  1.0 0.0)
VFP fadds (32bit x1) n8           :    1.354      443.1      443.1  (  1.0 0.0)
VFP fmacs (32bit x1) n8           :    1.332      900.6      450.3  (  2.0 0.0)
～
NEON vmul.f32 (32bit x4) n12      :    8.046      447.4      111.9  (  4.0 0.0)
NEON vadd.f32 (32bit x4) n12      :    7.972      451.6      112.9  (  4.0 0.0)
NEON vmla.f32 (32bit x4) n12      :    8.449      852.1      106.5  (  8.0 0.0)
NEON vfma.f32 (32bit x4) n12      :    8.337      863.6      108.0  (  8.0 0.0)

同じように Series 6 の結果も見てみます。こちらはスカラーもベクターも同速であり、かつ加算命令が乗算の 2倍回っています。128bit SIMD でも速度が落ちないので、同時に実行できる命令は「128bit 加算 + 128 bit 積和」の組み合わせだと考えられます。

これが ARM の 64bit core なら「64bit 積和 x 2」なので、128bit SIMD がスカラーや 64bit SIMD と同じ速度になることがありません。Apple の独自 core であることがわかります。乗算命令の MOPS をみると動作クロックはおそらく 1.5GHz 前後でしょう。

Apple Watch Series 6 (Apple S6) fp32

                                      TIME(s)   MFLOPS      MOPS     FOP   IPC
FPU fmul (32bit x1) n8            :    0.390     1538.2     1538.2  (  1.0 0.0)
FPU fadd (32bit x1) n8            :    0.194     3089.5     3089.5  (  1.0 0.0)
FPU fmadd (32bit x1) n8           :    0.388     3091.1     1545.6  (  2.0 0.0)
～
NEON fmul.4s (32bit x4) n12       :    0.585     6156.1     1539.0  (  4.0 0.0)
NEON fadd.4s (32bit x4) n12       :    0.291    12381.2     3095.3  (  4.0 0.0)
NEON fmla.4s (32bit x4) n12       :    0.581    12386.1     1548.3  (  8.0 0.0)

Apple Watch の 64bit CPU である Apple S4/S5/S6 は fp16 (半精度/16bit 浮動小数点) の演算命令に対応しています。Xcode で arm64_32 (Apple Watch 64bit) をターゲットにビルドを行うと clang が下記のマクロを定義することから判断できます。


実際に vfpbench でも fp16 演算命令が走っており、fp32 の倍の速度が出ています。iOS でいえば arm64e に相当するので、arm64_32 も同じ世代だと仮定するなら ARMv8.3A が対象となります。おそらく A12 以降の LITTLE core が用いられているのではないでしょうか。

Apple Watch Series 6 (Aple S6) fp16

                                      TIME(s)   MFLOPS      MOPS     FOP   IPC
NEON fmul.8h (16bit x8) n12       :    0.583    12350.5     1543.8  (  8.0 0.0)
NEON fadd.8h (16bit x8) n12       :    0.290    24794.4     3099.3  (  8.0 0.0)
NEON fmla.8h (16bit x8) n12       :    0.582    24729.8     1545.6  ( 16.0 0.0)

● arm64_32

説明に出てきた arm64_32 は Apple Watch 専用のアーキテクチャタイプです。表にまとめてみます。


arm64_32 は、ARM の 64bit アーキテクチャである ARMv8A Aarch64 の命令セットを採用していながら ILP32 (ポインタサイズが 32bit) の構成を使用しています。そのため 64bit といいつつも実質 32bit です。ILP32 なら ARMv7A もしくは ARMv8A AArch32 と何が違うのか？と思うかもしれませんが、別物になっています。arm64_32 はアドレスが 32bit なだけで AArch64 の命令が動きます。

ARM は生まれたときから 32bit の命令セットでしたが、ARMv8 で 64bit 化するときに全く新しいものに置き換わりました。レジスタも命令の種類もエンコーディングも違います。

例えば ARM 32bit では殆どの命令で条件付き実行やシフタが内蔵されていましたが 64bit 命令にはありません。他の RISC CPU のような Zero Register も登場します。ほぼ別の CPU となっており、Intel の IA-32 と IA-64 の関係に似ているかもしれません。

ARM の 64bit CPU は ARMv7A 互換の AArch32 (32bit) と新しい AArch64 (64bit) の 2 種類の命令デコーダーを持っていることになります。ILP32 として 32bit CPU 相当の使い方をするなら、AArch32 を使った方がコード資産を引き継げるし都合が良いように思えます。しかしながら Apple Watch は AArch64 のまま 32bit 化しているので、何かしらの理由があるのでしょう。

Apple は iOS 11 のタイミングで 32bit アプリを廃止して一切起動できなくなりました。同時に iOS 11 を搭載して出荷されたのが iPhone X (Apple A11) なので、Apple A11 以降は AArch32 mode が不要であると言えます。そもそも実行できない可能性があります。もしくはパフォーマンス面や消費電力、セキュリティなどの面で ARMv8.x 以降の命令に依存しているのかもしれません。


Wear OS (Android Wear) のスマートウォッチは最初に登場した初期モデルからスペックが共通で Snadpragon 400 / 210 ベースのまま変わっていません。新型が出ても性能はほぼ据え置きとなっています。対する Apple Watch は毎年新モデルが登場し、それに合わせて搭載 SoC も進化していることがよくわかります。

ログの全体は下記のページにあります。
・VFP Benchmark Log 計測結果まとめ

関連エントリ
・MacBook Air Late 2020 / Apple M1 のビルド速度と浮動小数点演算能力
・セサミmini、スマートロックを使って1年
・2年間使った Apple Watch Series 2
・Apple Watch S2 の CPU と浮動小数点演算

新しい iPod touch 6 は iPhone 4S 相当から 2世代飛んで一気に iPhone 6 世代へ移行しています。最も安価な iOS Device の底上げが行われました。

S-SP = Single Thread 単精度  (GFLOPS) いずれも数値が大きいほうが高速
S-DP = Single Thread 倍精度  (GFLOPS)
M-SP = Multi Thread 単精度  (GFLOPS)
M-DP = Multi Thread 倍精度  (GFLOPS)

浮動小数点演算のピーク値だけの比較なので実際のアプリケーションの速度とは異なります。ですが、浮動小数点演算の速度だけでも Apple の公称値である「CPU 速度で 6倍」に近い数値を得ることが出来ました。

M-SP: 35.5 (iPod touch 6) / 6.2 (iPod touch 5) = 5.7倍

また 32bit 世代 (A4～A6) と 64bit 世代 (A7/A8) の間に入る調度良い比較対象だったので Mac mini Early 2009 の結果も載せてみました。もちろん最新の Core i5/i7 には敵いません。Android や Desktop PC 含めた結果を下記に載せています。

・VFP Benchmark Log

GPU は ASTC 対応で PowerVR Series6XT (iOS GPUFamily2) を確認。

GL_VERSION: OpenGL ES 3.0 Apple A8 GPU - 53.13
GL_RENDERER: Apple A8 GPU
GL_VENDOR: Apple Inc.
GL_SHADING_LANGUAGE_VERSION: OpenGL ES GLSL ES 3.00

Extension:
GL_OES_standard_derivatives
GL_KHR_texture_compression_astc_ldr
GL_EXT_color_buffer_half_float
GL_EXT_debug_label
GL_EXT_debug_marker
GL_EXT_pvrtc_sRGB
GL_EXT_read_format_bgra
GL_EXT_separate_shader_objects
GL_EXT_shader_framebuffer_fetch
GL_EXT_shader_texture_lod
GL_EXT_shadow_samplers
GL_EXT_texture_filter_anisotropic
GL_APPLE_clip_distance
GL_APPLE_color_buffer_packed_float
GL_APPLE_copy_texture_levels
GL_APPLE_rgb_422
GL_APPLE_texture_format_BGRA8888
GL_IMG_read_format
GL_IMG_texture_compression_pvrtc

RAM は 1GB でした。

HW INFO: Machine = iPod7,1
HW INFO: Model = N102AP
HW INFO: Arch = N102AP
HW INFO: ByteOrder = 1234
HW INFO: NCPU = 2
HW INFO: MemSize = 1039306752
HW INFO: UserMem = 862314496
HW INFO: PageSize = 16384
HW INFO: VectorUnit = 0
HW INFO: Float = 0

関連エントリ
・iPad Air 2 (Apple A8X) の浮動小数点演算能力
・Android x86 Binary Translator を試してみる
・iPhone 5s A7 CPU の浮動小数点演算速度 (2) (arm64/AArch64/64bit)
・VFP Benchmark 関連

Raspberry Pi 2 を入手したので使ってみました。
ARM11 の Raspberry Pi と比べると格段に速くなっています。

VFP Benchmark の比較

               CPU       clock       single fp      double fp
----------------------------------------------------------------
Raspberry Pi B ARM1176   0.7GHz x1   0.674 GFLOPS   0.674 GFLOPS
Raspberry Pi 2 Cortex-A7 0.9GHz x4   7.087 GFLOPS   3.472 GFLOPS

ARM11 世代の VFP と比べると core あたり 2.6倍 (単精度時,クロック差含む)。

詳細な結果は下記に追加しました

・VFP Benchmark Log

Cortex-A7 は big.LITTLE でも省電力 core として用いられており、
単体の性能はあまり高くありません。

それでもエントリークラスのスマートフォンやタブレットでは
同じ Cortex-A7 Quad core のデバイスが多数リリースされています。
Snapdraogn 400 MSM8926/8226 や MT8125/8389/6582 など、
それなりにバランスが良い構成なのだと思われます。

下記は手持ちライブラリ(flatlib3)のビルド時間の比較です。
36分から 5分半へと現実的な数値になりました。
SD Card の速度に依存するためあまり正確ではないですが、
およそ 6.6倍で公称値通りといえそうです。

                                Clock  core  ISA    RAM    gcc-4.8 clang-3.4
---------------------------------------------------------------------------
(1) Raspberry Pi B ARM1176JZF   0.7GHz x1    armv6l 0.5GB   36m18s
(2) Raspberry Pi 2 Cortex-A7    0.9GHz x4    armv7l   1GB    5m29s
(3) Nexus 7 2012   Cortex-A9    1.3GHz x4    armv7l   1GB    3m42s
(4) Atom Z540      Bonnell      1.8GHz x1+HT x86      2GB    6m23s   6m18s
(5) BayTrail-D J1900 Silvermont 2.0GHz x4    x86_64   8GB    1m30s   1m11s
(6) Athlon-5350    Jaguar       2.0GHz x4    x86_64   8GB    1m33s   1m10s
(7) Core i7-2720QM SandyBridge  2.2GHz x4+HT x86_64  16GB    0m31s   0m24s

・36m18s = 36分18秒
・値は実行時間(3回の平均)。数値が小さい方が高速

Raspberry Pi 2 でそのままビルドすると ARMv6 のバイナリが生成されるため、
gcc-4.8 -march=armv7-a mfpu=neon-vfpv4 のオプションでコンパイルしています。

下記はそれぞれの詳細です。

(1) Raspberry Pi model B
BMC2835 ARM1176JZF 0.7GHz x1
RAM 512MB, SD 16GB
Debian wheezy armv6l (console)


(2) Raspberry Pi 2 model B
BMC2836 Cortex-A7 0.9GHz x4
RAM 1GB DDR2, SD 16GB
Debian wheezy armv7l (console)
gcc-4.8 (-march=armv7-a mfpu=neon-vfpv4)


(3) Nexus 7 (2012)
Tegra 3 T30L Cortex-A9 1.3GHz x4
RAM 1GB DDR3L, 8GB
Ubuntu 13.04 armv7l (console)


(4) VAIO Type P
Atom Z540 Bonnell 1.86GHz x1+HT
RAM 2GB, SSD 64GB
Ubuntu 14.04LTS x86 (console)


(5) Desktop PC
BayTrail-D Celeron J1900 Silvermont 2.0GHz x4
RAM 8GB, HDD
Ubuntu 14.04LTS x86_64


(6) Desktop PC
Athlon-5350 Jaguar 2.0GHz x4
RAM 8GB, HDD
Ubuntu 14.04LTS x86_64


(7) Desktop PC
Core i7-2720QM SandyBridge 2.2GHz x4+HT
RAM 16GB, HDD
Ubuntu 14.04LTS x86_64

GPU 周りは変わっていないようです。下記ページに追加しました。

・CPU/GPU OpenGL ES Extension (Mobile GPU)

ARM11 搭載機種ということで TouchDiamond S21HT もテストに加えてみました。
・昨日の結果

                Desire   ZenTouch2  ZiiO7    LuvPad   ODROID-S     S21HT
--------------------------------------------------------------------------
Android OS       2.2       2.1       2.1       2.2       2.2        2.2
Processor      QSD8250    i.MX51    ZMS-08   Tegra250  S5PC110   MSM7201A
CPU Hz           1GHz     800MHz     1GHz     1GHz x2    1GHz      528MHz
CPU Arch        ARMv7A    ARMv7A    ARMv7A    ARMv7A    ARMv7A   ARMv6TEJ
CPU            Scorpion  CortexA8  CortexA8  CortexA9  CortexA8 ARM1136EJ
FPU           VFP3,NEON VFP3,NEON VFP3,NEON    VFP3   VFP3,NEON      ---
GPU           Adreno200  AMD Z430   ZMS-08   Tegra250 PVRSGX540 Adreno130
OpenGL ES          2.0       2.0       2.0       2.0       2.0       1.1
RAM              576MB     256MB?    512MB     512MB     512MB     192MB
Display        800x480   480x320   800x480  1024x600   480x320   640x480
--------------------------------------------------------------------------
(1) Graphcis     28.16    225.21    395.79    293.48    517.90      9.38
(1) CPU Float  2049.57    432.77    581.37   2816.16   1675.83    128.41
(1) Memory      339.03    183.67    721.17    516.18    680.16    116.95
(2) CPU Bench    759ms    1207ms    1038ms     436ms     719ms    4698ms
(3) GPU Abs      14633     22071       ---       ---       ---       ---
(3) GPU Rel      11587     26300       ---       ---       ---       ---
(4) Quadrant      1259       979      1995      1827      1040       434
(5) Linpack      32.82      5.66      5.97     36.71     14.03      1.98
--------------------------------------------------------------------------
* 値が大きいほうが速い, (2) のみ値が小さいほうが速い

HTC Touch Diamond S21HT の MSM7201A は DirectX7/OpenGL ES 1.1 の GPU を
搭載しているので、低速ながらグラフィック系のテストも通りました。
ただし CPU core は VFP 無しの ARM11 なので Float 演算を行うテストの
スコアは大きく落ちています。

また ARMv6 (ARM11) と ARMv7 世代の性能差は大きく、同クロックで比べても
ARMv7 系はかなり高速に動作します。
NDK のバイナリの違いもありますので、ゲームなど高パフォーマンス用途を
考えると ARM v7 系とそれ以外の違いはますます広がることになります。

ODROID-S の Linpack も追加しました。
同じ A8 の ZenTouch2/ZiiO7 と比べて OS 2.2 になった分大幅に高速化されて
いますが Snapdragon や A9 には届きません。
(2) CPU Bench ではむしろ Snapdragon より速いので、やはり A8 の VFP が
原因だと考えられます。

整数: A9 ＞ A8 ＞ Snapdragon1
浮動小数 VFP: A9 ＞ Snapdragon1 ＞＞ A8
浮動小数NEON: A8 ≧ Snapdragon1

詳しい数値
・CPU/GPU Benchmark

関連エントリ
・各種 Android 端末のベンチマークテスト
・Android NDK r5 と armeabi, 浮動小数命令の種類

Cortex-A5 搭載 Android 端末 SXZ-PD10
(SHENZHEN LINK-CREATE TECHNOLOGY PD10 普及版)
を試してみました。
CPU や GPU のデータは下記ページにまとめています

・CPU/GPU

以下抜粋です。

Processor       : ARMv7 Processor rev 1 (v7l)
BogoMIPS        : 415.33
Features        : swp half thumb fastmult vfp edsp thumbee neon vfpv3 
CPU implementer : 0x41
CPU architecture: 7
CPU variant     : 0x0
CPU part        : 0xc05
CPU revision    : 1

GL_VERSION: OpenGL ES 2.0
GL_RENDERER: Mali-400 MP
GL_VENDOR: ARM
GL_SHADING_LANGUAGE_VERSION: OpenGL ES GLSL ES 1.00

Cortex-A5 は vfpv4 ですが cpuinfo の Features では vfpv3。

・ARM vfp の種類

上記のように SXZ-PD10 は Cortex-A5 1.2GHz + Mali-400 で
Android 4.0 が搭載されています。
実際にプログラムを走らせた結果は次のページにまとめています。

・CPU benchmark

以下は部分的に抜き出したものです。

SoC / CPU                   MB/sec   T/GHz  device
------------------------------------------------------------------
MSM7225 ARM11        600MHz   6.99   11.65  IDEOS
JZ4770 XBurst1       1.0GHz  16.40   16.40  Novo7 Paladin
TCC8923 Cortex-A5    1.2GHz  18.42   15.35  SXZ-PD10
MSM8255 Scorpion     1.0GHz  24.82   24.82  Xperia ray SC-03C  
Tegra2 Cortex-A9     1.0GHz  25.11   25.11  OptimusPad L-06C
Atom Z540            1.86GHz 30.44   16.37  VAIO Type P VGN-P90S
Exynos4210 Cortex-A9 1.2GHz  33.42   27.85  Galaxy S2 SC-02C
Tegra3 Cortex-A9     1.3GHz  36.15   25.82  EeePad TF201
APQ8060 Scorpion     1.5GHz  42.64   28.43  Galaxy Tab SC-01D

MB/sec の数値が大きい方が速い。
整数演算のみ。single thread (single core) のみ。
・MB/sec = 1秒あたりの変換byte数
・T/GHz  = MB/sec を CPU 1GHz あたりの速度に変換したもの

single thread のテストなので Multi core CPU や HT 対応 CPU でも
1 thread 分の速度なので注意してください。

Cortex-A5 は同時に実行できる命令数が半分なので、上位の CPU より
遅くなっています。

ところがこの Cortex-A5 には vfpv4 + neon が搭載されており、
浮動小数点演算ではかなり高速であることがわかりました。

・CPU bench FPU

Linpack 1.2.8

Single  Multi
MFLOPS  MFLOPS  Soc/CPU
-------------------------------------------------------------------
18.091          Cortex-A8     1.0GHz  S5PC110    Galaxy S SC-02B
18.684          MIPS XBurst1  1.0GHz  JZ4770     Novo7 Paladin
25.732          Cortex-A5     1.2GHz  TCC8923    SXZ-PD10
35.628          Scorpion      1.0GHz  QSD8250    Desire X06HT
31.142  57.331  Cortex-A9 x2  1.0GHz  Tegra2     OptimusPad L-06C
46.164  74.664  Scorpion  x2  1.2GHz  MSM8660    EVO 3D ISW12HT
56.076  89.860  Scorpion  x2  1.5GHz  APQ8060    Galaxy Tab SC-01D
57.342  92.981  Cortex-A9 x2  1.2GHz  Exynos4210 Galaxy S2 SC-02C
47.071 140.908  Cortex-A9 x4  1.3GHz  Tegra3     EeePad TF201

MFLOPS の数値が大きいほうが速い

                          Render                  NDK    VFP  NEON
CPU                       Script   Java  Java2    C++    asm   asm
--------------------------------------------------------------------
JZ4770   XBurst1 1.0GHz     289     479  11736    158     -      -
TCC8923  Cortex-A5 1.2GHz    67     295   6798     57    35     23
S5PC110  Cortex-A8 1.0GHz     -     698   1012    166   139     20
Tegra 2  Cortex-A9 1.0GHz    50     243   1219     75    46      -
Tegra 3  Cortex-A9 1.3GHz    38     172   3634     42    35     34
APQ8060  Scorpion 1.5GHz      -     279   1758     43    26     26

単位は実行時間(ms)、数値が小さいほうが速い。

Cortex-A8 のように vfp で遅くなることもなく、vfp/neon 共に高速に
実行できています。

GPU の結果は下記ページに追加しています。

・Mobile GPU bench mark


関連エントリ
・2012/02/15 Android 4.0 MIPS で RenderScript, ainol Novo 7 Paladin の浮動小数点演算速度
・2012/01/14 Android 4.0 RenderScript Compute の速度 その2
・2011/11/07 Android 3.x RenderScript (7) RenderScript Compute の速度

2020年後期の新型 MacBook Air (Apple M1 ARM) のビルド速度と vfpbench の結果です。2020年前期発売の Intel モデルと比べて 5倍高速でした。


・↑コンパイル時間の比較。Time が小さい方が速い。

vfpbench の結果は下記の通りです。macOS では LITTLE core だけ Affinity で固定することができないので Multi-Thread の値はまだ不正確です。そのため Single Thread だけ比較しています。

↓vfpbench の Single Thread の結果のみ抜粋


・↑Half/Single/Double の数値は GFLOPS。値が大きい方が速い。

Apple M1 の結果詳細(抜粋)

                                      TIME(s)   MFLOPS      MOPS     FOP   IPC
FPU fmul (32bit x1) n8            :    0.157    12195.9    12195.9  (  1.0 3.8)
FPU fadd (32bit x1) n8            :    0.150    12799.9    12799.9  (  1.0 4.0)
FPU fmadd (32bit x1) n8           :    0.301    12753.6     6376.8  (  2.0 2.0)
NEON fmul.2s (32bit x2) n8        :    0.150    25593.3    12796.7  (  2.0 4.0)
NEON fadd.2s (32bit x2) n8        :    0.150    25570.3    12785.2  (  2.0 4.0)
NEON fmla.2s (32bit x2) n8        :    0.302    25441.6     6360.4  (  4.0 2.0)
NEON fmul.4s (32bit x4) n12       :    0.225    51167.5    12791.9  (  4.0 4.0)
NEON fadd.4s (32bit x4) n12       :    0.225    51086.7    12771.7  (  4.0 4.0)
NEON fmla.4s (32bit x4) n12       :    0.301    76531.6     9566.5  (  8.0 3.0)

この結果より、SIMD (NEON) は 128bit FMA (fmla) が 3命令同時に走っており、ピーク値は 1 cycle あたり 24fop であることがわかります。256bit FMA が 2命令走る Haswell/Zen2/3 は 32 fop 、AVX512 では最大 64 fop なので、単 core でのピーク FLOPS はそれよりも落ちます。

その代わり注目すべきは IPC の方で、FMA で 3命令、ADD/MUL でサイクルあたりのスループットが 4命令です。Intel は 128bit でも最大 2命令、Zen2 では Add + Mul の組合わせのみ 4命令なので、スカラーや 128bit 演算は Apple M1 の方が速度出る可能性があります。

FLOPS 表の「Apple M1 x86_64」は Rosetta によるバイナリ変換で実行した場合のものです。AVX/FMA 命令が動かなかったので SSE4.2 までのオプションでビルドしています。FMA がないのでピーク値は半減していますが、加減算命令の IPC は 3～4 と高い値を維持していました。

コンパイル時間の比較を参考用に載せておきます。OS と SSD、使用したコンパイラが異なるので単純に比較できませんのでご了承ください。また必ずしもあらゆるタスクでこの性能差が生じるわけではありません。特にビルドに時間がかかる巨大なプロジェクトではかなり遅くなると思います。



上記以外の他のデバイスとの比較はこちら↓にあります。

・Compile Benchmark


関連ページ
・Hyperでんち: Compile Benchmark
・Hyperでんち: vfpbench 結果まとめ

関連エントリ
・Ice Lake の vfpbench 結果と AVX512 命令
・4倍速い Ryzen 9 3950X の UE4 コンパイル速度
・Snapdragon 845 ARMv8.2A 半精度 fp16 演算命令を使ってみる / Deep Learning 命令
・Snapdragon 835 と 845 のコンパイル時間の比較＆浮動小数点演算能力
・Snapdragon 845 の浮動小数点演算速度
・ARM CPU の浮動小数点演算能力まとめ
・HTC 10 Snapdragon 820 Kyro の浮動小数点演算能力
・iPhone SE, Apple A9 の浮動小数点演算速度
・ARM Cortex-A53 の浮動小数点演算速度とコンパイル時間の比較
・iPod touch 6 の浮動小数点演算速度は Core 2 Duo ライン超え
・iPad Air 2 (Apple A8X) の浮動小数点演算能力
・ARM cpu vfp の種類と fp16 命令を使ってみる

いろんなプロセッサの端末が揃ったのでベンチマークソフトを走らせてみました。
使用したソフトは下記のとおり。

(1) Benchmark 1.03
(2) CPU Benchmark 1.7.1
(3) GPUBench 1.0.0
(4) Quadrant standard 1.1.5
(5) Linpack 1.1.8

                     Desire   ZenTouch2   ZiiO7     LuvPad   ODROID-S
---------------------------------------------------------------------
Android OS              2.2       2.1       2.1       2.2       2.2
Processor            QSD8250    i.MX51    ZMS-08   Tegra250  S5PC110
CPU Hz                 1GHz     800MHz     1GHz     1GHz x2   1GHz
---------------------------------------------------------------------
(1) Bench Graphcis     28.16    225.21    395.79    293.48    517.90
(1) Bench CPU Float  2049.57    432.77    581.37   2816.16   1675.83
(1) Bench Memory      339.03    183.67    721.17    516.18    680.16
(2) CPU Benchmark     759ms    1207ms    1038ms     436ms     719ms
(3) GPU Absolute     14633     22071       ---       ---       ---
(3) GPU Relative     11587     26300       ---       ---       ---
(4) Quadrant          1259       979      1995      1827      1040
(5) Linpack           32.82      5.66      5.97     36.71      ---
----------------------------------------------------------------------
* (2) のみ値が小さいほうが速い

テスト環境は厳密に合わせたわけではないので結果は参考程度にお願いします。
例えば通信の接続状況とか起動中のサービスなど。

OS の違いを考慮する必要があります。
Android OS 2.2 では JIT が搭載されたため、Java アプリの場合は実行内容に
よっては 2.1 と 2.2 で極端な差が出ます。(1) の CPU や (5) など。
ZEN Touch2 と ZiiO7 で全体的に速度が低いのはそのためです。

GPU Test は OpenGL ES 2.0 ですが、動かないケースが多くあまり比較
できませんでした。

Quadrant は Disk/DB 速度が含まれているのでプロセッサのみの結果では
ないようです。例えば Desire の結果とプリセットされている結果を比べると
OS 2.2 になって 2倍程スコアが上がっていることがわかります。
その分を考慮すると OS 2.1 の ZEN Touch 2 や ZiiO7 はかなり突出した
値が出ているように見えます。原因は不明です。

LuvPad の Tegra は GPU 側をきちんと評価できていませんが、とりあえず
CPU core が高速なことがわかります。おそらく多くのテストは Single Thread
だと思われるので、A9 Dual ならもっと速いのではないでしょうか。

厳密ではなく大雑把な傾向ですがおそらく同クロックの場合

整数: A9 ＞ A8 ＞ Snapdragon1
浮動小数 VFP: A9 ＞ Snapdragon1 ＞ A8
(NEON: A8 ≧ Snapdragon1)

といった印象です。
GPU は残念ながらデータ不足です。
ただ同一と思われた GPU でも違う結果が出ています。
画面サイズやバス速度の差もあるのかもしれません。

結果の詳細はこちら
・CPU/GPU Benchmark

ちなみにベンチマーク結果と実際の使用感、体感速度は全くの別物です。
現状だとほぼ Desire X06HT とそれ以外の 2つに分けられます。
ZEN Touch2/ZiiO7 はパネルにさえ慣れれば反応は良好な方です。


テスト端末

・Desire
 HTC Desire X06HT
 Qualcomm Snapdragon QSD8250, Scorpion 1GHz, Adreno 200
 Android 2.2
 800x480
 RAM 576MB

・ZenTouch2
 Creative ZEN Touch 2 (8GB) TN-T28G
 Freescale i.MX51, Cortex-A8 800MHz, AMD Z430
 Android 2.1
 480x320
 RAM 256MB(?)

・ZiiO7
 Creative ZiiO 7 (8GB) ZO-7S
 ZiiLabs ZMS-08 HD, Cortex-A8 1GHz, ZMS-08
 Android 2.1
 800x480
 RAM 512MB

・LuvPad
 MouseComputer LuvPad AD100
 NVIDIA Tegra 250, Cortex-A9 x2 1GHz, Tegra 250
 Android 2.2
 1024x600
 RAM 512MB

・ODROID-S (借り物)
 HardKernel ODROID-S
 Sumsung S5PC110, Cortex-A8 1GHz, PowerVR SGX 540
 Android 2.2
 480x320
 RAM 512MB

NVIDIA SHIELD Android TV はすでに OpenGL ES 3.2 の Context に対応していることがわかりました。

Android 5.1 Tegra X1 Maxwell (256)

GL_VERSION: OpenGL ES 3.2 NVIDIA 349.00
GL_RENDERER: NVIDIA Tegra
GL_VENDOR: NVIDIA Corporation
GL_SHADING_LANGUAGE_VERSION: OpenGL ES GLSL ES 3.20

OpenGL ES 3.2 は ES 3.1 AEP が取り込まれており D3D11/OpenGL 4.x 相当の API となります。Android SDK が 3.2 に対応していないので現状ではあまり意味はありませんが、Desktop と共通のドライバが使われていることが読み取れます。

下記は Tegra K1 (Nexus 9 Driver 343.00) から追加された Extension です。

GL_EXT_discard_framebuffer
GL_EXT_draw_elements_base_vertex
GL_EXT_multi_draw_indirect
GL_EXT_post_depth_coverage
GL_EXT_raster_multisample
GL_EXT_shader_texture_lod
GL_KHR_context_flush_control
GL_KHR_robust_buffer_access_behavior
GL_KHR_robustness
GL_NV_conditional_render
GL_NV_conservative_raster
GL_NV_fill_rectangle
GL_NV_fragment_coverage_to_color
GL_NV_fragment_shader_interlock
GL_NV_framebuffer_mixed_samples
GL_NV_geometry_shader_passthrough
GL_NV_path_rendering_shared_edge
GL_NV_polygon_mode
GL_NV_sample_locations
GL_NV_sample_mask_override_coverage
GL_NV_shader_noperspective_interpolation
GL_NV_viewport_array
GL_NV_viewport_array2
GL_OES_copy_image
GL_OES_draw_buffers_indexed
GL_OES_draw_elements_base_vertex
GL_OES_texture_border_clamp
GL_OES_tessellation_point_size
GL_OES_tessellation_shader
GL_OES_texture_buffer
GL_OES_geometry_point_size
GL_OES_geometry_shader
GL_OES_gpu_shader5
GL_OES_shader_io_blocks
GL_OES_texture_view
GL_OES_primitive_bounding_box
GL_OES_texture_cube_map_array

↑ GL_NV_conservative_raster や GL_NV_fragment_shader_interlock など、Maxwell GM2xx で追加された D3D12 相当の機能も見えます。(参考)
↓ 他にも K1 との違いとして fp16 対応があります。

Precision:
 0: [15 15] 10       VS float  lowp
 1: [15 15] 10       VS float  mediump
 2: [127 127] 23     VS float  highp
 3: [31 30] 0        VS int    lowp
 4: [31 30] 0        VS int    mediump
 5: [31 30] 0        VS int    highp
 6: [15 15] 10       FS float  lowp
 7: [15 15] 10       FS float  mediump
 8: [127 127] 23     FS float  highp
 9: [31 30] 0        FS int    lowp
10: [31 30] 0        FS int    mediump
11: [31 30] 0        FS int    highp

詳細は下記に追加しました。

・CPU/GPU OpenGL ES Extension (Mobile GPU)

公式サイトには Tegra X1 の CPU clock が載っていませんが、調べた限りでは 2.0GHz でした。ただし VFP Benchmark の実測では 2.1GHz 相当なので TB のような機能が働いているものと思われます。

・VFP Benchmark Log


関連エントリ
・Direct3D 12 GeForce GTX970 は FeatureLevel 12_1 対応、Resource Bind/Heap Tier は低い
・NVIDIA SHIELD Tablet Tegra K1 は OpenGL ES 3.1 で Extension Pack 対応

Tegra K1 を搭載した SHILED Tablet が発売されました。
SHIELD Tablet の CPU Core は Tegra 4 同様 32bit Cortex-A15 Quad ですが、
GPU の本気度がこれまでと違います。

ブランドイメージに反して GPU が非力だった Tegra シリーズも、
K1 でようやく NVIDIA らしいスペックになったと言えるでしょう。

・NVIDIA SHIELD

GL_VENDOR:   NVIDIA Corporation
GL_RENDERER: NVIDIA Tegra
GL_VERSION:  OpenGL ES 3.1 340.00

Extension:
GL_EXT_debug_marker
GL_EXT_blend_minmax
GL_EXT_color_buffer_float
GL_EXT_color_buffer_half_float
GL_EXT_copy_image
GL_EXT_debug_label
GL_EXT_draw_buffers_indexed
GL_EXT_frag_depth
GL_EXT_geometry_point_size
GL_EXT_geometry_shader
GL_EXT_gpu_shader5
GL_EXT_map_buffer_range
GL_EXT_occlusion_query_boolean
GL_EXT_primitive_bounding_box
GL_EXT_robustness
GL_EXT_separate_shader_objects
GL_EXT_shader_implicit_conversions
GL_EXT_shader_integer_mix
GL_EXT_shader_io_blocks
GL_EXT_shadow_samplers
GL_EXT_sRGB
GL_EXT_sRGB_write_control
GL_EXT_tessellation_point_size
GL_EXT_tessellation_shader
GL_EXT_texture_border_clamp
GL_EXT_texture_buffer
GL_EXT_texture_compression_dxt1
GL_EXT_texture_compression_s3tc
GL_EXT_texture_cube_map_array
GL_EXT_texture_filter_anisotropic
GL_EXT_texture_format_BGRA8888
GL_EXT_texture_rg
GL_EXT_texture_sRGB_decode
GL_EXT_texture_storage
GL_EXT_texture_view
GL_EXT_unpack_subimage
GL_KHR_debug
GL_KHR_texture_compression_astc_ldr
GL_NV_bgr
GL_NV_bindless_texture
GL_NV_blend_equation_advanced
GL_NV_blend_equation_advanced_coherent
GL_NV_copy_buffer
GL_NV_copy_image
GL_NV_draw_buffers
GL_NV_draw_instanced
GL_NV_draw_texture
GL_NV_EGL_stream_consumer_external
GL_NV_explicit_attrib_location
GL_NV_fbo_color_attachments
GL_NV_framebuffer_blit
GL_NV_framebuffer_multisample
GL_NV_generate_mipmap_sRGB
GL_NV_instanced_arrays
GL_NV_occlusion_query_samples
GL_NV_non_square_matrices
GL_NV_pack_subimage
GL_NV_packed_float
GL_NV_packed_float_linear
GL_NV_pixel_buffer_object
GL_NV_read_buffer
GL_NV_read_depth
GL_NV_read_depth_stencil
GL_NV_read_stencil
GL_NV_secure_context
GL_NV_shadow_samplers_array
GL_NV_shadow_samplers_cube
GL_NV_sRGB_formats
GL_NV_texture_array
GL_NV_texture_border_clamp
GL_NV_texture_compression_latc
GL_NV_texture_compression_s3tc
GL_NV_texture_compression_s3tc_update
GL_NV_timer_query
GL_KHR_blend_equation_advanced
GL_KHR_blend_equation_advanced_coherent
GL_OES_compressed_ETC1_RGB8_texture
GL_OES_depth24
GL_OES_depth32
GL_OES_depth_texture
GL_OES_depth_texture_cube_map
GL_OES_EGL_image
GL_OES_EGL_image_external
GL_OES_EGL_sync
GL_OES_element_index_uint
GL_OES_fbo_render_mipmap
GL_OES_get_program_binary
GL_OES_mapbuffer
GL_OES_packed_depth_stencil
GL_OES_rgb8_rgba8
GL_OES_sample_shading
GL_OES_sample_variables
GL_OES_shader_image_atomic
GL_OES_shader_multisample_interpolation
GL_OES_standard_derivatives
GL_OES_surfaceless_context
GL_OES_texture_npot
GL_OES_texture_float
GL_OES_texture_float_linear
GL_OES_texture_half_float
GL_OES_texture_half_float_linear
GL_OES_texture_stencil8
GL_OES_texture_storage_multisample_2d_array
GL_OES_vertex_array_object
GL_OES_vertex_half_float
GL_ANDROID_extension_pack_es31a

OpenGL ES 3.1 に対応しており、OpenGL 4.x 相当の AEP
「 GL_ANDROID_extension_pack_es31a 」が付いています。

Tegra 2   Cortex-A9 x2   ULP GeForce(8)      OpenGL ES 2.0
Tegra 3   Cortex-A9 x4   ULP GeForce(12)     OpenGL ES 2.0
Tegra 4   Cortex-A15 x4  ULP GeForce(72)     OpenGL ES 2.0
Tegra K1  Cortex-A15 x4  GeForce Kepler(192) OpenGL ES 3.1 AEP/OpenGL 4.4

Tegra 2/3 の ULP GeForce は Direct3D 9 世代の GPU から
GLES 2.0 仕様ぎりぎりまで機能を削減したものでした。
Tegra 4 の ULP GeForce は同じ Direct3D 9 世代の GPU core のまま
本来のあるべき機能を復活させたもの。

Tegra K1 は Direct3D 11 世代の GPU core を搭載しています。
Shader Core 数が少ないだけで、対応 API など機能的には desktop GPU との差が
なくなっています。


CPU の VFP Benchmark の結果はこちら。

  SingleT SP max: 17.136 GFLOPS
  SingleT DP max:  3.431 GFLOPS
  MultiT  SP max: 70.174 GFLOPS
  MultiT  DP max: 14.036 GFLOPS

下記ページにも追加しました。

・CPU/GPU OpenGL ES Extension (Mobile GPU)
・VFP Benchmark Log

久しぶりに Intel Mac を使うと、コンパイルがなかなか終わらなくてあれ？と思うことがあります。以前比べたときは、同じ 2020年モデル同士の比較ながらビルド時間で 5倍ほどの差がありました。

M1 Mac が速い理由は色々あると思いますが、そもそもシンプルに CPU が速いです。これまで直接比較できるプラットフォームが無かっただけで、Apple の CPU はシングルスレッド性能が高くパフォーマンスが良好でした。

2018年に A12X を搭載した第３世代 iPad Pro が登場した時点ですでに「ほとんどのノートパソコンよりも優れたパフォーマンス」(ノートパソコンの92パーセントよりも高速)と謳っていることからもわかります。

先日 Apple Watch Series 6 の Apple S6 について性能を測定しました。合わせて手持ちの他のデバイスも一通りチェックしたのでその結果をまとめてみます。ログの全体はこちらにあります。


浮動小数点演算の同時に実行できる命令数 (IPC) に注目したのが下記の表です。単精度と一部の CPU のみ抜き出しています。あくまで浮動小数点演算命令しか見ていないので、必ずしも全体の性能を見ているわけではない点にご注意ください。



Intel CPU は AVX512 で最大 512bit 幅まで選べるものの同時に実行できる命令はいずれも 2命令までとなっています。

AMD Zen2 は add+mul の組み合わせで最大 4ですが、同じ種類の場合 2命令までとなります。Zen1 では 3命令に制限されていたようです。ちなみに Zen2 は通常の CPU (MCM) と APU (Monolithic) を比べましたが同じ結果でした。キャッシュサイズに違いはあるものの、特に浮動小数点演算の実行ユニットが削られているようなことはありませんでした。

Apple は A7 で 64bit 化と同時に 128bit fma x3 に拡張しています。ARM の Cortex は 64bit x2 なので、同じ ARM CPU でも 3倍の演算能力を持っており、スカラーや 64bit でも最大 1.5倍のスループットが期待できます。

さらに A9 で乗算も拡張されており、A12 以降いずれかのタイミングで 4命令に増加したと思われます。Intel が SIMD でピーク性能に特化しているのに対して、Apple は効率がよく小回りがきく印象です。

他の CPU や倍精度含めた表はこちらにあります。

・CPU の浮動小数点演算能力の詳細


ARM core 自体ここ数年で性能がかなり上がっています。以前 Pixel 3 (Snapdragon 845/Cortex-A75) を使い始めたときに、ハイエンドスマートフォンが十分開発に使えるくらい速いことに気が付きました。Core i7 (4 core / 8 thread) の普通の PC とコンパイル時間がほとんど変わらなかったためです。

・ARM CPU 上の開発環境とコンパイル時間の比較 (2) Pixel 3/UserLAnd

下記は Compile Benchmark からの抜粋です。4C8T の PC と Pixel3 のみ載せています。十分速いことがわかります。


もともとコンパイルは並列化が有効で、多コア CPU や I/O 性能の違いで速度が出やすくなります。スマートフォン向け ARM CPU はシングルスレッド性能よりも core 数を増やす方に進化していたので、特に並列コンパイルと相性が良かったのだと思われます。

core 数よりもシングルスレッド性能に力を入れいてた Apple が、同じくらい core 数を揃えたのが前述の Apple A12X です。さらに世代を重ねて、改良と同時に動作 Clock を上げたのが Apple M1 になります。以前のテストでも、コンパイル速度は Apple M1 では 16C/32T に匹敵する結果が出ていました。予想を大きく上回るもので、ARM への移行は早く進むのではないかと思います。

・MacBook Air Late 2020 / Apple M1 のビルド速度と浮動小数点演算能力



関連ページ
・CPU の浮動小数点演算能力の詳細
・Compile Benchmark
・VFP Benchmark Log 計測結果まとめ

関連エントリ
・Apple Watch Series 6 と CPU 性能の測定
・MacBook Air Late 2020 / Apple M1 のビルド速度と浮動小数点演算能力
・Ice Lake の vfpbench 結果と AVX512 命令
・Windows 10 WSL2 のコンパイル速度比較
・4倍速い Ryzen 9 3950X の UE4 コンパイル速度
・Huawei P30 Lite/Fire HD 10(2019) のコンパイル速度と UserLAnd
・Jetson Nano / Clang の Version とコンパイル速度の比較
・Snapdragon 835 と 845 のコンパイル時間の比較＆浮動小数点演算能力
・ARM CPU 上の開発環境とコンパイル時間の比較 (2) Pixel 3/UserLAnd

Ice Lake の PC (mac) を手に入れたので vfpbench を AVX512 対応にしてみました。結果は下記のとおりです。


・Core i5-1030NG7 (MacBook Air)

AVX512 は、512bit 単位の演算が可能となる Intel の新しい SIMD 命令セットです。AVX/AVX2 は 256bit 幅なので 2倍に増えたことになります。単精度の浮動小数点演算なら 512/32bit = 16並列です。4x4 matrix が 1レジスタに収まります。

SSE から AVX に進化したときと同じように、命令のエンコードも一新されており機能も増えています。SSE → AVX では 3オペランドになり 64bit 時に 16個のレジスタが利用できました。AVX → AVX512 ではレジスタフィールドが 5bit となり、レジスタ数が 32個に増えています。さらに 7個の mask レジスタを併用することができます。

mask レジスタは初期の GPU の Shader にあった書き込みマスクと同じものです。出力レジスタのうち必要な要素のみ置き換えることができます。残りの部分は元の値が残りますが、保存せずにゼロクリアを行うこともできます。

mask レジスタが導入されたことで、大きくて一見小回りがきかないようにみえる 512bit のレジスタも、任意のベクタ長とみなして扱うことができます。単精度なら 16個分ですが、mask を併用すれば 1～15 個の単位でも読み書きができるわけです。

SSE/AVX では少々扱いづらかった x,y,z の 3要素ベクタも簡単にロードすることができます。 下記の例ではベクタ (x,y,z) を 4個まとめて読み込んでいます。長さ 12 のベクタとして読み込んだあと、それぞれ (x,y,z) → (x,y,z,0) に展開しています。

movl    $0x0fff, %eax
kmovw   %eax, %k1
movl    $0x7777, %eax
kmovw   %eax, %k2

movups     data(%rbp), %zmm0{%k1}{z}    ; mask 0xfff で読み込み
vexpandps  %zmm0, %zmm1{%k2}{z}         ; mask 0xfff -

AVX2 でも gather を使えば似たようなことができますが、どちらかといえば gather 命令は Shader の InputAssembler に相当します。

もちろん常時マスク付きで演算を行うと無駄が生じていることになります。GPU の SIMT のように、SoA で扱う方が AVX512 の本来の形かもしれません。この場合レジスタはベクタではなく 16個(単精度の場合)のスカラーとなり、mask レジスタは 16個のフラグレジスタとみなせます。


例えば↑こんな感じのコードを 16並列で実行すると↓こうなります。

vmulps        %zmm8, %zmm11, %zmm20
vfmadd231ps   %zmm9, %zmm12, %zmm20
vfmadd231ps   %zmm10, %zmm13, %zmm20
vcmpps        $1, %zmm20, %zmm18, %k1
knotw         %k1, %k2
vfmadd231ps   %zmm20, %zmm19, %zmm21{%k1}
vaddps        %zmm17, %zmm21, %zmm21{%k2}

比較命令の結果であるフラグ値は mask レジスタに入るので、条件成立時と不成立時の演算結果をそのまま合成することができます。


AVX512 の説明が少々長くなりましたが、IceLake の vfpbench の結果を見てみます。ピークの GFLOPS 値は AVX(FMA3) 命令でも AVX512 命令でも変わっていないことがわかります。Ice Lake の場合 zmm (512bit) の AVX512F 命令は同時に 1命令しか実行できないようです。


この結果は Intel のサイトでも確認できます。

・Intel: Intrinsics Guide

上記ページの「__m512 _mm512_fmadd_ps (__m512 a, __m512 b, __m512 c)」を見ると、Icelake の throughput は 1 なので実行に 1 cycle かかることがわかります。対して Skylake (server)/Knights Landing の方は 0.5 なので、2 命令実行できることを意味しています。

また同じ AVX512 の命令でも、mask 付きの ymm(256bit) は AVX/FMA 同様 2命令実行できています。Intrinsics Guide で確認してみると throughput は 0.5 なので合っているようです。

よって IceLake の場合は、性能を上げるために無理に AVX512 命令を使う必要は無さそうです。ただし最初に紹介したように、AVX512 ではレジスタが倍増し便利な機能も命令も増えています。mask が使える便利な AVX2 として見ても十分使い物になるのではないでしょうか。

反面 CPU によって対応機能が細かく別れてしまうので、最適化と互換性の両立はますます難しくなりそうです。


なお vfpbench の log で IPC に大きな数値が出ているのは CPU のベースクロックを元にしているためです。今回使用した Core i5-1030NG7 はベースが 1.1GHz で Single Thread の Boost 時に 3.5GHz になります。そのため 3.5/1.1 の 3.18 がおよそ IPC=1 と思ってください。

より詳細なログは下記からどうぞ

・Hyperでんち: VFP Benchmark Log 計測結果まとめ


関連エントリ
・4倍速い Ryzen 9 3950X の UE4 コンパイル速度
・Snapdragon 845 ARMv8.2A 半精度 fp16 演算命令を使ってみる / Deep Learning 命令
・Snapdragon 835 と 845 のコンパイル時間の比較＆浮動小数点演算能力
・Snapdragon 845 の浮動小数点演算速度
・ARM CPU の浮動小数点演算能力まとめ
・HTC 10 Snapdragon 820 Kyro の浮動小数点演算能力
・iPhone SE, Apple A9 の浮動小数点演算速度
・ARM Cortex-A53 の浮動小数点演算速度とコンパイル時間の比較
・iPod touch 6 の浮動小数点演算速度は Core 2 Duo ライン超え
・iPad Air 2 (Apple A8X) の浮動小数点演算能力
・ARM cpu vfp の種類と fp16 命令を使ってみる
・Intel AVX その3 命令
・Intel AVX その2 転送
・Intel AVX

Snapdragon 835 (MSM8998) のデータを追加しました。コンパイル時間と VFP Benchmark の結果を載せています。ついでに Oculus Go でもコンパイル時間を調べてみました。(前回1) (前回2)

●コンパイル時間の比較 (Termux+clang)


・Time (秒) が小さい方が高速。


●浮動小数点演算能力ピーク値 (VFPBenchmark)


・GFLOPS が大きい方が高速。


演算ユニットの数が同じなので浮動小数点演算ピーク値はクロック数に比例した結果となっています。特に Total 値では 835 と 845 の差が少なくほぼ同じくらいの数値です。

それと比べるとコンパイル時間の方には若干差が付きました。CPU 自体も 2 命令 decode の Out-of-order から 3 命令 decode Out-of-order に増えていますので、Snapdragon 845 は big core のクロック差だけでなく IPC も向上しています。ベースとなった CPU core は ARM によると 20% 以上速いとのこと。UserLAnd + Termux を使っていても VNC 経由なのに十分満足できるもので、過去に使った Nexus 7 (2012) や Nexus 5 の Linux とは別物です。

Oculus Go で動く UserLAnd や Termux はどこでも大画面で作業場が作れるので魅力的なのですが、ビルドは残念ながら低速です。同じ Snapdragon 821 の Zenfone AR と比べても 2.5 倍時間がかかりました。使用したのは Oculus TV + Termux です。VR 空間の描画にパフォーマンスが取られているのだと思われます。VR 描画は両眼分必要で、また処理落ちは酔いにつながるため VR 描画が優先されます。


●スマートフォン以外のデバイスを含めたコンパイル時間の比較

他のデバイスとの比較表も更新しました。835 も十分速いです。ただし条件が一定ではないので参考程度にお願いします。特に Windows 10 PC は仮想環境を使っています。


・Time (秒) が小さい方が高速。


関連ページ
・VFP Benchmark Log 計測結果まとめ

関連エントリ
・Snapdragon 845 の浮動小数点演算速度
・ARM CPU 上の開発環境とコンパイル時間の比較 (2) Pixel 3/UserLAnd
・ARM CPU 上の開発環境とコンパイル時間の比較
・AMD CPU Ryzen とコンパイル時間の比較 (2)
・AMD CPU Ryzen とコンパイル時間の比較
・ARM CPU の浮動小数点演算能力まとめ
・HTC 10 Snapdragon 820 Kyro の浮動小数点演算能力
・iPhone SE, Apple A9 の浮動小数点演算速度
・Raspberry Pi 3 の速度比較, Cortex-A53 の速度
・ARM Cortex-A53 の浮動小数点演算速度とコンパイル時間の比較
・2955U vs N3150/J1900/Athlon5350 (コンパイル時間の比較)
・iPod touch 6 の浮動小数点演算速度は Core 2 Duo ライン超え
・Raspberry Pi 2 で速くなったコンパイル時間の比較
・iPad Air 2 (Apple A8X) の浮動小数点演算能力
・BayTrail vs Kabini (Celeron J1900 vs Athlon 5350)
・コンパイル時間の比較 BayTrail
・Atom vs Core i7

Raspberry Pi 3 を入手したので簡単にベンチマークを取ってみました。

昨年似たスペックの DragonBoard 410c (Snapdragon 410) が発売されています。CPU は Cortex-A53 1.2GHz quad でほぼ同等、どちらもオンボードで Wi-Fi/BT を搭載しています。RAM は Pi 3 の方が若干遅く内蔵ストレージも無いですが、値段は半分以下となっています。少々残念なのは Pi 3 の OS が 32bit なことです。DragonBoard の方は 64bit で動作しています。

いつものコンパイル時間を比較してみました。 (Time が小さい方が高速)


やはり DragonBaord 410c と近い数値になっています。SD Card の差もあるので一概には言えませんが、初代と比べておよそ 10倍、Pi 2 と比べても 2倍以上高速です。

スペック込み＆より多くのデバイスとの比較は下記の通りです。


・C/T = Core数/Thread数


vfp benchmark の比較はこちら (単位は GFLOPS、値が大きい方が速い)


・SP=単精度, DP=倍精度, ST=SingleThread, MT=MultiThread

あくまでピーク値なので実際のソフトウエアでここまで差がでるわけではありませんが、潜在能力としては Pi 2 の 5倍以上の差がついています。(SIMD で 4倍 x clock差) 単精度では 初代 Pi と比べると 55倍も高速です。将来的に 64bit に対応すれば、倍精度演算も DragonBoard と同じくらいの速度に上昇するでしょう。

Cortex-A53 は big.LITTLE の LITTLE として使われていますが、浮動小数点演算に関しては A7 から大幅に拡張されており big core に近い構成になっています。下記スライド写真からも「2 倍精度 MAC / cycle」「4 単精度 MAC / cycle」であることがわかります。

・マイナビニュース ARM TechCon 2012 - 64bitプロセッサ「Cortex-A50」シリーズの概要が公開される/Cortex-A53編

さらに下位の Cortex-A35 が登場予定となっており、こちらが本来の Cortex-A7 相当の 64bit プロセッサになるものと思われます。

下記ページを更新しました。

・VFP Benchmark Log 計測結果まとめ
・CPU の浮動小数点演算能力の詳細


関連エントリ
・ARM Cortex-A53 の浮動小数点演算速度とコンパイル時間の比較
・2955U vs N3150/J1900/Athlon5350 (コンパイル時間の比較)
・Raspberry Pi 2 で速くなったコンパイル時間の比較

Apple Watch Series 2 で vfpbenchmark を走らせてみました。
結果から Apple Watch S1 と同じ Cortex-A7 の 0.5GHz と思われます。


　・単位は GFLOPS, 値が大きい方が高速。

初代 Apple Watch の S1 と違い、新型 Apple Watch の S1P/S2 は Dual Core です。詳細は下記よりどうぞ。結果を追加しています。

・VFP Benchmark Log 計測結果まとめ

GPU については未調査です。SpriteKit 経由ですが、Watch OS 3.0 から OpenGL ES 2.0 相当の Shader (GLSL) が使えるようになっています。


関連エントリ
・Android 端末のアップデート (1) Android Wear バージョン一覧と新しいアーキテクチャ
・Apple Watch の CPU の種類と浮動小数点演算速度

Snapdragon 845 の Kryo 385 (Cortex-A75) は ARMv8.2 の拡張命令である半精度浮動小数点演算に対応しています。半精度浮動小数点数は HDR テクスチャなど GPU ではおなじみで、符号 1bit 指数部 5bit 仮数部 10bit の合計 16bit で表現されます。

CPU でもこれまで単精度と半精度 (fp32 と fp16) の相互変換が可能でした。X86/X64 では F16C 命令 (vcvtph2ps/vcvtps2ph) がありますし、ARM では以前試したように Cortex-A9 以降で変換命令が追加されています。変換だけなのでメモリアクセスは速くなるものの演算速度は特に変わりません。

ARMv8.2 ではオプションの拡張命令 FPHP, SIMDHP が新設され、対応していれば 16bit 半精度のまま演算ができるようになりました。128bit の SIMD(NEON) なら同時に 8個の積和演算を行うので、ピークの演算速度は単精度の倍になる計算です。

fmla  v0.2d, v1.2d, v2.2d   ; 倍精度 64bit x2
fmla  v0.4s, v1.4s, v2.4s   ; 単精度 32bit x4
fmla  v0.8h, v1.8h, v2.8h   ; 半精度 16bit x8

新しい vfpbench で対応したので実際に計測してみたのがこちらです。8 core で 8 thread 並列時の値です。

・GFLOPS の値が大きい方が高速

予想通りほぼ fp32 の倍の値になっています。なお big/little core を個別計測した結果の合計なので、全 core 同時に走らせた場合はもう少し数値は下がるものと思われます。big, little それぞれの値を表にすると下記の通り。

Cortex-A75 の FP/SIMD pipe は 2本ありますが、命令単位で調べると 64bit (4h) 時は IPC=2、128bit (8h) 時は IPC=1 なのでそれぞれの pipe は 64bit であることがわかります。

Deep Learning 用の命令としては他にも 8bit 積和演算である Dot Product (dotprod) 拡張命令があります。これも ARMv8.2A のオプションで、下記ような整数 Int8 の 4乗算と 4加算を 4並列で行うことができます。AVX512VNNI や GeForce RTX (Turing) などの Int8 命令によく似ています。

udot  v0.4s, v1.16b, v2.16b
sdot  v0.4s, v1.16b, v2.16b

32bit += 8bit * 8bit + 8bit * 8bit + 8bit * 8bit + 8bit * 8bit
32bit += 8bit * 8bit + 8bit * 8bit + 8bit * 8bit + 8bit * 8bit
32bit += 8bit * 8bit + 8bit * 8bit + 8bit * 8bit + 8bit * 8bit
32bit += 8bit * 8bit + 8bit * 8bit + 8bit * 8bit + 8bit * 8bit

fp16 の倍なので計算上は 500 GOPS を超えるのですが、残念ながら Snapdragon 845 の Kryo 385 では対応していませんでした。

詳細なログはこちら
・Pixel 3 Snapdragon 845 Kryo 385 2.8GHz x4 + 1.77GHz x4 ARM64 (AArch64) Android 9.0

vfpbench のログ(一部)

ARCH: ARMv8.2A
FPU : ASIMD(AArch64 NEON) FPHP ASIMDHP
Name: Qualcomm Technologies, Inc SDM845

CPU Thread:  8
CPU Core  :  8
CPU Group :  2
  Group 0: Thread= 4  Clock=1.766400 GHz  (mask:f)
  Group 1: Thread= 4  Clock=2.803200 GHz  (mask:f0)
NEON  : yes
FMA   : yes
FPHP  : yes
SIMDHP: yes

Total:
SingleThread HP max:   71.675 GFLOPS
SingleThread SP max:   35.892 GFLOPS
SingleThread DP max:   17.940 GFLOPS
MultiThread  HP max:  277.711 GFLOPS
MultiThread  SP max:  138.445 GFLOPS
MultiThread  DP max:   68.745 GFLOPS

Group 0:  Thread=4  Clock=1.766400 GHz  (mask:f)
  SingleThread HP max:   27.426 GFLOPS
  SingleThread SP max:   13.683 GFLOPS
  SingleThread DP max:    6.851 GFLOPS
  MultiThread  HP max:  108.928 GFLOPS
  MultiThread  SP max:   54.046 GFLOPS
  MultiThread  DP max:   27.273 GFLOPS

Group 1:  Thread=4  Clock=2.803200 GHz  (mask:f0)
  SingleThread HP max:   44.248 GFLOPS
  SingleThread SP max:   22.209 GFLOPS
  SingleThread DP max:   11.090 GFLOPS
  MultiThread  HP max:  168.783 GFLOPS
  MultiThread  SP max:   84.400 GFLOPS
  MultiThread  DP max:   41.472 GFLOPS

関連ページ
・VFP Benchmark Log 計測結果まとめ

関連エントリ
・Snapdragon 835 と 845 のコンパイル時間の比較＆浮動小数点演算能力
・Snapdragon 845 の浮動小数点演算速度
・ARM CPU の浮動小数点演算能力まとめ
・HTC 10 Snapdragon 820 Kyro の浮動小数点演算能力
・iPhone SE, Apple A9 の浮動小数点演算速度
・ARM Cortex-A53 の浮動小数点演算速度とコンパイル時間の比較
・iPod touch 6 の浮動小数点演算速度は Core 2 Duo ライン超え
・iPad Air 2 (Apple A8X) の浮動小数点演算能力
・ARM cpu vfp の種類と fp16 命令を使ってみる

iPhone SE で vfpbench を走らせてみました。
単位は GFLOPS で数値が大きい方が高速です。SP-MT で速い順に並べています。


・SP=単精度, DP=倍精度, ST=SingleThread, MT=MultiThread

Apple A9 は Core 単体の演算能力が非常に上がっていることがわかります。Core 単体の演算速度 SP-ST ですでに 41.9 GFLOPS に達し、Multi-Thread 時の SP-MT では 2 core の A9 が 3 core の A8X を上回っています。クロック差を考えると iPad Pro の A9X はおそらく 100 GFLOPS を超えるでしょう。

他の CPU との比較は下記の通り。Ivy Bridge i5 は Mac Book Pro Late2013 (Core i5-3210M) の結果です。


clock から逆算すると A9 の CPU Twister は単精度の NEON 命令を 3 つ同時に実行しており、積和 x NEON 4 x 3 pipe で clock あたり 24 flop 相当となります。Ivy Bridge が 16 flop, Haswell が 32 flop なのでその中間です。ただし Haswell は 8 並列の AVX x 2 pipe なので、並列度で言えば Twister の方が上回っていることになります。単精度のスカラー命令や SSE との比較なら Twister の方が高速に実行できるかもしれません。

なお倍精度では乗算と積和が 2 並列となっており、A8 Typhoon 世代と同等になっているようです。

CPU 毎の並列度の詳細は下記の参照してください

・CPU の浮動小数点演算能力の詳細

計測結果は下記に追加しています。

・VFP Benchmark Log 計測結果まとめ


関連エントリ
・Raspberry Pi 3 の速度比較, Cortex-A53 の速度
・ARM Cortex-A53 の浮動小数点演算速度とコンパイル時間の比較
・2955U vs N3150/J1900/Athlon5350 (コンパイル時間の比較)
・Apple TV の浮動小数点演算速度。Fire TV/Android TV との比較など
・iPod touch 6 の浮動小数点演算速度は Core 2 Duo ライン超え
・iPad Air 2 (Apple A8X) の浮動小数点演算能力

Ryzen 9 3950X は 16 core 32 thread の CPU です。少し前まで 4 core 8 thread の CPU をメインに使っていたことを考えると、これ 1つで従来の PC の 4台分に相当します。

実際に速度を調べてみました。UE4 のコンパイル速度の比較は下記の通り。本当に 4台分、コンパイル時間が 1/4になっています。

● UE4 4.24.0 (GitHub版) の Engine コンパイル時間


・Build 時間の単位は秒、値が小さい方が高速

Skylake Core i7-6700K で 1時間かかるビルドが Ryzen 9 3950X だと 16分で終わっています。4倍高速です。1800X と比べても 2.5倍速くなっています。これくらい速ければ分散ビルドなしで十分使えそうです。

ちなみに条件を統一するため 3台とも SATA 接続の SSD の上でビルドしています。NVMe ならもっと時間を短縮できると思われます。


・(A) は Total のビルド時間で UnrealHeaderTool と ShaderCompileWorker が含まれています。また UHT のヘッダ生成は並列化されないためシングルスレッドの時間が含まれます。

・(B) は Engine の ParallelExecutor だけの時間で、最後の Link 以外は並列化されています。シングルスレッドの時間が短いため (A) よりも Thread 数の差が出やすくなります。

・一旦 clean してから Engine\Build\BatchFiles\Build.bat を使い DevelopmentEditor Win64 でビルドしています。




↑16 core でも小さい Socket AM4。箱の中身は殆どが黒いスポンジ。


● ARM デバイスの比較に使っているコンパイルベンチの速度


・Build 時間の単位は秒、値が小さい方が高速

これも UE4 とほぼ同じで 4倍速くなっています。詳しくはこちら


● vfpbench の結果


・GFLOPS の値が大きい方が高速。単精度のみ。

1.9 TFLOPS (1898 GFLOPS) という見たことがない数値が出ました。あくまでメモリアクセスを無視した理想的な条件での値です。だいたい PS4 の GPU に相当します。実際のアプリケーションでこの速度が出るわけではないので参考程度にお願いします。

下記は計測結果のログです。Single Thread 単精度のみ。倍精度はまだ調査中です。

Group 0:  Thread=32  Clock=3.493000 GHz  (mask:ffffffff)
  SingleThread HP max: -
  SingleThread SP max:  122.851 GFLOPS
  SingleThread DP max:   52.722 GFLOPS
  MultiThread  HP max: -
  MultiThread  SP max: 1894.097 GFLOPS
  MultiThread  DP max:  954.959 GFLOPS

* Group 0:  Thread=1  Clock=3.493000 GHz
                                  TIME(s)   MFLOPS      MOPS    FOP IPC
SSE mulss (32bit x1) n8       :    0.244     8605.0     8605.0 (  1 2.5)
SSE addss (32bit x1) n8       :    0.244     8591.2     8591.2 (  1 2.5)
FMA vfmaddss (32bit x1) n8    :    0.317    13239.6     6619.8 (  2 1.9)
FMA vfmaddss (32bit x1) n12   :    0.365    17246.0     8623.0 (  2 2.5)
SSE mulps (32bit x4) n8       :    0.245    34194.1     8548.5 (  4 2.4)
SSE addps (32bit x4) n8       :    0.243    34520.1     8630.0 (  4 2.5)
SSE mul+addps (32bit x4) n8   :    0.183    45837.4    11459.3 (  4 3.3)
FMA vfmaddps (32bit x4) n8    :    0.303    55334.8     6916.9 (  8 2.0)
FMA vfmaddps (32bit x4) n12   :    0.364    69104.3     8638.0 (  8 2.5)
SSE ml+ad+adps (32bit x4) n9  :    0.218    43313.8    10828.4 (  4 3.1)
SSE mulss (32bit x1) ns4      :    0.368     5699.9     5699.9 (  1 1.6)
SSE addss (32bit x1) ns4      :    0.368     5698.4     5698.4 (  1 1.6)
SSE mulps (32bit x4) ns4      :    0.367    22812.0     5703.0 (  4 1.6)
SSE addps (32bit x4) ns4      :    0.366    22916.4     5729.1 (  4 1.6)
AVX vmulps (32bit x8) n8      :    0.258    65052.1     8131.5 (  8 2.3)
AVX vaddps (32bit x8) n8      :    0.260    64581.5     8072.7 (  8 2.3)
AVX vmul+addps (32bit x8) n8  :    0.157   106474.3    13309.3 (  8 3.8)
FMA vfmaddps (32bit x8) n8    :    0.318   105391.7     6587.0 ( 16 1.9)
FMA vfmaddps (32bit x8) n12   :    0.408   123302.0     7706.4 ( 16 2.2)
FMA vfma+mlps (32bit x8) n12  :    0.408    92570.0     7714.2 ( 12 2.2)
FMA vfma+adps (32bit x8) n12  :    0.345   109457.1     9121.4 ( 12 2.6)
AVX vml+ad+adps (32bit x8) n9 :    0.345    54644.5     6830.6 (  8 2.0)
FMA vfma+ml+adps (32bit x8) n9:    0.307    81930.4     8193.0 ( 10 2.3)

関連ページ
・Compile Benchmark
・VFP Benchmark Log 計測結果まとめ

関連エントリ
・UE4 UnrealBuildTool の設定 BuildConfiguration.xml
・UE4 UnrealBuildTool VisualStudio の選択を行う
・UE4 UnrealBuildTool *.Build.cs のコードを共有する
・AMD CPU Ryzen とコンパイル時間の比較 (2)
・AMD CPU Ryzen とコンパイル時間の比較

暫定のまとめ。上の表は単精度のみです。vfpbench の結果から推定した値になります。
倍精度 (ARMv8A のみ) は下記のとおりです。



関連ページ
・CPU の浮動小数点演算能力の詳細
・64bit ARMv8A CPU Core
・VFP Benchmark Log 計測結果まとめ

Qualcomm の DragonBoard 410c を入手したので vfpbench を走らせてみました。


・ 単位は GFLOPS, 値が大きい方が高速
・ SP=single fp, DP=double fp, ST=single thread, MT=multi thread

Cortex-A53 は big.LITTE の LITTLE に使われる core で Cortex-A7 同様 in-order の pipeline を持っています。ところが浮動小数点演算のピーク速度は予想以上に高い結果となっています。

上の結果が本当なら Cortex-A7 比で VFP で 2倍、NEON single だと最大 4倍速いことになります。また同一クロックかつピークのみに限定すれば big core にも並びます。ただし in-order かつ動作クロックも低いため、実際のコードでは big core とはかなり差が生じると思われます。倍精度演算の並列性も劣っているようです。



Linux 上でコンパイル速度も測定してみました。RAM が少ないとはいえ十分速度が出ています。クロック差を考えても Desktop CPU との違いが少なくなってきてることがよくわかります。


* sec = コンパイル時間(秒)、値が小さい方が速い
* Dragonboard 401c = Debian 8.0

RAM が少ないデバイスはストレージ速度の影響が大きい点に注意してください。特に Raspberry Pi 系は SD カードに依存するため参考程度にお願いします。

下記のページを更新しました

・VFP Benchmark Log 計測結果まとめ
・CPU の浮動小数点演算能力の詳細


関連エントリ
・2955U vs N3150/J1900/Athlon5350 (コンパイル時間の比較)
・Apple TV の浮動小数点演算速度。Fire TV/Android TV との比較など
・ARM Cortex-A72 の浮動小数点演算速度 (Amazon Fire TV)
・Raspberry Pi 2 で速くなったコンパイル時間の比較
・BayTrail vs Kabini (Celeron J1900 vs Athlon 5350)
・コンパイル時間の比較 BayTrail

CPU ベンチに Snapdragon 800 MSM8974 Krait 400 の結果を追加しました。

・ARM CPU core 毎の浮動小数点演算速度の比較 (VFP/NEON)
・CPU benchmark

浮動小数点演算命令毎の実行速度

                (1)      (2)      (3)      (4)       (5)      (6)      (7)
               Nexus7   iPad4    HTL21   Nexus10  iPhone5s iPhone5s KindleHDX7
              Cortex-A9 Swift    Krait  Cortex-A15 Cyclone  Cyclone   Krait4
               Tegra3    A6X    APQ8064  Exynos5D   A7 32    A7 64   MSM8974
               1.2GHz   1.4GHz   1.5GHz   1.7GHz    1.3GHz   1.3GHz   2.2GHz
------------------------------------------------------------------------------
a:m44 vmla_AQ  3.959    1.204    1.337    0.619     0.700    -----    0.661
b:m44 vmla_BQ  2.002    1.266    0.931    0.569     0.670    -----    0.542
c:m44 vmla_AD  3.980    1.554    1.889    0.557     0.649    -----    0.888
d:m44 vmla_BD  2.003    1.238    1.532    0.568     0.745    -----    0.768
A:m44 vfma_AQ  -----    1.519    1.882    0.746     0.707    0.692    1.178
B:m44 vfma_BQ  -----    1.484    0.695    0.840     0.699    0.696    0.463
e:fadds     A  3.343    2.878    2.774    2.383     3.551    1.043    1.864
f:fmuls     A  3.337    2.953    2.747    2.369     3.475    1.548    1.867
g:fmacs     A  3.337    5.757    5.574    2.956     3.480    -----    2.052
h:vfma.f32  A  -----    5.756    2.747    2.957     3.480    3.185    1.864
i:vadd.f32 DA  3.426    2.877    2.762    1.183     1.031    1.031    1.866
j:vmul.f32 DA  3.421    2.950    2.746    1.478     1.545    1.545    1.864
k:vmla.f32 DA  3.792    2.951    5.604    1.480     1.567    -----    2.051
o:vfma.f32 DA  -----    2.494    2.833    1.479     1.574    1.753    1.871
l:vadd.f32 QA  6.688    2.878    2.801    2.365     1.031    1.039    1.872
m:vmul.f32 QA  6.681    2.952    2.761    2.364     1.548    1.548    1.879
n:vmla.f32 QA  6.681    2.950    5.606    2.367     1.574    -----    2.059
N:vfma.f32 QA  -----    -----    -----    -----     -----    1.696    -----
p:fadds     B  3.347    5.756    3.467    2.956     6.953    3.663    -----
q:fmuls     B  4.195    5.756    3.556    3.558     6.652    3.296    -----
r:fmacs     B  6.688   11.514    6.298    5.912     9.867    -----    -----
s:vfma.f32  B  -----   11.513    3.430    5.910     9.859    3.292    -----
t:vadd.f32 DB  3.421    2.881    3.529    2.958     3.663    3.643    1.865
u:vmul.f32 DB  3.422    2.949    3.447    2.364     3.114    3.289    2.339
v:vmla.f32 DB  7.561    5.755    6.293    4.728     6.185    -----    3.773
z:vfma.f32 DB  -----    5.755    3.437    4.730     6.188    6.237    2.340
w:vadd.f32 QB  6.705    2.879    3.457    2.961     3.659    3.641    1.875
x:vmul.f32 QB  6.683    2.950    3.428    2.363     3.101    3.276    2.340
y:vmla.f32 QB  7.532    5.759    6.372    4.729     6.199    -----    3.746
Y:vfma.f32 QB  -----    -----    -----    -----     -----    6.226    -----

・↑数値は実行時間(秒) 数値が小さい方が高速。single thread
・すべて単精度 32bit float の演算です。

Krait 400 は動作 clock が高いこともあり非常に高速です。
上の結果では同じ ARMv7A VFPv4 世代の Cortex-A15 に匹敵し、
実行効率の差を動作クロックが十分補っていることがわかります。

またここでの Quad core は Cortex-A9, Krait, Krait 400 だけなので、
総合的なパフォーマンスでは高クロックかつ Quad core の Krait 400 が
最も高いスコアになることが予想できます。

NEON 命令は 64bit と 128bit の差がなく、Cortex-A15 と違い 128bit
単位となっています。

vfma (FMA) よりも vmla が 2倍遅かった Krait 無印 (3) と比べて、
Krait 400 (7) では vmla も vfma に近い速度が出ています。
同じ Krait でも傾向が異なっており、様々な改良が施されているようです。

同時にあらためて A7 Cyclone の単 core 性能が非常に高いこともわかります。
A7 Cyclone の結果は 2個ありますが、
(5) は ARMv8 AArch32 (armv7) 32bit モードの結果で
(6) は ARMv8 AArch64 (arm64) 64bit モードでの結果です。

以下テスト端末の詳細

device                     OS   SoC      CPU core     clock  Arch        VFP
----------------------------------------------------------------------------
(1)ASUS Nexus 7 (2012)     A4.2 Tegra 3  Cortex-A9 x4 1.2GHz ARMv7A 32bit v3
(2)Apple iPad 4            i6.1 A6X      Swift     x2 1.4GHz ARMv7A 32bit v4
(3)HTC J butterfly HTL21   A4.1 APQ8064  Krait     x4 1.5GHz ARMv7A 32bit v4
(4)Samsung Nexus 10        A4.2 Exynos5D Cortex-A15x2 1.7GHz ARMv7A 32bit v4
(5)Apple iPhone 5s         i7.0 A7       Cyclone   x2 1.3GHz ARMv8A 32bit v4
(6)Apple iPhone 5s         i7.0 A7       Cyclone   x2 1.3GHz ARMv8A 64bit Ad
(7)Amazon Kindle Fire HDX7 A4.2 MSM8974  Krait 400 x4 2.2GHz ARMv7A 32bit v4

下記はもうひとつのCPUベンチの結果です。

  SoC CPU              clock  compiler  arch   time  MB/s   MBS/GHz
-------------------------------------------------------------------
1.A7 Cyclone + AES     1.3GHz clang 5.0 arm64  0.129 837.54  644.26
2.A7 Cyclone           1.3GHz clang 5.0 arm64  1.04  104.27   80.21
3.A7 Cyclone           1.3GHz clang 5.0 armv7  1.16   93.04   71.57
4.MSM8974 Krait 400    2.2GHz gcc 4.8   armv7  1.41   76.67   34.85
5.Exynos 5D Cortex-A15 1.7GHz gcc 4.6   armv7  1.49   72.61   42.71
6.A6X Swift            1.4GHz clang 4.2 armv7  1.75   61.82   44.16
7.APQ8064 Krait        1.5GHz gcc 4.6   armv7  2.28   47.64   31.82
8.Tegra3 Cortex-A9     1.3GHz gcc 4.4.3 armv7  3.00   36.15   25.82

・time の単位は秒
・MB/s が大きいほうが高速
・MBS/GHz = 1GHz あたりの処理速度

専用命令を使っている 1. が一桁高速なのは当然ですが、64bit アーキテクチャ
の A7 も十分高速です。
新 core + クロック数が最も高い Krait 400 はそれらに次ぐ速度となりました。
テスト内容の詳細はこちらから。

テストに使った Kindle Fire HDX 7 のデータは下記にも追加しました。

・CPU/GPU OpenGL ES Extension (Mobile GPU)


関連エントリ
・iPhone 5s A7 CPU の浮動小数点演算速度 (2) (arm64/AArch64/64bit)
・iPhone 5s A7 CPU の浮動小数点演算速度 (32bit)
・Nexus 10 CPU Cortex-A15 の速度
・Qualcomm APQ8064 GPU Adreno 320 の速度
・Qualcomm APQ8064 Krait/A6 swift の浮動小数点演算能力

新しい Apple TV は Apple A8 搭載で Android TV や Fire TV 同様アプリケーション走らせることができるようになっています。vfpbench を試してみました。clock 数から計算すると Apple TV の CPU は 1.4GHz だと思われます。

ARCH: ARMv8A
FPU: AArch64 NEON
SingleT SP max: 22.197 GFLOPS
SingleT DP max: 11.105 GFLOPS
MultiT  SP max: 44.331 GFLOPS
MultiT  DP max: 22.084 GFLOPS
CPU core: 2

詳細は下記に追加しています。

・VFP Benchmark Log

同等の TV 用プレイヤーデバイスとの比較。

(SP/DP/SP-MT/DP-MT の単位は GFLOPS, 数値が大きい方が高速)

GPU は下記の通り


SoC/CPU core が異なるもののなぜか GPU はみな PowerVR です。動作クロックは不明ですが型番上は Apple TV の GPU が一番性能が高いことになります。

なお Android TV は Nexus Player 以外にも存在しているため性能にはばらつきがあります。例えば NVIDIA SHILED も Android TV です。

下記ページも更新しました。

・Video Game Console スペック一覧

いずれも GameController に対応しており Game Console のような使い方も可能となっています。

Nexus Player, Fire TV は純正の Wireless Game Contoller が用意されていますし、Android に対応した Game Pad を USB 接続することも可能です。特に Fire TV はフルサイズの USB コネクタなので変換アダプタも不要。Apple TV は iOS 仕様の Bluetooth ゲームパッドを使うことができます。





↑左上から AppleTV, Fire TV, Nexus Player

Apple TV は厚みがある代わりに AC アダプタが不要です。



↑付属リモコン 左から Nexus Player, Fire TV, Apple TV

充電式で乾電池が不要な分だけ Apple TV のリモコンは薄型です。Nexus Player, Fire TV はどちらもリング状の方向キーでセンターが決定、左下に Back キー。Apple TV はカーソルの代わりにタッチパッドがついており押し込みで決定。MENU がバックキー相当です。


関連エントリ
・ARM Cortex-A72 の浮動小数点演算速度 (Amazon Fire TV)
・Amazon Fire TV と OpenGL ES 3.1, TV Stick の OS
・Nexus Player を GamePad＆Mouse で使う、他
・Android 5.0 Nexus Player x86 と対応 ABI

iPhone 5s に遅れることおよそ 1年、
64bit 対応の Android と ARM64 端末がリリースされました。
Nexus 9 の CPU core は NVIDIA の Denver。

Processor	: NVIDIA Denver 1.0 rev 0 (aarch64)
processor	: 0
processor	: 1
Features	: fp asimd aes pmull sha1 sha2 crc32 
CPU implementer	: 0x4e
CPU architecture: AArch64
CPU variant	: 0x0
CPU part	: 0x000
CPU revision	: 0

Hardware	: Flounder
Revision	: 0000
Serial		: 0000000000000000

少々わかりにくいですが "processor" の行が 2つあるので dual core です。

$ cat /sys/devices/system/cpu/online
0-1

vfpbenchmark は下記のとおり。
single core 時の浮動小数点演算能力はほぼ SHILED Tablet (Cortex-A15 2.2GHz)
と同等で、トータル性能では Core 数の分だけ落ちています。
あくまで 32bit の結果なので後ほど 64bit (AArch64) でも試してみたいと思います。

// Nexus 9
ARCH: ARMv7A
CPU core: 2
VFP: VFPv4-D32 NEON
FMA: Yes
NEON: Yes
  SingleT SP max: 17.799 GFLOPS
  SingleT DP max:  4.423 GFLOPS
  MultiT  SP max: 34.582 GFLOPS
  MultiT  DP max:  8.719 GFLOPS

ro.product.cpu.abi=arm64-v8a
ro.product.cpu.abilist=arm64-v8a,armeabi-v7a,armeabi
ro.product.cpu.abilist32=armeabi-v7a,armeabi
ro.product.cpu.abilist64=arm64-v8a

arm64-v8a, armeabi-v7a, armeabi 3つの ABI に対応していました。
Android が現在 NDK でサポートしている ABI は下記の 7種類です。

armeabi       ARMv5TE
armeabi-v7a   ARMv7A VFPv3-D16 softfp (VFPv3-D32, NEON, hard-float)
arm64-v8a     ARMv8A (AArch64)
x86           x86 (IA-32)
x86_64        x64
mips          MIPS32-R1
miips64       MIPS64

ちなみに iOS で開発用の lib を作ると 5種類。

armv7         ARMv7A VFPv3-D32+NEON softfp
armv7s        ARMv7A VFPv4-D32+NEON softfp
arm64         ARMv8A (AArch64)
i386          x86    simulator
x86_64        x86_64 simulator

GPU は OpenGL ES 3.1 の Context を返します。

GL_VERSION: OpenGL ES 3.1 NVIDIA 343.00
GL_RENDERER: NVIDIA Tegra
GL_VENDOR: NVIDIA Corporation
GL_SHADING_LANGUAGE_VERSION: OpenGL ES GLSL ES 3.10

対応しているテクスチャフォーマットは DXT, ETC1, ETC2/EAC, ASTC 。
詳細は下記ページに掲載しています。

・CPU/GPU OpenGL ES Extension (Mobile GPU)

今までテストに使用してきたプログラムが安定して動作しないため
Adreno 320 では速度の計測ができていませんでした。
LG Optimus G LGL21 を借りることができたのでもう一度テストしてみました。

・Mobile GPU ベンチ OpenGL ES 2.0
・CPU benchmark
・OpenGL ES Extension (Mobile GPU)

GPU bench の (1) 以外は 60fps に達するため数値が出ていません。
GPU 性能が上がったため、もはやこのテストは計測に向いていないことになります。

また Adreno 320 は OpenGL ES 3.0 世代の GPU ですが、
現在の OS から使う限り API は OpenGL ES 2.0 になります。
GPU 性能をまだ引き出せていない可能性があります。

テストプログラムのエラーの原因は特定のケースでシェーダーのコンパイルが
エラーになるもので、回避方法はわかったもののまだ詳しい条件が
特定できていません。

VFP test では HTC J HTL21 よりも良い結果が出ています。

                 (1)     (2)     (3)      (4)    (5)     (6)
                 iPad3  Touch5   EVO 3D  iPad4 Butterfly OptimusG
                 A5X     A5      8660     A6X    8064    8064
                 C-A9    C-A9   Scorpion Swift   Krait   Krait
----------------------------------------------------------------
a:mat44 neon_AQ  4.784   5.979   2.879   1.204   1.919   1.354
b:mat44 neon_BQ  2.408   3.008   1.146   1.266   1.273   0.930
c:mat44 neon_AD  4.781   5.974   3.079   1.554   2.453   1.862
d:mat44 neon_BD  2.406   3.007   1.440   1.344   2.041   1.521
e:fadds      A   4.010   5.013   3.460   2.882   3.791   2.831
f:fmuls      A   4.010   5.012   4.361   2.953   3.671   2.793
g:fmacs      A   4.012   5.011   4.034   5.763   7.334   5.599
h:vfma.f32   A   -----   -----   -----   5.765   3.725   2.743
i:vadd.f32 D A   4.111   5.136   3.493   2.877   3.706   2.724
j:vmul.f32 D A   4.110   5.136   3.502   2.950   3.667   2.767
k:vmla.f32 D A   4.512   5.650   3.638   2.951   7.557   5.462
l:vadd.f32 Q A   8.023  10.036   3.408   2.878   3.677   2.717
m:vmul.f32 Q A   8.022  10.028   3.427   2.952   3.647   2.741
n:vmla.f32 Q A   8.025  10.028   3.400   2.955   7.362   5.446
o:vfma.f32 D A   -----   -----   -----   2.494   3.676   2.709
p:fadds      B   4.014   5.013   5.972   5.757   4.664   3.388
q:fmuls      B   5.013   6.265   5.960   5.760   4.583   3.384
r:fmacs      B   8.023  10.024   8.573  11.521   8.266   6.246
s:vfma.f32   B   -----   -----   -----  11.519   4.611   3.622
t:vadd.f32 D B   4.113   5.137   5.945   2.881   4.746   3.406
u:vmul.f32 D B   4.118   5.145   5.098   2.951   4.680   3.454
v:vmla.f32 D B   9.027  11.278   8.498   5.757   8.361   6.140
w:vadd.f32 Q B   8.021  10.023   5.950   2.879   4.702   3.481
x:vmul.f32 Q B   8.029  10.023   5.095   2.951   4.595   3.412
y:vmla.f32 Q B   9.026  11.277   8.497   5.762   8.464   6.249
z:vfma.f32 D B   -----   -----   -----   5.759   4.660   3.413
---------------------------------------------------------------
↑数値は実行時間(秒) 数値が小さい方が速い

(1)=Apple iPad 3           A5X      ARM Cortex-A9 x2  1.0GHz
(2)=Apple iPod touch 5     A5       ARM Cortex-A9 x2  0.8GHz
(3)=HTC EVO 3D ISW12HT     MSM8660  Scorpion      x2  1.2GHz
(4)=Apple iPad 4           A6X      A6 (swift)    x2    ?GHz
(5)=HTC J butterfly HTL21  APQ8064  Krait         x4  1.5GHz
(6)=LG Optimus G LGL21     APQ8064  Krait         x4  1.5GHz

Krait の FP 性能は Swift に並ぶ新 core であることがよくわかります。

前回のテスト時はクロックが上限まで上がっていなかった可能性があります。
HTC J butterfly が修理から戻ってきたらもう一度計測してみたいと思っています。


関連エントリ
・Adreno 320 Snapdragon S4 Pro APQ8064

低消費電力の Desktop PC 向け CPU として Intel からは BeyTrail-D、
AMD からは Kabini が登場しています。
BayTrail-D Celeron J1900 と Kabini Athlon 5350 は、
どちらも 4 core CPU + マザーボードでちょうど 1万円。
価格帯もスペックも良く似ているので比べてみました。

                    BayTrail-D              Kabini
                    Celeron J1900         Athlon 5350
-----------------------------------------------------
CPU core             Silvermont             Jaguar
CPU cores                4                    4
CPU clock            2.0-2.41GHz           2.05GHz
RAM                DDR3-1333 dual         DDR3-1600
MEM BW                21.3GB/s             12.8GB/s
L2                      2MB                  2MB
SSE                    SSE4.2               SSE4.2
AVX                      --                  AVX
AES                      --                 AES-NI
CPU SP              24 fop/clock         32 fop/clock
CPU SP FLOPS        57.81 GFLOPS          65.6 GFLOPS
CPU DP               6 fop/clock         12 fop/clock
CPU DP FLOPS        14.46 GFLOPS          24.6 GFLOPS
GPU core         Intel HD Graphics 3G    RADEON R3 (GCN)
GPU clock            688-854MHz             600MHz
GPU SP              64 fop/clock         256 fop/clock
GPU SP FLOPS         54.7 GFLOPS         153.6 GFLOPS
OpenGL Windows       OpenGL 4.0           OpenGL 4.3
OpenGL Linux         OpenGL 3.3           OpenGL 4.3
TDP                     10W                  25W

・Intel Celeron Processor J1900
・AMD Athlon

浮動小数点演算能力

VFP Benchmark     Celeron J1900    Athlon 5350
-------------------------------------------------
SingleT SP max:   14.477 GFLOPS    15.943 GFLOPS
SingleT DP max:    3.619 GFLOPS     6.127 GFLOPS
MultiT  SP max:   57.902 GFLOPS    63.737 GFLOPS
MultiT  DP max:   14.471 GFLOPS    24.504 GFLOPS

・値が大きいほうが高速

前前回の予想通り浮動小数点演算能力は Jaguar (Kabini/Athlon) の方が高くなっています。
J1900 (BayTrail) は動作クロックの高さで補っている形です。

演算能力/clock    Single FP   Double FP
-----------------------------------------------
Celeron J1900         6          1.5
Athlon 5350           8            3

再測定して気が付きましたが、以前のエントリで J1900 の倍精度演算の
性能評価が間違っていました。下記訂正しましたので申し訳ありませんでした。
「Atom Bay Trail の浮動小数点演算能力」


前回のコンパイル速度比較を Kabini でも試してみました。
驚くほど拮抗しています。

flatlib3 Linux       clock  core  RAM   OS   arch compiler    time sec
-------------------------------------------------------------------------
Kabini Athlon 5350  2.05GHz  x4   8GB  14.04  x64  clang-3.5    54.8
BayTrail-D J1900    2.41GHz  x4   8GB  14.04  x64  clang-3.5    54.6

・time が小さい方が速い

テストした環境は下記の通り。

Test 環境
Celeron J1900 (Q1900B-ITX DDR3-1333 dual   8GB  21.3GB/s)
Athlon 5350   (AM1l       DDR3-1333 single 8GB  10.7GB/s)

Kabini は DDR3-1600 が使えますが、テスト環境では手持ちの DDR3-1333 を使用しています。
本来の能力よりもスコアが低くなっていると考えられますので予めご了承ください。


AES 変換テスト

AES CTR 599MByte  Celeron J1900    Athlon 5350
-------------------------------------------------
Table1               18.708          18.964
Table2               15.409          14.600
Table3               14.902          12.374
AES-NI                   --           4.238

・単位は秒、値が小さい方が速い, Single Thread

AES-NI が使えるため Jaguar (Athlon/Kabini) の方が高速です。
同じアルゴリズム同士でもわずかに Jaguar の方が速いようです。
メモリ速度、CPU の動作クロックともに J1900 (BayTrail) の方が上なので、
Jaguar (Athlon/Kabini) は Core 性能そのものが高いのだと思われます。


簡単なシーンのレンダリング速度の比較

Ubuntu 14.04   GPU                    API            fps
----------------------------------------------------------
Celeron J1900  Intel HD Graphics 3G   OpenGL 3.3     17fps
Athlon 5350    RADEON R3              OpenGL 4.3     89fps

・fps が大きい方が速い

比べるまでもなく内蔵 GPU の性能では圧倒的な差があります。
RADEON は OpenGL で新しい API が使える点もポイントが高いです。
J1900 の GPU は使用していて少々性能不足を感じます。


CPU core の基本性能は Jaguar (Athlon/Kabini) の方が上。
メモリ速度や動作クロックを加味すると両者かなり近い性能になっています。

GPU は当然 RADEON (Athlon/Kabini) の方が速く、
性能差には数倍の開きがあります。

● BayTrail-D (Celeron J1900/Silvermont)
・消費電力が低くファンレス
・メモリ帯域が広い

● Kabini (Athlon 5350/Jaguar)
・浮動小数点演算能力が高い
・AVX/AES 命令に対応している
・GPU 性能が非常に高い


関連エントリ
・コンパイル時間の比較 BayTrail
・Atom Bay Trail の浮動小数点演算能力

C++ で開発していた OpenGL/OpenGL ES の Project を Emscripten でビルドしてみました。
Native Code 向けのプログラムがそのままブラウザ内で動いています。

・Windows Firefox (29.0.1)



・Android Firefox (29.0.1)



Chrome では 7 fps 程度なので asm.js (Firefox) の効果は絶大でした。
Android でも十分な速度で動いています。

追記 2014/05/24: その後 Chrome でも 60fps 以上出るようになりました。詳しくはこちら

Windows 8.1 Firefox 29    60fps 以上   (Core i7-3615QM)
FireOS 3.0  Firefox 29    60fps 以上   (Kindle Fire HDX7 MSM8974)
Android 4.4 Firefox 29    34fps 前後   (Nexus 7 2013 APQ8064)

Windows 8.1 Chrome 34      7fps 前後   (Core i7-3615QM)
FireOS 3.0  Silk           3fps 前後   (Kindle Fire HDX7 MSM8974)
Android 4.4 Chrome 34      3fps 前後   (Nexus 7 2013 APQ8064)

・fps の値が大きい方が高速
・FireOS 3.0 = Android 4.2.2 相当

もともと OpenGL ES 2.0 / EGL に対応していたこともあり、
修正箇所はごく僅かで済んでいます。
使えなかった API は pthread だけで、
追加したのは Mouse/Touch/Keyboard などの Event 周りです。
Network (socket系) とサウンドは未着手。
ソースコード数は 600 file, 26万行ほど。

Native を想定して書いたコードが、拍子抜けするほどあっさりと
ブラウザ内で動いています。

以前から何度か NativeClient (NaCl) への対応化にも取り組んでいたのですが、
あまり本質的でない部分で躓いていました。
同期型 FileIO や Thread 周りといった API 制限だけでなく、
gcc (4.4) が古くて C++11 のコードが通らなかったためです。
その後確認したところ、ARM や pnacl では比較的新しいコンパイラに
置き換わってるようです。

今回使用した Emscripten では何も問題はなく Native 向け API もそのままです。
詳しい説明は次回。


● Emscripten

・emscripten wiki

Android では Java, iOS では Objective-C が使われているように、
プラットフォームによってアプリケーション記述言語はまちまちです。
ただ多くの場合 C/C++ も併用できることが多く、
C/C++ 言語 + OpenGL ES 2.0 の組み合わせは、
移植性の高い共通言語＆API としての役割も担っています。
主にゲームで。

Web Browser も OpenGL ES 2.0 (WebGL) に対応しており、
NativeClient (NaCl) や Emscripten といった C/C++ のコードを
走らせる仕組みも登場しています。
C/C++ が使えるようになったことで、同じソースコードのまま
さらに多くの環境にアプリケーションを移植できるようになりました。

NaCl はコンパイルしたバイナリをブラウザ内で走らせますが、
Emscripten は仮想マシンとして JavaScript を利用しています。
ポインタを駆使した C Native なコードが JavaScript に変換されると聞いても
少々奇妙な印象を受けるかもしれません。
しかしながら JavaScript の性能向上は著しく、モバイル含めて
十分な速度で動いているこれらの結果にはやはり驚きを隠せません。


● 速度比較

1. 960x640 63万Tri/191万Vertices, 一部 Bone Animation あり

CPU                  GPU            OS           Browser      fps
------------------------------------------------------------------------
Ivy Core i7-3615QM   Intel HD 4000  Win8.1 x64   Win+OpenGL  100fps 前後
Ivy Core i7-3615QM   Intel HD 4000  Win8.1 x64   Firefox      60fps 以上*1
Ivy Core i7-3615QM   Intel HD 4000  Win8.1 x64   Chrome        7fps 前後
BayTrail-D J1900     Intel HD       Ubuntu14.04  X11+OpenGL    8fps 前後
BayTrail-D J1900     Intel HD       Ubuntu14.04  Firefox       5fps 前後
BayTrail-D J1900     Intel HD       Ubuntu14.04  Chrome         動作せず
Kabini Athlon5350    GeForce GTX650 Ubuntu14.04  X11+OpenGL  880fps 前後
Kabini Athlon5350    GeForce GTX650 Ubuntu14.04  Firefox      30fps 前後
Kabini Athlon5350    GeForce GTX650 Ubuntu14.04  Chrome        4fps 前後
APQ8064 Krait 1.5GHz Adreno 320     Android4.4   NDK+ES3.0    50fps 前後
APQ8064 Krait 1.5GHz Adreno 320     Android4.4   Firefox      34fps 前後
APQ8064 Krait 1.5GHz Adreno 320     Android4.4   Chrome        3fps 前後
Exynos5D Cortex-A15  Mali-T604      Android4.4   NDK+ES3.0    60fps 前後
Exynos5D Cortex-A15  Mali-T604      Android4.4   Firefox       8fps 前後
Exynos5D Cortex-A15  Mali-T604      Android4.4   Chrome         動作せず
MSM8974 Krait 400    Adreno 330     FireOS 3.0   Firefox      60fps 以上*1
MSM8974 Krait 400    Adreno 330     FireOS 3.0   Silk           fps 前後

・fps の値が大きい方が高速
・*1 : VSyncの上限
・Firefox 29, Chrome 34
・FireOS 3.0 = Android 4.2.2 相当
・APQ8064 = Nexus 7(2013), Exynos5D = Nexus 10, MSM8974 = Kindle Fire HDX7

2. 960x640 63万Tri/191万Vertices

CPU                  GPU            OS           Browser      fps
------------------------------------------------------------------------
Ivy Core i7-3615QM   Intel HD 4000  Win8.1 x64   Win+OpenGL  110fps 前後
Ivy Core i7-3615QM   Intel HD 4000  Win8.1 x64   Firefox      60fps 以上*1
Ivy Core i7-3615QM   Intel HD 4000  Win8.1 x64   Chrome       10fps 前後
BayTrail-D J1900     Intel HD       Ubuntu14.04  X11+OpenGL    8fps 前後
BayTrail-D J1900     Intel HD       Ubuntu14.04  Firefox       5fps 前後
BayTrail-D J1900     Intel HD       Ubuntu14.04  Chrome         動作せず
Kabini Athlon 5350   GeForce GTX650 Ubuntu14.04  X11+OpenGL  900fps 前後
Kabini Athlon 5350   GeForce GTX650 Ubuntu14.04  Firefox      30fps 前後
Kabini Athlon 5350   GeForce GTX650 Ubuntu14.04  Chrome        6fps 前後
APQ8064 Krait 1.5GHz Adreno 320     Android4.4   NDK+ES3.0    50fps 前後
APQ8064 Krait 1.5GHz Adreno 320     Android4.4   Firefox      30fps 前後
APQ8064 Krait 1.5GHz Adreno 320     Android4.4   Chrome        5fps 前後
Exynos5D Cortex-A15  Mali-T604      Android4.4   NDK+ES3.0    60fps 以上*1
Exynos5D Cortex-A15  Mali-T604      Android4.4   Firefox       8fps 前後
Exynos5D Cortex-A15  Mali-T604      Android4.4   Chrome         動作せず
MSM8974 Krait 400    Adreno 330     FireOS 3.0   Firefox      60fps 以上*1
MSM8974 Krait 400    Adreno 330     FireOS 3.0   Silk          5fps 前後

・fps の値が大きい方が高速

3. 960x640 6万Tri/19万Vertices

CPU                  GPU            OS           Browser      fps
------------------------------------------------------------------------
Ivy Core i7-3615QM   Intel HD 4000  Win8.1 x64   Win+OpenGL  520fps 前後
Ivy Core i7-3615QM   Intel HD 4000  Win8.1 x64   Firefox      60fps 以上*1
Ivy Core i7-3615QM   Intel HD 4000  Win8.1 x64   Chrome       15fps 前後
BayTrail-D J1900     Intel HD       Ubuntu14.04  X11+OpenGL   60fps 以上*1
BayTrail-D J1900     Intel HD       Ubuntu14.04  Firefox       5fps 前後
BayTrail-D J1900     Intel HD       Ubuntu14.04  Chrome         動作せず
Kabini Athlon 5350   GeForce GTX650 Ubuntu14.04  X11+OpenGL 1020fps 前後
Kabini Athlon 5350   GeForce GTX650 Ubuntu14.04  Firefox      38fps 前後
Kabini Athlon 5350   GeForce GTX650 Ubuntu14.04  Chrome        9fps 前後
APQ8064 Krait 1.5GHz Adreno 320     Android4.4   NDK+ES3.0    60fps 以上*1
APQ8064 Krait 1.5GHz Adreno 320     Android4.4   Firefox      60fps 以上*1
APQ8064 Krait 1.5GHz Adreno 320     Android4.4   Chrome        8fps 前後
Exynos5D Cortex-A15  Mali-T604      Android4.4   NDK+ES3.0    60fps 以上*1
Exynos5D Cortex-A15  Mali-T604      Android4.4   Firefox       9fps 前後
Exynos5D Cortex-A15  Mali-T604      Android4.4   Chrome         動作せず
MSM8974 Krait 400    Adreno 330     FireOS 3.0   Firefox      60fps 以上*1
MSM8974 Krait 400    Adreno 330     FireOS 3.0   Silk          8fps 前後

・fps の値が大きい方が高速

描画負荷を変えても速度が大きく変わらないものは CPU (JavaScript) 側の
限界と思われます。
Chrome, BayTrail-D, Kabini, Exynos 5D(Nexus10) が相当します。
また Native との差が少ないものは GPU 側も上限に近いことを意味しています。

Animation ありの場合骨の計算分 JS の負担が増えます。(頂点blendは GPU)
GPU に余裕があるのに 1. と 2. で大きく差が生じる場合は、
JavaScript の演算能力にも余裕がないことを示しています。

BayTrail-D は描画と CPU (JS) 両方共限界に達しているようです。
Native (X11+OpenGL) の 1./2. のテストでは、画面拡大時に速度が上がり、
オブジェクトが画面に全体が収まる場合は Firefox に近い速度まで下がります。
おそらく頂点性能が足りていないと思われます。

また同時に BayTraild の Firefox では拡大しても速度が上がらず一定なので、
JavaScript の動作速度も制限となっていることがわかります。
倍精度浮動小数点演算が苦手なことも影響しているかもしれません。

Kabini は外付けの GeForce がオーバースペック過ぎて CPU が追いついていません。
CPU (JS) 自体は BayTrail よりはかなり速いようです。

Android の Native (NDK+ES) は Fullscreen 動作となり、1920x1200, 2560x1600 で
レンダリングしているため他と条件が異なっています。

JavaScript の動作は Cortex-A15 よりも Krait/Krait 400 の方が高速でした。
Krait (APQ8064) は 3. のテストで制限がかかっていないため、
JavaScript 自体は余裕があるものの GPU で落ちているようです。
GPU の演算能力に余裕がある Krait 400 (MSM8974) はどのテストでも 60fps
超えています。

Desktop の Kabini よりも Krait/Krait 400 の方が JavaScript の
動作速度が速いこともわかります。

Cortex-A15 の速度が全然出ていませんが、VFP Benchmark の結果でも
倍精度演算は Krait の方が良い結果を出しています。
ただそれ以上に大きく差が開いているので、他にも何らかの要因があるのでは
ないかと思われます。

同じ Cortex-A15 のTegra Note 7 (Tegra4) でも試したかったのですが
RAM 容量が足りず動きませんでした。
今のところ Android + Firefox の組み合わせは RAM 2GB でぎりぎりです。
まだビルドを通したばかりでプロジェクトが巨大なせいもあります。


● まとめ

・Emscripten で C/C++ と OpenGL ES 2.0 のコードがブラウザ上でそのまま走る
・Firefox なら速度も速い (asm.js のおかげ)
・Android でも Firefox + Krait は高速動作 (Cortex-A15 が遅い原因は不明)

追記 (2014/05/20) : Tegra4 (Cortex-A15) では高速に動作することを確認しました

追記 (2014/05/24) : Chrome で速度が遅かった原因がわかりました。修正により 60fps 以上出ています。

続きます:「Emscripten C++/OpenGL ES 2.0 のアプリケーションをブラウザで動かす (2)」


関連エントリ
・Emscripten C++/OpenGL ES 2.0 のアプリケーションをブラウザで動かす 一覧