HN 日本語サマリー

← 一覧へ戻る
プログラミング

Rustの新APIによる高速な浮動小数点演算

Faster floating point math with Rust's new API (pythonspeed.com)

93 pointsby subset33 コメント

要約

Rust 1.98で導入された新しいAPIにより、浮動小数点演算のパフォーマンスが向上しました。これは、コンパイラが浮動小数点演算の順序を保守的に扱うため、整数演算ほど最適化されないという問題を解決するものです。新しい「代数的」演算子を使用することで、コンパイラは浮動小数点演算の順序を変更できるようになり、SIMD命令などの最適化を活用して速度を向上させることができます。

全文翻訳

Rustの新APIによる高速な浮動小数点演算

浮動小数点演算は、コンパイラがコードの最適化に関して保守的であるため、整数演算よりも遅くなることがよくあります。一部のプログラミング言語にはすでに何らかの解決策がありましたが、これまではRustにはこの制限に対処するための良い安定した方法がありませんでした。しかし、バージョン1.98から、Rustはコンパイラにコードをさらに最適化できることを伝えることができるようになります。ただし、丸め誤差を最小限に抑えながら数値アルゴリズムを記述できるような、追加の制御も可能です。

この記事では、以下のことを学びます。

  • デフォルトでは、コンパイラが整数演算ほど浮動小数点演算を最適化しない理由。
  • この制限を解決するためのRustの新API。
  • この新しいAPIの使用例、その速度への影響、およびどこで使用できるかを制御する方法。

整数の合計は速い

可能なパフォーマンスの基準として、整数を使った例から始めます。

最も高速なコード生成を得るために、Rustに「もう2004年ではない」こと、そして過去10年ほどのモダンなハードウェア、すなわちx86-64マシンを必要とするCPU命令を生成できることを伝えています。具体的には、この記事のすべてのコードは RUSTFLAGS="-C target-cpu=x86-64-v3" でコンパイルされています。(最大限の互換性のために、実際の使用では古いコンピュータ用のフォールバック実装を提供することもできます。)

以下は、int64数値のスライスを合計するRust関数です。

fn naive_sum_i64(values: &[i64]) -> i64 {
    let mut total = 0;
    for value in values {
        total += value;
    }
    total
}

Pythonにこれを公開するコードは省略しますが、それは以前の記事にあるRust/Pythonコードのバリアントです。

ベンチマークのために、NumPyで整数の配列を作成します。

import numpy as np

DATA_INT = np.ones((1_000_000,), dtype=np.int64)
assert naive_sum_i64(DATA_INT) == 1_000_000

そして、この配列の合計速度を測定できます。

コード➘ 経過マイクロ秒➘ 値あたりのCPU命令数
naive_sum_i64(DATA_INT)168.10.5

➘ 数値が小さいほど良い

値あたり0.5 CPU命令!これはどのように機能するのでしょうか?

おそらくコンパイラは、Single Instruction, Multiple Data (SIMD) CPU命令を使用しており、複数の値を一度にバッチ処理します。私が使用しているi7-12700K CPUは256ビットSIMD命令を備えており、一度に4つの64ビット整数に対して特定の操作を実行できます。もし専用のSIMD合計CPU命令があれば、CPUは250,000回ループし、各イテレーションで4つの整数を合計するだけで済むでしょう。

実際、そうなっています。

コード➘ 経過マイクロ秒➘ CPU命令数256ビットSIMD整数命令
naive_sum_i64(DATA_INT)156.8521,280250,003

➘ 数値が小さいほど良い

要するに、専用のSIMD命令を使用することで、私のCPUは非常に高速に整数を合計できます。

合計する浮動小数点数は遅い?!

では、浮動小数点数はどうでしょうか?それらも高速なのでしょうか?

再び、100万個の浮動小数点値を作成します。

# 0から1の間のfloat64値100万個の配列。
DATA = np.random.random((1_000_000,))

単純な浮動小数点合計関数を実装します。

fn naive_sum(values: &[f64]) -> f64 {
    let mut total = 0.0;
    for value in values {
        total += value;
    }
    total
}

整数と浮動小数点数の合計のパフォーマンスを比較します。

コード➘ 経過マイクロ秒➘ CPU命令数256ビットSIMD整数命令256ビットSIMD浮動小数点命令
naive_sum_i64(DATA_INT)151.9521,214250,0030
naive_sum(DATA)595.21,458,26900

➘ 数値が小さいほど良い

浮動小数点合計は整数合計よりもはるかに遅く、コンパイラはSIMD浮動小数点演算を使用しませんでした。なぜ違いがあるのでしょうか?

浮動小数点演算は結合法則を満たさない

