0
0

Delete article

Deleted articles cannot be recovered.

Draft of this article would be also deleted.

Are you sure you want to delete this article?

OpenBLASってなんだ? — NumPyの行列積が1コアで76 GFLOPS出る理由

0
Posted at

はじめに

この記事で得られること

読み終えると、明日から次の4つを自分で決められるようになります。

  1. 自分のNumPyやPyTorchが どのBLASで動いているか を1コマンドで確かめ、乗り換えるべきか判断できる
  2. マルチプロセスで回す処理で OPENBLAS_NUM_THREADS を いつ1に固定すべきか 判断できる
  3. 小さな行列を大量に掛けるとき、forループとバッチ化のどちらが速いか 境目のサイズ で判断できる
  4. llama.cppのCPUビルドで GGML_BLAS=ON を 付ける価値があるか 判断できる

対象読者

NumPyで a @ b を書いたことはあるが、その中で何が動いているかは考えたことがない人。線形代数の深い知識は要りません。

範囲外

BLASの全API解説、CUDA側のcuBLAS、OpenBLASのソースからのビルド手順は扱いません。CPU上で「なぜ速いのか」と「何を設定すべきか」に絞ります。

なぜ私がこれを書くのか

きっかけは、貧弱なサンドボックス環境(Xeon 1コア、メモリ3GB)でMamba系の計測をしていたときのことです。自作の三重ループが0.06 GFLOPSしか出ないのに、np.matmul に置き換えた瞬間に65 GFLOPSが出ました。1000倍です。この差の正体が、何も考えずにpipで入れたNumPyに同梱されていたOpenBLASでした。

読者に考えてほしいのは「速さは誰が作っているのか」です。Pythonの1行の裏には、CPU世代ごとに手書きされた命令列が控えています。その正体を知ると、環境変数1つで速度が半分になる事故や、逆に何もせず倍速になる余地が見えてきます。

この記事の実測はすべて Xeon 1コア(2.10GHz、AVX-512対応)、メモリ3GB、Python 3.12.3、NumPy 2.4.4(同梱OpenBLAS 0.3.31)、threadpoolctl 3.6.0 で取得しています。数値は環境依存なので、倍率の傾向を読んでください。


1. BLASってなんだ? — 規格と実装は別物

このセクションで分かること: OpenBLASの「BLAS」が指しているものと、なぜ実装が複数あるのか。

まず土台です。BLAS(Basic Linear Algebra Subprograms、基本線形代数副プログラム)は、ベクトルと行列の基本演算を定めた 関数名と引数の規格 です。1979年に策定され、公式の参照実装は現在もnetlib.orgで公開されています。

この記事では、ここから最後まで 工場 のたとえで進めます。

  • BLASの規格は、工場に届く 作業指示書の書式 です
  • netlibの参照実装は、指示書どおりに 教科書的な手作業 で組み立てる試作工場です。正しいけれど遅い
  • OpenBLASは、同じ指示書を、CPUごとに最適化された 専用の工作機械 で量産する工場です

指示書は3階級に分かれています。

階級 代表的な指示 演算量とデータ量の比 工場で言うと
Level 1 内積 dot、スケーリング axpy データ量と同じ 部品を1個ずつ検品
Level 2 行列とベクトルの積 gemv データ量と同じ 部品を1列ぶん組み立て
Level 3 行列同士の積 gemm データ量の $n$ 倍 部品を丸ごと組み立て

Level 3だけが特別です。行列積は $n^3$ 回の掛け算をするのにデータは $n^2$ 個しか要らないので、いちど工場に運び込んだ部品を 何度も使い回せます。この性質が、次節以降の「なぜ速いのか」の根っこになります。


2. OpenBLASの正体 — 2010年に止まった職人の工場を、世界が引き継いだ

前節で、BLASは規格でありOpenBLASはその実装の1つだと確認しました。では、なぜ数ある実装の中でOpenBLASがNumPyの標準搭載になったのか。その理由は出自にあります。

このセクションで分かること: OpenBLASの系譜、ライセンス、現在の開発状況。

公式READMEの冒頭はこう始まります。

OpenBLAS is an optimized BLAS (Basic Linear Algebra Subprograms) library based on GotoBLAS2 1.13 BSD version.
(和訳:OpenBLASは、GotoBLAS2 1.13 BSD版を基にした最適化BLASライブラリです。)

