tensorstudio 1.5.1__tar.gz → 1.7.0__tar.gz

{tensorstudio-1.5.1 → tensorstudio-1.7.0}/CHANGELOG.md

@@ -2,6 +2,49 @@
 
 ## Unreleased
 
+## 1.7.0 - 2026-07-07
+
+- Completed the ordered Core Math Expansion roadmap section as one release
+  batch.
+- Added native C++ `logsumexp`, `softmax`, and `log_softmax` operations with
+  max-shifted stable numerics and autograd support.
+- Added native C++ batched matrix multiplication through `bmm` and 3D `@`
+  dispatch, including reverse-mode gradients for both operands.
+- Added native C++ `var`, `variance`, `std`, `all`, and `any` operations, plus
+  Tensor methods and top-level Python exports where appropriate.
+- Added Tensor-level `norm()` and expanded `tensorstudio.math` with
+  `logsumexp`, `softmax`, `log_softmax`, boolean reductions, and a documented
+  practical `einsum` subset.
+- Added seeded native random distributions: `uniform`, `normal`, `randint`,
+  and `bernoulli`, with Python `*_like` helpers where useful.
+- Switched neural-network functional softmax/log-softmax and cross entropy to
+  the native stable kernels.
+- Added NumPy parity and autograd tests for the expanded math surface.
+
+## 1.6.0 - 2026-07-07
+
+- Completed the ordered CPU Performance Core roadmap section as one release
+  batch.
+- Added optional CBLAS/Accelerate-backed `matmul` for contiguous `float32` and
+  `float64` matrices when the source build environment exposes a compatible
+  BLAS library and header; portable C++ kernels remain the fallback path.
+- Added a small native C++ CPU thread pool, configurable with
+  `tensorstudio.set_num_threads()` and `TENSORSTUDIO_NUM_THREADS`, and used it
+  for large contiguous elementwise ops, reductions, matrix multiplication,
+  convolution, and pooling forward kernels.
+- Added SIMD-friendly typed `float32`/`float64` contiguous kernels for common
+  elementwise arithmetic and activations, while preserving mixed-dtype fallback
+  behavior.
+- Added a bounded C++ storage reuse pool for tensor allocations, with
+  `TENSORSTUDIO_DISABLE_STORAGE_POOL=1` and
+  `TENSORSTUDIO_STORAGE_POOL_MAX_BLOCK_BYTES` controls.
+- Added `tensorstudio.performance_info()`, `get_num_threads()`, and
+  `set_num_threads()` diagnostics/configuration helpers.
+- Added benchmark threshold support via `benchmark_all.py --check-thresholds`
+  and `benchmarks/thresholds.json`.
+- Expanded performance, CPU backend, and platform docs for BLAS selection,
+  threading, storage reuse, benchmark thresholds, and honest interpretation.
+
 ## 1.5.1 - 2026-07-07
 
 - Completed the next ordered correctness-roadmap item with clearer native

{tensorstudio-1.5.1 → tensorstudio-1.7.0}/CMakeLists.txt

@@ -1,11 +1,13 @@
 cmake_minimum_required(VERSION 3.18)
 
-project(tensorstudio VERSION 1.5.1 LANGUAGES CXX)
+project(tensorstudio VERSION 1.7.0 LANGUAGES CXX)
 
 find_package(Python COMPONENTS Interpreter Development.Module REQUIRED)
 set(PYBIND11_FINDPYTHON ON)
 find_package(pybind11 CONFIG REQUIRED)
 