ほとんどのコンパイラと同様に、Rustはリリースモードでコードをコンパイルする際にコードを最適化し、(うまくいけば)より高速にするためにさまざまな方法で変換します。しかし、コンパイラがこれを行う際に約束していることがあります。それは、最適化されたコードが最適化されていないコードと全く同じように動作することです。

3つの整数 a, b, c を加算する場合、a + (b + c) == (a + b) + c です。これは、コンパイラがSIMD演算など、わずかに加算の順序を変更する可能性のある最適化を行うための十分な余地を与えます。

浮動小数点数は異なります。例えば、浮動小数点数は非常に小さい値から非常に大きい値まで幅広い値を持つため、十分に大きい数に十分に小さい数を加えると、その同じ大きい数になります。

print(
    "Does adding a small number do nothing?",
    1e16 + 1.0 == 1e16
)
Does adding a small number do nothing? True

より一般的には、浮動小数点数では、少なくとも複数の数を連続して加算する場合、a + (b + c) は (a + b) + c と常に同じではありません。例えば、1e16 で始まり、その後に多くの 1.0 値が続く配列と、その逆の配列があるとします。これらの配列を合計すると異なる結果になります。

import math

HIGH_VALUE_FIRST = np.ones((1_000_000,), dtype=np.float64)
HIGH_VALUE_FIRST[0] = 1e16
HIGH_VALUE_LAST = np.ones((1_000_000,), dtype=np.float64)
HIGH_VALUE_LAST[-1] = 1e16

print(
    "Is the sum the same?",
    naive_sum(HIGH_VALUE_FIRST) == naive_sum(HIGH_VALUE_LAST)
)
Is the sum the same? False

合計の順序が結果に影響するため、コンパイラは、私がその特定の順序を理由があって求めたと仮定します。その結果、コンパイラはこれらの操作を並べ替えることはありません。また、結果のコードが遅くなるとしても、結果を変更する可能性のある他の最適化を適用することもありません。

Rustの新しい代数演算子:コンパイラに柔軟性をいつ与えるかを伝える

コンパイラの保守性はデフォルトで正しいですが、プログラマとして操作の順序を変更しても問題ないことを知っている場合があります。その状況では、コンパイラに「ここでは操作の順序を変更すべきではないが、あちらでは実際には問題ない」と伝えることができると良いでしょう。

Rust 1.98から、それを可能にする新しい機能があります。浮動小数点数に対して通常の算術演算を行うことに加えて、新しいいわゆる「代数」算術演算子のセットがあり、ドキュメントによると「コンパイラが実数のすべての通常の代数的性質を使用して浮動小数点演算を最適化することを許可する」とあります。これには操作の順序を変更することも含まれます。

Rust 1.98のリリース日は2026年8月20日です。この記事を書いたのはそれより前なので、この記事のコードは同じ機能を含む「beta」チャンネルで実行しました。

例:最適化されたペアワイズ加算

これらの演算子を実際に見て、それらがどのように高速なコードを可能にするかを見てみましょう。

浮動小数点数の合計は予期しない動作をする可能性があるため(1e16 + 1.0 == 1e16 を思い出してください)、多数の浮動小数点数を合計したい場合、結果の丸め誤差を最小限に抑えるためにさまざまなアルゴリズムを使用できます。それらの間のトレードオフは、通常、速度と精度のどちらを優先するかです。numpy.sum() は、速度と累積誤差の低減のバランスが良いペアワイズ加算と呼ばれるアルゴリズムを主に使用しています。確かに、上記で naive_sum() で行ったように、一度に1つの浮動小数点数を順番に加算するよりも誤差の蓄積は少ないです。

ペアワイズ加算の基本的な考え方は、配列を2つに分割し、同じアルゴリズムで各側を再帰的に合計し、結果の2つの浮動小数点数を合計することです。配列サイズの特定のしきい値(NumPyの場合は128)を下回ると、合計は通常どおり行われます…そしてそれは任意の順序で行うことができます。

このアルゴリズムをRustで実装してみましょう。上位2つの浮動小数点数を加算する際には、通常の加算を使用します。この場合、コンパイラは操作を並べ替えたり、出力を変更する可能性のある他のことはできません。関数が通常の合計を行うしきい値に達したら、代数加算に切り替えます。なぜなら、この時点では加算の順序は気にせず、ただ速度が欲しいからです。