GotoBLASは、テキサス大学TACCに在籍していた後藤和茂氏が、CPUのアセンブリを手書きして作り上げたBLASです。リポジトリに今も同梱されている GotoBLAS_01Readme.txt には「This is the last update and done on 5th Feb. 2010」とあり、2010年2月で更新が止まっています。工場のたとえで言えば、一人の職人が全機械を手で調整していた工場が、職人の退職で止まった のがこの時点です。

その最終版がBSDライセンスで公開されていたため、中国科学院の並列ソフトウェアグループが2011年3月にフォークし、OpenBLASとして開発を引き継ぎました。現在は OpenMathLib という組織名義で、GitHub上で開発が続いています。

現時点の状況を一次情報で押さえると、最新安定版は 0.3.34(2026年7月16日リリース)、ライセンスは3-clause BSD、対応CPUはx86-64、ARM/AArch64、POWER、RISC-V、LoongArchなどで、連立方程式や固有値を扱う上位ライブラリLAPACKも同梱されています。

注意: 0.3.34のリリースノートには「Fixed potential race conditions between concurrent calls to level3 BLAS functions」(和訳:Level 3 BLAS関数の同時呼び出し間で起こりうる競合状態を修正)とあります。マルチスレッドで大量に gemm を呼ぶ環境では、古いバージョンを使い続けるリスクがあります。

つまりOpenBLASは、元は一人の職人技、今は世界中の手で保守される工場 です。この出自が、次節で見る「あなたは既にこの工場を使っている」という事実につながります。


3. まず自分のNumPyが何を使っているか確かめる

前節で、OpenBLASが2011年以来オープンに保守されてきた実装だと分かりました。オープンでBSDライセンスだからこそ、NumPyやSciPyの配布物に同梱できます。

このセクションで分かること: 手元のNumPyがどのBLASにリンクされているか、1コマンドで確認する方法。

NumPyの公式ビルドドキュメントは、BLASの探索順序を次のように書いています。

A typical order is: MKL, Accelerate, OpenBLAS, FlexiBLAS, BLIS, plain libblas/liblapack.
(和訳:典型的な順序は、MKL、Accelerate、OpenBLAS、FlexiBLAS、BLIS、素のlibblas/liblapack です。)

ただしこれはソースからビルドする場合の話で、PyPIから pip install numpy で落ちてくるwheelにはOpenBLASが同梱されています。実際に確認してみます。

import numpy as np
from threadpoolctl import threadpool_info

np.show_config()  # Build Dependencies の blas / lapack を見る

for lib in threadpool_info():
    print(lib["internal_api"], lib["version"],
          lib["num_threads"], lib.get("architecture"))

手元の出力(抜粋)です。

blas:
  name: scipy-openblas
  openblas configuration: OpenBLAS 0.3.31.188.0  USE64BITINT DYNAMIC_ARCH NO_AFFINITY
    Haswell MAX_THREADS=64
openblas 0.3.31.188.0 1 SkylakeX

読み取れることが3つあります。

  1. scipy-openblas という名前で OpenBLAS 0.3.31が同梱 されている
  2. ビルド時のターゲットは Haswell だが、DYNAMIC_ARCH フラグが立っている
  3. 実行時に検出されたアーキテクチャは SkylakeX、スレッド数は1

層構造を図にすると、こうなります。

2番と3番のギャップが、次節の主役です。工場のたとえで言えば、出荷時の設計図はHaswell向けなのに、現場に着いてからAVX-512の機械があると気づいてラインを組み替えた ということです。


4. なぜ速いのか① — CPUごとに手書きされた工作機械

前節で、同梱OpenBLASが実行時に SkylakeX を選んだことを見ました。この「実行時に選ぶ」仕組みが、OpenBLASの速さの第一の源です。

このセクションで分かること: カーネルとは何か、DYNAMIC_ARCHが何をしているか、それが何倍の差を生むか。

OpenBLASの内部では、行列積の最内側ループがCPU世代ごとに別々のコードで書かれています。これをカーネル(kernel、演算の最小単位を担う専用コード)と呼びます。工場で言えば、Haswell用の工作機械、SkylakeX用の工作機械が別々に置いてあり、READMEには対応表があります。

Intel Haswell: Optimized Level-3 and Level-2 BLAS with AVX2 and FMA on x86-64.
Intel Skylake-X: Optimized Level-3 and Level-2 BLAS with AVX512 and FMA on x86-64.
(和訳:Haswellでは AVX2 と FMA、Skylake-Xでは AVX512 と FMA でLevel-3、Level-2を最適化。)