+option(TENSORSTUDIO_ENABLE_BLAS "Enable optional CBLAS-backed matmul when available" ON)
+
 set(TENSORSTUDIO_CORE_SOURCES
   src/core/tensor.cpp
   src/core/dtype.cpp
@@ -19,6 +21,7 @@ set(TENSORSTUDIO_CORE_SOURCES
   src/core/random.cpp
   src/core/serialization.cpp
   src/core/errors.cpp
+  src/core/perf.cpp
 )
 
 set(TENSORSTUDIO_BINDING_SOURCES
@@ -38,6 +41,20 @@ pybind11_add_module(_C MODULE
 target_include_directories(_C PRIVATE include src/bindings)
 target_compile_features(_C PRIVATE cxx_std_20)
 
+if(TENSORSTUDIO_ENABLE_BLAS)
+  find_package(BLAS)
+  if(BLAS_FOUND)
+    include(CheckIncludeFileCXX)
+    check_include_file_cxx(cblas.h TENSORSTUDIO_HAVE_CBLAS_H)
+    target_link_libraries(_C PRIVATE ${BLAS_LIBRARIES})
+    if(APPLE)
+      target_compile_definitions(_C PRIVATE TENSORSTUDIO_HAS_ACCELERATE=1)
+    elseif(TENSORSTUDIO_HAVE_CBLAS_H)
+      target_compile_definitions(_C PRIVATE TENSORSTUDIO_HAS_CBLAS=1)
+    endif()
+  endif()
+endif()
+
 if(MSVC)
   target_compile_options(_C PRIVATE /W4 /permissive-)
 else()

{tensorstudio-1.5.1 → tensorstudio-1.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: tensorstudio
-Version: 1.5.1
+Version: 1.7.0
 Summary: TensorStudio is a compact C++ tensor and autograd engine with a Python API for learning, experimentation, and lightweight ML workloads.
 Keywords: tensor,autograd,machine-learning,cpp,pybind11
 Author: TensorStudio contributors
@@ -71,8 +71,12 @@ Description-Content-Type: text/markdown
 TensorStudio is a compact C++ tensor and autograd engine with a Python API for
 learning, experimentation, and lightweight ML workloads.
 
-TensorStudio `1.5.1` is a CPU-only stable API foundation. It is eager-only,
-intentionally small, and not a replacement for mature ML frameworks.
+TensorStudio `1.7.0` is a CPU-only stable API foundation with native C++
+threading, storage reuse, SIMD-friendly typed kernels, and optional
+CBLAS/Accelerate matrix multiplication when available. It adds native stable
+softmax/logsumexp, batched matrix multiplication, statistical reductions,
+boolean reductions, and seeded random distributions. It is eager-only,
+intentionally compact, and not a replacement for mature ML frameworks.
 
 ## Install
 
@@ -163,12 +167,15 @@ a = ts.zeros((2, 3))
 b = ts.rand((2, 3))
 c = ts.eye(3)
 d = ts.linspace(0.0, 1.0, 5)
+labels = ts.randint((4,), low=0, high=3, seed=3)
+mask = ts.bernoulli((2, 3), probability=0.25, seed=5)
 
 print(a.shape, a.strides, a.device, a.is_contiguous)
 print((b.clamp(0.2, 0.8) + 1).mean().item())
 print(b.sum(axis=1).tolist())
 print(ts.concat([b, b], axis=0).shape, b.astype("float64").dtype)
 print(c.tolist(), d.tolist())
+print(labels.tolist(), mask.any(axis=1).tolist())
 print(ts.zeros_like(b).shape, ts.randn_like(b, seed=11).dtype)
 ```
 
@@ -197,14 +204,29 @@ print(loss.item())
 print(x.grad.tolist())
 ```
 
-Higher-level helpers live in `tensorstudio.math`:
+Stable reductions and normalized probabilities are available as Tensor methods,
+functional ops, and `tensorstudio.math` helpers:
 
 ```python
-values = ts.tensor([[1.0, 2.0], [3.0, 4.0]])
+values = ts.tensor([[1000.0, 1001.0, 999.0], [1.0, 2.0, 3.0]])
 
 print(ts.math.variance(values).item())
 print(ts.math.std(values, axis=0).tolist())
 print(ts.math.norm(values, ord=2).item())
+print(values.softmax(axis=1).tolist())
+print(ts.logsumexp(values, axis=1).tolist())
+```
+
+Batched matrix multiplication and a small documented `einsum` subset cover
+common model and scientific-programming patterns:
+
+```python
+left = ts.randn((2, 3, 4), seed=1)
+right = ts.randn((2, 4, 5), seed=2)
+
+print((left @ right).shape)
+print(ts.bmm(left, right).shape)
+print(ts.einsum("bij,bjk->bik", left, right).shape)
 ```
 
 ## Autograd
@@ -344,31 +366,46 @@ python benchmarks/benchmark_report.py
 columns for NumPy, TensorFlow, PyTorch, and JAX when those libraries are
 available locally.
 
-On one Windows CPython 3.10 development run reporting `1.2.0`, TensorStudio
-beat NumPy on 26 small operation benchmark cases and lost on 77
-NumPy-comparable cases. Against PyTorch CPU `2.12.1+cpu`, TensorStudio won 75
-local cases and lost 33. The strongest local wins were small eager operations,
-small contiguous axis reductions, and the simple NumPy convolution/pooling
-references where framework dispatch or Python loops dominate; larger matrix
-multiplication, PyTorch convolution and pooling, larger axis reductions, larger
-transcendental activations, and larger autograd workloads remain faster in
-PyTorch and NumPy.
+Useful runtime diagnostics:
+
+```python
+import tensorstudio as ts
+
+print(ts.performance_info())
+ts.set_num_threads(4)
+```
+
+Run the loose local regression thresholds with:
+
+```bash
+python benchmark_all.py --check-thresholds
+```
+
+On one Windows CPython 3.10 development run reporting `1.7.0`, with
+TensorStudio threads enabled, storage pooling enabled, SSE2 autovectorization
+reported, and no BLAS provider found, TensorStudio beat NumPy on 7 local
+benchmark cases and lost on 96 NumPy-comparable cases. JAX CPU dispatch was
+available on that machine; TensorStudio won 45 local cases and lost 53. The
+strongest local wins were the simple NumPy convolution/pooling reference loops
+and some small JAX-dispatch-heavy eager cases. NumPy and JAX were faster for
+many elementwise, reduction, matrix multiplication, larger activation, and
+autograd workloads.
 See `benchmarks/results.md` for the full table, platform details, and exact
 timings.
 
 Snapshot from that local run:
 
-| operation | shape | TensorStudio | NumPy | PyTorch CPU | TS vs NumPy | TS vs PyTorch |
+| operation | shape | TensorStudio | NumPy | JAX CPU dispatch | TS vs NumPy | TS vs JAX |
 |---|---:|---:|---:|---:|---:|---:|
-| `sigmoid` | `(32,)` | 0.0017 ms | 0.0038 ms | 0.0614 ms | 2.1691x | 35.3154x |
-| `mean` | `(32,)` | 0.0029 ms | 0.0131 ms | 0.0186 ms | 4.5638x | 6.4709x |
-| `sum_axis1` | `(16, 16)` | 0.0027 ms | 0.0029 ms | 0.0085 ms | 1.0894x | 3.1408x |
-| `chain_relu` | `(128,)` | 0.0112 ms | 0.0051 ms | 0.0726 ms | 0.4575x | 6.4533x |
-| `matmul` | `(256, 256)` | 4.4121 ms | 0.3779 ms | 0.1669 ms | 0.0856x | 0.0378x |
-| `conv2d_3x3_padding1` | `(1, 1, 8, 8)` | 0.2374 ms | 1.7112 ms | 0.0186 ms | 7.2091x | 0.0784x |
-| `max_pool2d_2x2` | `(1, 1, 16, 16)` | 0.0237 ms | 0.2764 ms | 0.0082 ms | 11.6685x | 0.3462x |
-| `avg_pool2d_2x2` | `(1, 1, 16, 16)` | 0.0198 ms | 0.7431 ms | 0.0073 ms | 37.4930x | 0.3662x |
-| `elementwise_backward` | `(1024,)` | 3.0196 ms | n/a | 0.2254 ms | n/a | 0.0746x |
+| `sigmoid` | `(32,)` | 0.0152 ms | 0.0044 ms | 0.0727 ms | 0.2909x | 4.7701x |
+| `mean` | `(32,)` | 0.0177 ms | 0.0083 ms | 0.0113 ms | 0.4715x | 0.6400x |
+| `sum_axis1` | `(16, 16)` | 0.0163 ms | 0.0031 ms | 0.0123 ms | 0.1901x | 0.7536x |
+| `chain_relu` | `(128,)` | 0.0867 ms | 0.0062 ms | 0.0923 ms | 0.0721x | 1.0641x |
+| `matmul` | `(256, 256)` | 2.2252 ms | 0.4754 ms | 0.2750 ms | 0.2136x | 0.1236x |
+| `conv2d_3x3_padding1` | `(1, 1, 8, 8)` | 0.1915 ms | 1.2845 ms | 0.1081 ms | 6.7064x | 0.5646x |
+| `max_pool2d_2x2` | `(1, 1, 16, 16)` | 0.0277 ms | 0.1577 ms | n/a | 5.7024x | n/a |
+| `avg_pool2d_2x2` | `(1, 1, 16, 16)` | 0.0278 ms | 0.5538 ms | n/a | 19.8919x | n/a |
+| `elementwise_backward` | `(1024,)` | 2.7344 ms | n/a | n/a | n/a | n/a |
 
 Speedup is `competitor median / TensorStudio median`, so values above `1.0x`
 favor TensorStudio.
@@ -465,7 +502,9 @@ tokens or print secrets.
 - CPU backend only.
 - Eager execution only.
 - No CUDA or Metal backend yet.
-- No BLAS-backed matrix multiplication yet.
+- Optional BLAS-backed matrix multiplication depends on the build environment
+  exposing a compatible CBLAS/Accelerate interface; otherwise TensorStudio uses
+  a portable C++ fallback.
 - No graph compiler or distributed runtime.
 - Convolution and pooling support are currently limited to CPU NCHW
   `conv2d`, `max_pool2d`, and `avg_pool2d` style workloads.
@@ -495,9 +534,9 @@ tokens or print secrets.
 - Richer dataset utilities
 - Model zoo examples
 - ONNX import and broader export coverage
-- Improved memory allocator
-- SIMD kernels
-- Multithreaded ops
+- Runtime-dispatched SIMD kernels
+- Better non-BLAS matrix multiplication tiling
+- More threaded backward kernels
 
 ## License
 

{tensorstudio-1.5.1 → tensorstudio-1.7.0}/README.md

@@ -7,8 +7,12 @@
 TensorStudio is a compact C++ tensor and autograd engine with a Python API for
 learning, experimentation, and lightweight ML workloads.
 
-TensorStudio `1.5.1` is a CPU-only stable API foundation. It is eager-only,
-intentionally small, and not a replacement for mature ML frameworks.
+TensorStudio `1.7.0` is a CPU-only stable API foundation with native C++
+threading, storage reuse, SIMD-friendly typed kernels, and optional
+CBLAS/Accelerate matrix multiplication when available. It adds native stable
+softmax/logsumexp, batched matrix multiplication, statistical reductions,
+boolean reductions, and seeded random distributions. It is eager-only,
+intentionally compact, and not a replacement for mature ML frameworks.
 
 ## Install
 
@@ -99,12 +103,15 @@ a = ts.zeros((2, 3))
 b = ts.rand((2, 3))
 c = ts.eye(3)
 d = ts.linspace(0.0, 1.0, 5)
+labels = ts.randint((4,), low=0, high=3, seed=3)
+mask = ts.bernoulli((2, 3), probability=0.25, seed=5)
 
 print(a.shape, a.strides, a.device, a.is_contiguous)
 print((b.clamp(0.2, 0.8) + 1).mean().item())
 print(b.sum(axis=1).tolist())
 print(ts.concat([b, b], axis=0).shape, b.astype("float64").dtype)
 print(c.tolist(), d.tolist())
+print(labels.tolist(), mask.any(axis=1).tolist())
 print(ts.zeros_like(b).shape, ts.randn_like(b, seed=11).dtype)
 ```
 
@@ -133,14 +140,29 @@ print(loss.item())
 print(x.grad.tolist())
 ```
 
-Higher-level helpers live in `tensorstudio.math`:
+Stable reductions and normalized probabilities are available as Tensor methods,
+functional ops, and `tensorstudio.math` helpers:
 
 ```python
-values = ts.tensor([[1.0, 2.0], [3.0, 4.0]])
+values = ts.tensor([[1000.0, 1001.0, 999.0], [1.0, 2.0, 3.0]])
 
 print(ts.math.variance(values).item())
 print(ts.math.std(values, axis=0).tolist())
 print(ts.math.norm(values, ord=2).item())
+print(values.softmax(axis=1).tolist())
+print(ts.logsumexp(values, axis=1).tolist())
+```
+
+Batched matrix multiplication and a small documented `einsum` subset cover
+common model and scientific-programming patterns:
+
+```python
+left = ts.randn((2, 3, 4), seed=1)
+right = ts.randn((2, 4, 5), seed=2)
+
+print((left @ right).shape)
+print(ts.bmm(left, right).shape)
+print(ts.einsum("bij,bjk->bik", left, right).shape)
 ```
 
 ## Autograd
@@ -280,31 +302,46 @@ python benchmarks/benchmark_report.py
 columns for NumPy, TensorFlow, PyTorch, and JAX when those libraries are
 available locally.
 
-On one Windows CPython 3.10 development run reporting `1.2.0`, TensorStudio
-beat NumPy on 26 small operation benchmark cases and lost on 77
-NumPy-comparable cases. Against PyTorch CPU `2.12.1+cpu`, TensorStudio won 75
-local cases and lost 33. The strongest local wins were small eager operations,
-small contiguous axis reductions, and the simple NumPy convolution/pooling
-references where framework dispatch or Python loops dominate; larger matrix
-multiplication, PyTorch convolution and pooling, larger axis reductions, larger
-transcendental activations, and larger autograd workloads remain faster in
-PyTorch and NumPy.
+Useful runtime diagnostics:
+
+```python
+import tensorstudio as ts
+
+print(ts.performance_info())
+ts.set_num_threads(4)
+```
+
+Run the loose local regression thresholds with:
+
+```bash
+python benchmark_all.py --check-thresholds
+```
+
+On one Windows CPython 3.10 development run reporting `1.7.0`, with
+TensorStudio threads enabled, storage pooling enabled, SSE2 autovectorization
+reported, and no BLAS provider found, TensorStudio beat NumPy on 7 local
+benchmark cases and lost on 96 NumPy-comparable cases. JAX CPU dispatch was
+available on that machine; TensorStudio won 45 local cases and lost 53. The
+strongest local wins were the simple NumPy convolution/pooling reference loops
+and some small JAX-dispatch-heavy eager cases. NumPy and JAX were faster for
+many elementwise, reduction, matrix multiplication, larger activation, and
+autograd workloads.
 See `benchmarks/results.md` for the full table, platform details, and exact
 timings.
 
 Snapshot from that local run:
 
-| operation | shape | TensorStudio | NumPy | PyTorch CPU | TS vs NumPy | TS vs PyTorch |
+| operation | shape | TensorStudio | NumPy | JAX CPU dispatch | TS vs NumPy | TS vs JAX |
 |---|---:|---:|---:|---:|---:|---:|
-| `sigmoid` | `(32,)` | 0.0017 ms | 0.0038 ms | 0.0614 ms | 2.1691x | 35.3154x |
-| `mean` | `(32,)` | 0.0029 ms | 0.0131 ms | 0.0186 ms | 4.5638x | 6.4709x |
-| `sum_axis1` | `(16, 16)` | 0.0027 ms | 0.0029 ms | 0.0085 ms | 1.0894x | 3.1408x |
-| `chain_relu` | `(128,)` | 0.0112 ms | 0.0051 ms | 0.0726 ms | 0.4575x | 6.4533x |
-| `matmul` | `(256, 256)` | 4.4121 ms | 0.3779 ms | 0.1669 ms | 0.0856x | 0.0378x |
-| `conv2d_3x3_padding1` | `(1, 1, 8, 8)` | 0.2374 ms | 1.7112 ms | 0.0186 ms | 7.2091x | 0.0784x |
-| `max_pool2d_2x2` | `(1, 1, 16, 16)` | 0.0237 ms | 0.2764 ms | 0.0082 ms | 11.6685x | 0.3462x |
-| `avg_pool2d_2x2` | `(1, 1, 16, 16)` | 0.0198 ms | 0.7431 ms | 0.0073 ms | 37.4930x | 0.3662x |
-| `elementwise_backward` | `(1024,)` | 3.0196 ms | n/a | 0.2254 ms | n/a | 0.0746x |
+| `sigmoid` | `(32,)` | 0.0152 ms | 0.0044 ms | 0.0727 ms | 0.2909x | 4.7701x |
+| `mean` | `(32,)` | 0.0177 ms | 0.0083 ms | 0.0113 ms | 0.4715x | 0.6400x |
+| `sum_axis1` | `(16, 16)` | 0.0163 ms | 0.0031 ms | 0.0123 ms | 0.1901x | 0.7536x |
+| `chain_relu` | `(128,)` | 0.0867 ms | 0.0062 ms | 0.0923 ms | 0.0721x | 1.0641x |
+| `matmul` | `(256, 256)` | 2.2252 ms | 0.4754 ms | 0.2750 ms | 0.2136x | 0.1236x |
+| `conv2d_3x3_padding1` | `(1, 1, 8, 8)` | 0.1915 ms | 1.2845 ms | 0.1081 ms | 6.7064x | 0.5646x |
+| `max_pool2d_2x2` | `(1, 1, 16, 16)` | 0.0277 ms | 0.1577 ms | n/a | 5.7024x | n/a |
+| `avg_pool2d_2x2` | `(1, 1, 16, 16)` | 0.0278 ms | 0.5538 ms | n/a | 19.8919x | n/a |
+| `elementwise_backward` | `(1024,)` | 2.7344 ms | n/a | n/a | n/a | n/a |
 
 Speedup is `competitor median / TensorStudio median`, so values above `1.0x`
 favor TensorStudio.
@@ -401,7 +438,9 @@ tokens or print secrets.
 - CPU backend only.
 - Eager execution only.
 - No CUDA or Metal backend yet.
-- No BLAS-backed matrix multiplication yet.
+- Optional BLAS-backed matrix multiplication depends on the build environment
+  exposing a compatible CBLAS/Accelerate interface; otherwise TensorStudio uses
+  a portable C++ fallback.
 - No graph compiler or distributed runtime.
 - Convolution and pooling support are currently limited to CPU NCHW
   `conv2d`, `max_pool2d`, and `avg_pool2d` style workloads.
@@ -431,9 +470,9 @@ tokens or print secrets.
 - Richer dataset utilities
 - Model zoo examples
 - ONNX import and broader export coverage
-- Improved memory allocator
-- SIMD kernels
-- Multithreaded ops
+- Runtime-dispatched SIMD kernels
+- Better non-BLAS matrix multiplication tiling
+- More threaded backward kernels
 
 ## License
 

{tensorstudio-1.5.1 → tensorstudio-1.7.0}/benchmark_all.py

@@ -3,7 +3,13 @@ from __future__ import annotations
 import argparse
 from pathlib import Path
 
-from benchmarks.benchmark_report import run_benchmarks
+from benchmarks.benchmark_report import (
+    evaluate_thresholds,
+    load_thresholds,
+    render_benchmark_report,
+    run_benchmark_data,
+    write_benchmark_report,
+)
 
 ALL_SECTIONS = {
     "elementwise",
@@ -36,14 +42,36 @@ def main() -> None:
         action="store_true",
         help="Print the full Markdown report after writing it.",
     )
+    parser.add_argument(
+        "--thresholds",
+        type=Path,
+        default=Path("benchmarks") / "thresholds.json",
+        help="Benchmark regression threshold file.",
+    )
+    parser.add_argument(
+        "--check-thresholds",
+        action="store_true",
+        help="Fail if TensorStudio median benchmark times exceed thresholds.",
+    )
     args = parser.parse_args()
 
     selected_sections = set(args.section or ALL_SECTIONS)
-    report = run_benchmarks(selected_sections, args.output)
+    cases, libraries, results = run_benchmark_data(selected_sections)
+    report = render_benchmark_report(cases, libraries, results)
+    write_benchmark_report(report, args.output)
     if args.print:
         print(report)
     else:
         print(f"Wrote benchmark report to {args.output}")
+    if args.check_thresholds:
+        thresholds = load_thresholds(args.thresholds)
+        failures = evaluate_thresholds(thresholds, results)
+        if failures:
+            print("Benchmark threshold failures:")
+            for failure in failures:
+                print(f"- {failure}")
+            raise SystemExit(1)
+        print(f"Benchmark thresholds passed using {args.thresholds}")
 
 
 if __name__ == "__main__":

{tensorstudio-1.5.1 → tensorstudio-1.7.0}/benchmarks/benchmark_report.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import argparse
 import importlib
 import io
+import json
 import os
 import platform
 import statistics
@@ -794,6 +795,12 @@ def _render_report(
     lines.append(f"- Processor: `{platform.processor() or 'unknown'}`")
     lines.append(f"- Python: `{sys.version.split()[0]}`")
     lines.append(f"- TensorStudio: `{ts.__version__}`")
+    with suppress(Exception):
+        perf_info = ts.performance_info()
+        lines.append(f"- TensorStudio threads: `{perf_info['num_threads']}`")
+        lines.append(f"- TensorStudio BLAS enabled: `{perf_info['blas_enabled']}`")
+        lines.append(f"- TensorStudio SIMD level: `{perf_info['simd_level']}`")
+        lines.append(f"- TensorStudio storage pool enabled: `{perf_info['storage_pool_enabled']}`")
     lines.append(f"- NumPy: `{np.__version__}`")
     for library in libraries:
         if library.name in {"TensorStudio", "NumPy"}:
@@ -925,14 +932,55 @@ def _render_report(
     return "\n".join(lines)
 
 
-def run_benchmarks(sections: set[str], output: Path | None) -> str:
+def run_benchmark_data(
+    sections: set[str],
+) -> tuple[list[BenchmarkCase], list[Library], dict[str, Stats]]:
     libraries = _load_libraries()
     cases = _build_cases(sections)
     results = _run_cases(cases, libraries)
-    report = _render_report(cases, libraries, results)
+    return cases, libraries, results
+
+
+def render_benchmark_report(
+    cases: list[BenchmarkCase],
+    libraries: list[Library],
+    results: dict[str, Stats],
+) -> str:
+    return _render_report(cases, libraries, results)
+
+
+def write_benchmark_report(report: str, output: Path | None) -> None:
     if output is not None:
         output.parent.mkdir(parents=True, exist_ok=True)
         output.write_text(report, encoding="utf-8")
+
+
+def load_thresholds(path: Path) -> dict[str, Any]:
+    return json.loads(path.read_text(encoding="utf-8"))
+
+
+def evaluate_thresholds(thresholds: dict[str, Any], results: dict[str, Stats]) -> list[str]:
+    failures: list[str] = []
+    for item in thresholds.get("cases", []):
+        category = str(item["category"])
+        operation = str(item["operation"])
+        shape = str(item["shape"])
+        max_ms = float(item["max_median_ms"])
+        key = f"{category}|{operation}|{shape}|TensorStudio"
+        stats = results.get(key)
+        label = f"{category}/{operation}/{shape}"
+        if stats is None:
+            failures.append(f"{label}: no TensorStudio benchmark result was recorded")
+            continue
+        if stats.median_ms > max_ms:
+            failures.append(f"{label}: median {stats.median_ms:.4f} ms exceeded {max_ms:.4f} ms")
+    return failures
+
+
+def run_benchmarks(sections: set[str], output: Path | None) -> str:
+    cases, libraries, results = run_benchmark_data(sections)
+    report = _render_report(cases, libraries, results)
+    write_benchmark_report(report, output)
     return report