fn pairwise_sum(values: &[f64]) -> f64 {
    let n = values.len();
    if n > 128 {
        // アルゴリズムの2つの再帰的な適用による正確な加算:
        let half = n / 2;
        pairwise_sum(&values[0..half])
            + pairwise_sum(&values[half..n])
    } else {
        // 😎 アルゴリズムに関しては順序が問題ない通常の加算。
        // そのため、代数加算を使用しても問題なく、コンパイラに
        // 大胆な最適化を許可します。
        let mut total: f64 = 0.0;
        for value in values {
            total = total.algebraic_add(*value);
        }
        total
    }
}

このペアワイズ実装は高速であり、実際、NumPyの実装よりも高速です。

コード➘ 経過マイクロ秒➘ CPU命令数256ビットSIMD浮動小数点命令
naive_sum(DATA)563.11,458,2790
np.sum(DATA)190.72,191,7670
pairwise_sum(DATA)144.5🏆1,298,028270,336

➘ 数値が小さいほど良い

そして、NumPyの実装と同じ(一般的な)精度を持ちます。なぜなら、同じアルゴリズムを実装しているからです。

from math import fsum

# fsum() は、回避可能な浮動小数点誤差をすべて除去する正確な合計アルゴリズムを使用します。
assert fsum(HIGH_VALUE_FIRST) == fsum(HIGH_VALUE_LAST)

correct_sum = fsum(HIGH_VALUE_FIRST)

print(
    "naive_sum() error:   ",
    naive_sum(HIGH_VALUE_FIRST) - correct_sum
)
print(
    "np.sum() error:      ",
    np.sum(HIGH_VALUE_FIRST) - correct_sum
)
print(
    "pairwise_sum() error:",
    pairwise_sum(HIGH_VALUE_FIRST) - correct_sum
)
naive_sum() error:    -1000000.0
np.sum() error:       -14.0
pairwise_sum() error:-6.0

np.sum() と pairwise_sum() の誤差の違いは意味のあるものではなく、単なる偶然です。重要な点は、naive_sum() と比較して同程度の低オーダーの誤差があるということです。

追加のボーナスとして、pairwise_sum() がSIMDコード生成を促進するために使用するコード構造は、NumPyのものよりもはるかに簡潔です。

もう一つの例:二乗差の合計

代数演算子でできるのは、数値を合計することだけではありません。次の例では、2つの配列間の二乗差の合計を計算します。

2つの配列が必要です。

DATA1 = np.random.random((1_000_000,))
DATA2 = np.random.random((1_000_000,))

通常の算術演算子を使用した実装は次のとおりです。

fn ssd_normal(arr1: &[f64], arr2: &[f64]) -> f64 {
    assert_eq!(arr1.len(), arr2.len());
    let mut total = 0.0;
    for (val1, val2) in arr1.iter().zip(arr2) {
        total += (val1 - val2).powi(2);
    }
    total
}

そして、代数演算子を使用した場合は次のようになります。f64.powi() が代数演算子を使用するかどうかは私には明らかではないため、明示的に使用しました。

fn ssd_optimized(arr1: &[f64], arr2: &[f64]) -> f64 {
    assert_eq!(arr1.len(), arr2.len());
    let mut total: f64 = 0.0;
    for (val1, val2) in arr1.iter().zip(arr2) {
        // 😎 より多くのコンパイラ最適化を許可するための代数演算:
        let diff = val1.algebraic_sub(*val2);
        let squared_diff = diff.algebraic_mul(diff);
        total = total.algebraic_add(squared_diff);
    }
    total
}

まず、結果が類似していることを確認するための簡単なテストです。

print(ssd_normal(DATA1, DATA2))
print(ssd_optimized(DATA1, DATA2))
166770.0055951995
166770.00559520238

次に、パフォーマンスを測定します。

コード➘ 経過マイクロ秒➘ 値あたりのCPU命令数
ssd_normal(DATA1, DATA2)628.74.5
ssd_optimized(DATA1, DATA2)371.1🏆1.0

➘ 数値が小さいほど良い

代数演算を使用することで、私のコンピュータでは2倍高速に実行されるコードを生成できます。

数値コードを高速化しましょう!

ペアワイズ加算アルゴリズムは、厳密な演算子と緩やかな演算子の両方がなぜ必要なのかを示す素晴らしい例です。

  • 厳密な順序演算子のみを使用すると、コードは遅くなります。
  • 緩やかな代数最適化演算子のみを使用すると、コンパイラがアルゴリズムを存在しないものに最適化してしまう可能性があり、アルゴリズムが目指す精度を失います。

上記で示した実装は、精度のためには通常の加算と、速度のためには代数加算の両方を使用することから恩恵を受けています。

Rustで数値コードを書いている場合、あなたのコードも恩恵を受けるかもしれません。Rust 1.98が利用可能になったら試してみてください。まだRustを使用していない場合は、これも切り替える良い理由になります。