そして DYNAMIC_ARCH=1 でビルドすると、複数世代のカーネルを1つのライブラリに全部詰め込み、起動時にCPUを見て選びます。READMEの記述はこうです。

OpenBLAS can be built for multiple targets with runtime detection of the target cpu by specifying DYNAMIC_ARCH=1
(和訳:DYNAMIC_ARCH=1 を指定すると、複数ターゲット向けにビルドし、実行時にCPUを検出して切り替えられる。)

この工作機械がどれほど違うかを測ります。同じ $256 \times 256$ の行列積を、Python三重ループ、BLASを使わないNumPyの einsum、OpenBLAS経由の matmul の3通りで実行しました。

import time, numpy as np

def gflops(n, sec):
    return 2 * n**3 / sec / 1e9

def timeit(fn, a, b):
    t0 = time.perf_counter(); fn(a, b); return time.perf_counter() - t0

def py_loop(a, b):
    n = len(a); c = [[0.0]*n for _ in range(n)]
    al, bl = a.tolist(), b.tolist()
    for i in range(n):
        for k in range(n):
            aik = al[i][k]; bk = bl[k]; ci = c[i]
            for j in range(n):
                ci[j] += aik * bk[j]
    return c

n = 256
a = np.random.rand(n, n); b = np.random.rand(n, n)
for name, fn in [("Python三重ループ", py_loop),
                 ("np.einsum BLAS不使用", lambda a, b: np.einsum("ij,jk->ik", a, b)),
                 ("np.matmul OpenBLAS", np.matmul)]:
    fn(a, b)  # ウォームアップ
    t = min(timeit(fn, a, b) for _ in range(3))
    print(f"{name:22s} {t*1000:9.1f} ms {gflops(n, t):7.2f} GFLOPS")

ここで使った指標を1つだけ導入します。$\mathrm{GFLOPS}$(ギガフロップス、スカラー値)は1秒あたりの浮動小数点演算回数で、工場なら 1秒あたりの加工数 です。

\mathrm{GFLOPS} = \frac{2 n^3}{t \times 10^9}

この式が言っているのは「$n \times n$ 行列積は掛け算 $n^3$ 回と足し算 $n^3$ 回で合計 $2n^3$ 回の加工が必要で、それを所要時間 $t$ 秒で割る」ということです。

実装 所要時間 GFLOPS 工場で言うと
Python三重ループ 533.7 ms 0.06 職人が1個ずつ手作業
np.einsum BLAS不使用 4.1 ms 8.16 汎用機械で加工
np.matmul OpenBLAS 0.5 ms 64.84 SkylakeX専用機械で加工

正直に言うと、einsumとmatmulに8倍の差がつくのは予想外でした。どちらもCで書かれたNumPyの内部関数です。差の正体は、AVX-512で1命令に8個のdoubleを詰めるカーネルと、それを支える次節の仕組みです。


5. なぜ速いのか② — 作業台に載る分量に小分けする

前節で、専用カーネルだけでBLAS不使用の8倍になることを見ました。しかしSIMD命令の幅は8倍もありません。残りの差を埋めているのが、行列を小分けする工夫 です。

このセクションで分かること: ブロッキングの考え方と、行列サイズを大きくするとOpenBLASだけが速くなり続ける理由。

CPUのキャッシュはL1が数十KB、L2でも数MBです。$1024 \times 1024$ のdouble行列は8MBなので丸ごとは載りません。工場で言えば、部品を全部いちどに作業台に置くことはできない のです。

そこでOpenBLASは、行列をキャッシュに収まる大きさのブロック(block、部分行列)に切り出し、連続したメモリに詰め直してから計算します。これをパッキング(packing、詰め直し)と呼びます。パレット1枚ぶんの部品だけを作業台に載せ、載っているあいだに使えるだけ使い切ってから次のパレットを取りに行く、という運び方です。

この設計は、GotoBLASの作者らによる2008年の論文 "Anatomy of High-Performance Matrix Multiplication"(邦題訳:高性能行列積の解剖)で体系化され、OpenBLASの公式FAQもブロックサイズの根拠としてこの論文を挙げています。

効果を測ります。行列サイズと精度を変えて、BLAS不使用の einsum と OpenBLASの matmul を並べます。

import time, numpy as np

def best_of(fn, reps=3):
    ts = []
    for _ in range(reps):
        t0 = time.perf_counter(); fn(); ts.append(time.perf_counter() - t0)
    return min(ts)

def run(n, dtype):
    a = np.random.rand(n, n).astype(dtype); b = a.copy()
    np.matmul(a, b)  # ウォームアップ
    t_blas = best_of(lambda: np.matmul(a, b))
    t_ein = best_of(lambda: np.einsum("ij,jk->ik", a, b)) if n <= 1024 else float("nan")
    f = lambda t: 2 * n**3 / t / 1e9
    return t_ein * 1e3, t_blas * 1e3, f(t_ein), f(t_blas)

for dtype in (np.float64, np.float32):
    for n in (256, 1024, 2048):
        te, tb, fe, fb = run(n, dtype)
        print(f"| {n} | {dtype.__name__} | {te:.2f} | {tb:.2f} | {fe:.1f} | {fb:.1f} |")
n dtype einsum ms matmul ms einsum GFLOPS OpenBLAS GFLOPS 倍率
256 float64 4.20 0.58 8.0 58.3 x7
1024 float64 341.91 28.51 6.3 75.3 x12
2048 float64 未計測 225.98 未計測 76.0 未計測
256 float32 2.41 0.24 13.9 138.9 x10
1024 float32 152.22 13.98 14.1 153.6 x11
2048 float32 未計測 99.95 未計測 171.9 未計測

読み方は2点です。

  1. einsumは行列が大きくなると遅くなる(float64で8.0から6.3へ)のに、OpenBLASは大きくなるほど速くなる(58.3から76.0へ)。前者は部品が作業台からこぼれてメモリまで取りに戻っている状態、後者はパレット運用でこぼれを防いでいる状態です。
  2. float32はfloat64のほぼ2倍 です。AVX-512の1命令はfloat64なら8個、float32なら16個を同時に加工できるので、機械の1ストロークあたりの部品数がちょうど倍になります。

float64からfloat32に落とすと、丸め誤差は約 $10^{-16}$ から $10^{-7}$ に悪化します。速度が2倍になる代わりに有効桁数が半分になる、という交換です。機械学習の推論では許容されることが多く、金融計算や科学計算では許容されないことが多いです。


ここまでのまとめ

  • BLAS は作業指示書の規格、OpenBLAS はGotoBLAS2 1.13から続く量産工場で、現行版は0.3.34
  • pipで入れたNumPyには OpenBLASが同梱 されていて、np.show_config() と threadpool_info() で確認できる
  • 速さの源は2つ。CPU世代ごとの 専用カーネル を実行時に選ぶこと(DYNAMIC_ARCH)と、キャッシュに載る ブロック単位 に詰め直すこと
  • 手元の1コアでは、BLAS不使用比で 7倍から12倍、float32ならさらに 2倍

ここまでは「なぜ速いのか」でした。後半は、その知識を使って 明日何を決めるか です。


6. 決定① — 小さい行列を大量に掛けるなら、束ねてから工場に出す

前節で、OpenBLASは行列が大きいほど効率が上がることを見ました。逆に言えば、小さい行列ではパレット運用の意味がなく、工場への搬入手続きだけが残ります。

このセクションで分かること: forループでmatmulを1万回呼ぶのと、3次元配列で1回呼ぶのはどこから差がつくか。

import time, numpy as np

def best_of(fn, reps=3):
    ts = []
    for _ in range(reps):
        t0 = time.perf_counter(); fn(); ts.append(time.perf_counter() - t0)
    return min(ts)

B = 10_000
for n in (4, 8, 16, 32, 64):
    a = np.random.rand(B, n, n); b = np.random.rand(B, n, n)
    t_loop = best_of(lambda: [np.matmul(a[i], b[i]) for i in range(B)])
    t_batch = best_of(lambda: np.matmul(a, b))
    print(f"| {n} | {t_loop*1e3:.1f} ms | {t_batch*1e3:.1f} ms | x{t_loop/t_batch:.0f} |")
行列サイズ n forループで matmul 1万回 3次元配列で matmul 1回 倍率
4 12.5 ms 0.4 ms x29
8 12.6 ms 0.7 ms x19
16 18.2 ms 3.9 ms x5
32 40.8 ms 34.5 ms x1
64 171.5 ms 193.5 ms x1

$n = 4$ と $n = 8$ でforループの時間がほぼ同じ(12.5 msと12.6 ms)なのが決定的です。計算量は8倍違うのに時間が変わらない。つまり 1回あたり約1.2マイクロ秒の搬入手続きが全体を支配していて、加工時間はほぼゼロ です。

判断基準はこうなります。

  • n が 16 以下: 必ず束ねる。forループは搬入手続きにしか時間を使っていない
  • n が 32 以上: どちらでもよい。加工時間が手続きを上回り、束ねるメリットが消える

これはAttentionのヘッドごとの小さな行列積を、PyTorchが bmm(batched matrix multiply)で束ねて処理する理由そのものです。


7. 決定② — 作業員の人数、OPENBLAS_NUM_THREADS をいつ1にするか

前節で、行列が十分大きければ工場は効率よく回ることが分かりました。ここに 作業員を増やす、つまりマルチスレッドの話が乗ります。ところが作業員は増やすほど速いわけではありません。

このセクションで分かること: OpenBLASのスレッド数を決める環境変数と、それを1に固定すべき典型的な状況。

READMEはスレッド数の指定方法と優先順位をこう定めています。

The priorities are OPENBLAS_NUM_THREADS > GOTO_NUM_THREADS > OMP_NUM_THREADS.
If you compile this library with USE_OPENMP=1, you should set the OMP_NUM_THREADS environment variable; OpenBLAS ignores OPENBLAS_NUM_THREADS and GOTO_NUM_THREADS when compiled with USE_OPENMP=1.
(和訳:優先順位は OPENBLAS_NUM_THREADS、GOTO_NUM_THREADS、OMP_NUM_THREADS の順。USE_OPENMP=1 でビルドした場合は OMP_NUM_THREADS を使うこと。その場合、他の2つは無視される。)

指定しない場合、OpenBLASは コア数ぶんの作業員を全員出勤させます。単独で1つの大きな行列積を回すならこれが最速です。問題は、工場が複数同時に立つときです。

典型的な事故: 16コアのマシンで multiprocessing.Pool(16) を起こし、各プロセスがNumPyで行列積をする。各プロセスのOpenBLASが16スレッドずつ立てるので、合計256スレッドが16コアを奪い合います。工場のたとえなら、16の工場が同じ16人の作業員を同時に呼び出している 状態で、移動時間だけが増えます。これをオーバーサブスクリプション(oversubscription、コア数を超えるスレッドの過剰配置)と呼びます。

判断基準はこうなります。

状況 設定 理由
単一プロセスで大きな行列積 未設定、または物理コア数 全員出勤が最速
multiprocessing、joblib、Gunicorn複数ワーカー OPENBLAS_NUM_THREADS=1 外側の並列に任せる
PyTorchの学習と同居 PyTorch側の set_num_threads に合わせる 2つの工場が作業員を取り合わない
# プロセス単位の設定。import numpy より前に効かせる必要がある
export OPENBLAS_NUM_THREADS=1
python train_worker.py

コードの途中だけ絞りたい場合は threadpoolctl.threadpool_limits(limits=1, user_api="blas") を with で囲むだけです。

PyTorchも同じ問題を抱えており、CPU上の行列積はOpenBLASまたはMKLに委ねられます。3行で確認と設定ができます。

import torch
print(torch.__config__.show())   # BLAS_INFO の行で何にリンクしているか分かる
torch.set_num_threads(4)         # OpenBLAS側の環境変数と合わせて設定する

計測環境が1コアのため、この節のスレッド数の効果は実測できていません。一次情報から設定の仕組みと判断基準を整理したものです。マルチコア環境なら OPENBLAS_NUM_THREADS を1、2、4、8と変えて本記事の2番目のスクリプトを回してみてください。


8. 決定③ — llama.cppのCPUビルドに GGML_BLAS を付けるべきか

前節までで、OpenBLASが効く条件は「行列が大きいこと」「作業員を奪い合わないこと」の2つだと分かりました。この2条件をLLM推論に当てると、答えがはっきり分かれます。

このセクションで分かること: llama.cppでBLASが効く工程と効かない工程。

llama.cppの公式ビルドドキュメントは、BLASの効果をこう限定しています。

Building the program with BLAS support may lead to some performance improvements in prompt processing using batch sizes higher than 32 (the default is 512). Using BLAS doesn't affect the generation performance.
(和訳:BLAS対応でビルドすると、バッチサイズが32より大きいプロンプト処理で性能が向上することがある。BLASは生成の性能には影響しない。)

これは本記事の実測とぴったり対応しています。

  • プロンプト処理 は、数百トークンをまとめて重みに掛ける 大きな行列積 です。前節までの条件を満たすのでOpenBLASが効きます。
  • トークン生成 は、1トークンずつ重みに掛ける 行列とベクトルの積、つまりLevel 2です。パレット運用の余地がなく、メモリ帯域で頭打ちになるのでBLASは効きません。
# Linux、OpenBLASが apt などで入っている前提
cmake -B build -DGGML_BLAS=ON -DGGML_BLAS_VENDOR=OpenBLAS
cmake --build build --config Release

判断はこうなります。長いシステムプロンプトやRAGの文脈を毎回流し込む用途なら付ける価値があり、短い問いかけに短く答えるチャット用途なら生成速度は変わらないので付けなくてよい、です。


トラブルシューティング

症状 原因 対処
np.show_config() に openblas が出ない condaのMKL版NumPyや、ディストリ版の参照BLASにリンクされている pip install numpy のwheelに切り替えるか、そのまま使う。MKLなら速度面の心配は不要
マルチプロセスにしたら全体が遅くなった オーバーサブスクリプション OPENBLAS_NUM_THREADS=1 を import前 に設定
OPENBLAS_NUM_THREADS を設定しても効かない OpenMPビルドのOpenBLASを使っている OMP_NUM_THREADS を代わりに設定
小行列のループが遅い 呼び出しオーバーヘッド支配 3次元配列に積んで1回の matmul に束ねる
マルチスレッドで稀に結果がおかしい 0.3.34で修正された競合状態の可能性 NumPyを更新し、同梱OpenBLASのバージョンを確認

用語集

用語 定義 工場のたとえ
BLAS ベクトル・行列の基本演算の関数規格 作業指示書の書式
netlib参照実装 BLASの公式かつ素朴な実装 教科書どおりの手作業工場
OpenBLAS GotoBLAS2 1.13を引き継いだ最適化実装 CPU別の専用機械を備えた量産工場
カーネル CPU世代ごとに手書きされた最内側ループ 専用の工作機械
DYNAMIC_ARCH 複数カーネルを同梱し実行時に選ぶビルド設定 現場の機械を見てラインを選ぶ
ブロッキング/パッキング 行列をキャッシュに収まる部分に切り詰め直す パレット1枚ぶんだけ作業台に載せる
GFLOPS 1秒あたりの浮動小数点演算回数、10億単位 1秒あたりの加工数
オーバーサブスクリプション コア数を超えるスレッドを立てること 複数工場が同じ作業員を奪い合う

学習ロードマップ

この記事は「CPU上の行列積の裏方」でした。次に読むと繋がる記事です。

  • 行列積そのものの仕組み → matmul
  • 同じ行列積をGPUで回すとどうなるか → GPU、CUDA
  • LLM推論で「生成がメモリ帯域で頭打ちになる」話 → KVキャッシュ、VRAM
  • CPU推論エンジンの実践 → llama.cpp、Ollama

まとめ

自分の三重ループが0.06 GFLOPSで、np.matmul が65 GFLOPSだったとき、私は「NumPyが速い」と思っていました。違いました。速いのはNumPyの下にいるOpenBLASで、さらにその下にいる、CPU世代ごとに手で書かれたカーネルと、キャッシュに合わせて部品を小分けする運び方でした。

計測して分かったことを3つに絞ると、こうです。

  1. 手元の1コアで、OpenBLASはBLAS不使用の 7倍から12倍、float32ならさらに 2倍。しかも行列が大きいほど差が開く
  2. 行列が 16以下 なら工場の搬入手続きが支配的で、束ねないと1万回で29倍損する
  3. スレッドは増やせば速いわけではなく、外側にプロセス並列があるなら 1に固定 するのが正解

一番意外だったのは、einsum と matmul の間に8倍もの壁があったことです。同じNumPyの、同じCで書かれた関数なのに。この壁の正体が「誰が最内側ループを書いたか」だと知って、私は以来、速度を語るときに必ず threadpool_info() の出力から始めるようになりました。

明日、あなたのNumPyが何を使っているか、1コマンドで確かめてみてください。


参考文献


記事の続報や検証の裏話はXで流しています。

Zenn

0
0
0

Register as a new user and use Qiita more conveniently

  1. You get articles that match your needs
  2. You can efficiently read back useful information
  3. You can use dark theme
What you can do with signing up
0
0

Delete article

Deleted articles cannot be recovered.

Draft of this article would be also deleted.

Are you sure you want to delete this article?