pycauset 0.6.2.dev5__tar.gz → 0.6.2.dev9__tar.gz

{pycauset-0.6.2.dev5 → pycauset-0.6.2.dev9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: pycauset
-Version: 0.6.2.dev5
+Version: 0.6.2.dev9
 Summary: High-performance Causal Set matrix operations using memory-mapped files
 Author: Bror Hjemgaard
 License: MIT

pycauset-0.6.2.dev9/documentation/dev/R2_PERF_FINDINGS.md

@@ -0,0 +1,71 @@
+# R2_PERF — parity findings (R2.2)
+
+Measured with `python benchmarks/r2_parity.py` (dense float64, n=1024 matrices,
+best-of-3, PyCauset result forced through `np.asarray`; `invert`/`determinant`
+clear their derived caches before timing so both sides recompute). The ratio is
+`numpy_time / pycauset_time`; the R2_PERF bar is **≥ 0.90×**.
+
+Current state (threaded DYNAMIC_ARCH OpenBLAS, `OPENBLAS_NUM_THREADS=8` default,
+GEMM bumps to 20 threads internally):
+
+| op | ratio | verdict |
+| :-- | --: | :-- |
+| add | ~1.1–1.2× | PASS |
+| solve | ~0.96× | PASS |
+| invert | ~1.1× | PASS |
+| dot | ~2× | PASS |
+| multiply | ~0.93× | PASS (marginal) |
+| determinant | ~1.24× | PASS |
+| eigh | ~0.98× | PASS |
+| matmul | ~0.87× | FAIL (marginal) |
+
+7/8 ops are at or above parity. `matmul` hovers just under 0.90× (~0.0071 s vs
+NumPy ~0.0063 s) and `multiply` just above it (~0.93×); both flap across the 0.90
+line run-to-run (CPU frequency/thermal noise).
+
+## What landed in R2.2
+
+1. **`determinant` → LAPACK** — `CpuSolver::determinant` uses `LAPACKE_dgetrf`/
+   `zgetrf` (NumPy's own backend) instead of Eigen's single-threaded `PartialPivLU`.
+2. **Fair `invert`/`determinant` benchmarking** — the benchmark clears the derived
+   caches (`_invalidate_cached_derived`) before timing.
+3. **`add` flakiness root-caused** — a stale installed wheel merged into a namespace
+   package and `import_native_extension()` used `next(iter(pkg.__path__))` (filesystem-
+   dependent order on Windows), so ~50% of processes loaded a stale `_pycauset.pyd`.
+   Fixed by loading from the package's `__file__` directory (`native.py`).
+4. **AVX2 f64 sub/mul/div kernels + full-span hardening** — elementwise `subtract`/
+   `multiply`/`divide` now route through AVX2 with strict full-span guards.
+5. **`matmul` OpenBLAS rebuilt** — the CMake fallback downloaded a *generic single-core*
+   0.3.26 binary; rebuilt 0.3.28 with `DYNAMIC_ARCH=1 USE_THREAD=1` (Haswell kernels),
+   relinked, and bundled the MinGW runtime DLLs. `build_openblas.ps1` documents it.
+6. **`OPENBLAS_NUM_THREADS` default 8** — the threaded OpenBLAS uses one pool for BLAS
+   and LAPACK; 20 threads regresses small LAPACK (invert/determinant) via SMP sync
+   overhead, so `pycauset` pins 8 at import and the matmul GEMM temporarily bumps to 20.
+
+## The two memory/perf root fixes (biggest wins)
+
+- **`:memory:` backing switched to `VirtualAlloc`** (`MemoryMapper`) instead of a
+  pagefile-backed section (`CreateFileMappingA(INVALID_HANDLE_VALUE)`). The pagefile
+  path commits a page from the paging file on every first write, costing several ms
+  per 8MB result and dominating small elementwise ops. This single change took
+  `add` 0.88× → ~1.1× and `multiply` 0.72× → ~0.93×.
+- **CPU dgemm no longer pins operands** (`CpuSolver::attempt_direct_path`) — `VirtualLock`
+  is a GPU-DMA optimization and pure overhead for CPU `dgemm`.
+
+## Remaining gap: `matmul` (~0.87×)
+
+The raw `cblas_dgemm` is already **faster than NumPy** (0.0044 s vs NumPy's 0.0060 s
+at the same 20 threads). The residual is per-call wrapper cost on top of the kernel:
+
+| component | time |
+| :-- | --: |
+| raw `cblas_dgemm` (warm buffer, 20 threads) | ~0.0044 s |
+| fresh 8MB result (VirtualAlloc + first-write faults) | ~1.6 ms |
+| C++ `create_matrix` + MemoryGovernor + dispatch | ~0.4 ms |
+| Python `_ops.matmul` (IO planning, streaming checks, inline imports) | ~0.7 ms |
+| **total** | **~0.0071 s** |
+
+NumPy's `@` skips most of the Python/IO-planning layer. Fully closing the 0.03× gap
+means trimming the Python `_ops.matmul` IO-planning/inline-import path (or routing the
+native `matmul` through the eager operator), which trades away the streaming/observability
+layer for the hot dense case. Tracked against `R2_PERF` in `R2_ROADMAP.md`.

{pycauset-0.6.2.dev5 → pycauset-0.6.2.dev9}/documentation/project/plans/R2_ROADMAP.md

@@ -507,7 +507,7 @@ DoD: zero undocumented public API; zero untested public behavior; every node's i
 
 ### R2_PERF — NumPy Parity (≥ 0.90×)
 
-Status: - [ ] (in progress: a canonical `benchmarks/r2_parity.py` gate landed; current baseline (n=1024) — `solve` 0.96×, `eigh` 0.98×, `dot` 2.13× at parity; `matmul` 0.66×, `add` 0.09×, `multiply` 0.84× below parity. Verified `matmul` hits OpenBLAS `cblas_dgemm` (not a naive loop); measured the residual is a **bundled-OpenBLAS build/tuning difference** vs NumPy's OpenBLAS (same thread count, still ~1.66× slower) — fixable only by rebuilding the bundled OpenBLAS. `add` is the lazy-materialization gap (reverted a routing fix that overran — see R2_CPU). See `documentation/dev/R2_PERF_FINDINGS.md`)
+Status: - [ ] (in progress: `benchmarks/r2_parity.py` gate landed; current baseline (n=1024) — **7/8 at parity** (`add` ~1.1×, `solve` ~0.96×, `invert` ~1.1×, `dot` ~2×, `multiply` ~0.93×, `determinant` ~1.24×, `eigh` ~0.98×). `matmul` hovers just under the bar (~0.87×): the raw `cblas_dgemm` is already faster than NumPy (0.0044s vs 0.0060s at 20 threads), the residual is per-call wrapper cost (fresh-result VirtualAlloc + `create_matrix`/MemoryGovernor + Python IO-planning). Landed in R2.2: (1) LAPACK determinant, (2) fair invert/determinant cache-clearing in the benchmark, (3) add-flakiness root-cause (stale-binary namespace merge — `native.py` now loads from `__file__`), (4) AVX2 f64 sub/mul/div + full-span hardening, (5) OpenBLAS 0.3.28 rebuilt DYNAMIC_ARCH+threaded, (6) `:memory:` backing switched to `VirtualAlloc` (the add/multiply win), (7) CPU dgemm no longer pins operands, (8) GEMM bumps to 20 threads. See `documentation/dev/R2_PERF_FINDINGS.md`)
 
 Goal: every op is at least 0.90× NumPy throughput in the regimes PyCauset claims, or is an
 explicitly-documented out-of-scope case / performance bug. Per-op status lives in

{pycauset-0.6.2.dev5 → pycauset-0.6.2.dev9}/python/pycauset/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.6.2.dev5'
-__version_tuple__ = version_tuple = (0, 6, 2, 'dev5')
+__version__ = version = '0.6.2.dev9'
+__version_tuple__ = version_tuple = (0, 6, 2, 'dev9')
 
-__commit_id__ = commit_id = 'gcb2153da7'
+__commit_id__ = commit_id = 'g6e4c13b57'

{pycauset-0.6.2.dev5 → pycauset-0.6.2.dev9}/src/compute/cpu/CpuSolver.cpp

@@ -525,71 +525,62 @@ namespace {
             const uint64_t b_elems = b_dense->base_rows() * b_dense->base_cols();
             const uint64_t c_elems = c_dense->base_rows() * c_dense->base_cols();
             const size_t total_bytes = static_cast<size_t>(a_elems + b_elems + c_elems) * sizeof(T);
-            
+
             auto& governor = pycauset::core::MemoryGovernor::instance();
-            
-            // Check 1: Does it fit in RAM? (Anti-Nanny Logic)
-            // Check 2: Do we have enough Pinned Memory Budget?
-            if (governor.should_use_direct_path(total_bytes) && governor.try_pin_memory(total_bytes)) {
-                // Attempt to pin all three matrices
-                bool pinned = true;
-                // We use const_cast because pinning is a logical const operation (doesn't change data)
-                // but might change internal OS handles.
-                pinned &= const_cast<DenseMatrix<T>*>(a_dense)->pin_range(0, a_elems);
-                pinned &= const_cast<DenseMatrix<T>*>(b_dense)->pin_range(0, b_elems);
-                pinned &= c_dense->pin_range(0, c_elems);
-                
-                if (pinned) {
-                    const T* a_data = a_dense->data() + (a_dense->row_offset() * a_dense->base_cols() + a_dense->col_offset());
-                    const T* b_data = b_dense->data() + (b_dense->row_offset() * b_dense->base_cols() + b_dense->col_offset());
-                    T* c_data = c_dense->data() + (c_dense->row_offset() * c_dense->base_cols() + c_dense->col_offset());
-                    
-                    bool t_a = a_dense->is_transposed();
-                    bool t_b = b_dense->is_transposed();
-
-                    const int M = static_cast<int>(a_dense->rows());
-                    const int N = static_cast<int>(b_dense->cols());
-                    const int K = static_cast<int>(a_dense->cols());
-                    const int lda = static_cast<int>(a_dense->base_cols());
-                    const int ldb = static_cast<int>(b_dense->base_cols());
-                    const int ldc = static_cast<int>(c_dense->base_cols());
-                    
-                    if constexpr (std::is_same_v<T, double>) {
-                        cblas_dgemm(
-                            CblasRowMajor,
-                            t_a ? CblasTrans : CblasNoTrans,
-                            t_b ? CblasTrans : CblasNoTrans,
-                            M, N, K,
-                            1.0, a_data, lda,
-                            b_data, ldb,
-                            0.0, c_data, ldc
-                        );
-                    } else {
-                        cblas_sgemm(
-                            CblasRowMajor,
-                            t_a ? CblasTrans : CblasNoTrans,
-                            t_b ? CblasTrans : CblasNoTrans,
-                            M, N, K,
-                            1.0f, a_data, lda,
-                            b_data, ldb,
-                            0.0f, c_data, ldc
-                        );
-                    }
-                    
-                    // Cleanup
-                    // Unpinning is important to release the "locked" status
-                    const_cast<DenseMatrix<T>*>(a_dense)->unpin_range(0, a_elems);
-                    const_cast<DenseMatrix<T>*>(b_dense)->unpin_range(0, b_elems);
-                    c_dense->unpin_range(0, c_elems);
-                    
-                    governor.unpin_memory(total_bytes);
-                    
-                    c_dense->set_scalar(a_dense->get_scalar() * b_dense->get_scalar());
-                    return true;
+
+            // Check: does the operation fit in RAM? (Anti-Nanny Logic). When it
+            // does, call BLAS directly. We intentionally do NOT pin the operands
+            // (VirtualLock): pinning is a GPU-DMA optimization (R1_GPU) and is pure
+            // overhead for CPU dgemm — it added ~1-2ms per call at n=1024 and was
+            // the dominant residual in the matmul parity gap.
+            if (governor.should_use_direct_path(total_bytes)) {
+                const T* a_data = a_dense->data() + (a_dense->row_offset() * a_dense->base_cols() + a_dense->col_offset());
+                const T* b_data = b_dense->data() + (b_dense->row_offset() * b_dense->base_cols() + b_dense->col_offset());
+                T* c_data = c_dense->data() + (c_dense->row_offset() * c_dense->base_cols() + c_dense->col_offset());
+
+                bool t_a = a_dense->is_transposed();
+                bool t_b = b_dense->is_transposed();
+
+                const int M = static_cast<int>(a_dense->rows());
+                const int N = static_cast<int>(b_dense->cols());
+                const int K = static_cast<int>(a_dense->cols());
+                const int lda = static_cast<int>(a_dense->base_cols());
+                const int ldb = static_cast<int>(b_dense->base_cols());
+                const int ldc = static_cast<int>(c_dense->base_cols());
+
+                if constexpr (std::is_same_v<T, double>) {
+                    // GEMM scales well with threads, while small LAPACK
+                    // factorizations (invert/determinant) do not, so we keep the
+                    // global OpenBLAS default low (8) and bump it here only for
+                    // the matmul GEMM, then restore. (Assumes single-threaded
+                    // dispatch; the thread-safety of the global OpenBLAS count is
+                    // tracked separately under R2_HARDEN.)
+                    const int prev_threads = openblas_get_num_threads();
+                    openblas_set_num_threads(20);
+                    cblas_dgemm(
+                        CblasRowMajor,
+                        t_a ? CblasTrans : CblasNoTrans,
+                        t_b ? CblasTrans : CblasNoTrans,
+                        M, N, K,
+                        1.0, a_data, lda,
+                        b_data, ldb,
+                        0.0, c_data, ldc
+                    );
+                    openblas_set_num_threads(prev_threads);
                 } else {
-                    // Pinning failed (OS limit?), release budget and fall back
-                    governor.unpin_memory(total_bytes);
+                    cblas_sgemm(
+                        CblasRowMajor,
+                        t_a ? CblasTrans : CblasNoTrans,
+                        t_b ? CblasTrans : CblasNoTrans,
+                        M, N, K,
+                        1.0f, a_data, lda,
+                        b_data, ldb,
+                        0.0f, c_data, ldc
+                    );
                 }
+
+                c_dense->set_scalar(a_dense->get_scalar() * b_dense->get_scalar());
+                return true;
             }
         }
         return false;

{pycauset-0.6.2.dev5 → pycauset-0.6.2.dev9}/src/core/MemoryMapper.cpp

@@ -244,6 +244,22 @@ void MemoryMapper::open_file(bool create_new) {
         return;
     }
 
+    // Anonymous (:memory:) storage: allocate with VirtualAlloc instead of a
+    // pagefile-backed section (CreateFileMappingA(INVALID_HANDLE_VALUE)). The
+    // pagefile-backed path commits a page from the paging file on every first
+    // write, which costs several ms for an 8MB result and dominates small
+    // elementwise ops (add/multiply). VirtualAlloc gives fast anonymous commit
+    // (the same class as malloc), closing most of the gap vs NumPy.
+    if (hFile_ == INVALID_HANDLE_VALUE) {
+        base_ptr_ = VirtualAlloc(NULL, map_size, MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE);
+        if (base_ptr_ == NULL) {
+            throw std::runtime_error("Failed to allocate anonymous memory (VirtualAlloc)");
+        }
+        hMapping_ = NULL;
+        mapped_ptr_ = static_cast<char*>(base_ptr_) + adjustment;
+        return;
+    }
+
     hMapping_ = CreateFileMappingA(
         hFile_,
         NULL,
@@ -292,6 +308,9 @@ void MemoryMapper::close_file() {
         // Check if it was pinned memory
         if (is_pinned_) {
             pycauset::ComputeContext::instance().free_pinned(base_ptr_);
+        } else if (hMapping_ == NULL) {
+            // Anonymous (:memory:) storage allocated with VirtualAlloc.
+            VirtualFree(base_ptr_, 0, MEM_RELEASE);
         } else {
             UnmapViewOfFile(base_ptr_);
         }
@@ -534,8 +553,8 @@ void MemoryMapper::close_file() {
 void MemoryMapper::flush() {
     if (mapped_ptr_) {
 #ifdef _WIN32
-        if (!FlushViewOfFile(mapped_ptr_, 0)) {
-            // Log warning?
+        if (hMapping_ != NULL) {
+            FlushViewOfFile(mapped_ptr_, 0);
         }
         if (hFile_ != INVALID_HANDLE_VALUE) {
             FlushFileBuffers(hFile_);
@@ -549,7 +568,9 @@ void MemoryMapper::flush() {
 void MemoryMapper::flush(void* ptr, size_t size) {
     if (ptr && size > 0) {
 #ifdef _WIN32
-        FlushViewOfFile(ptr, size);
+        if (hMapping_ != NULL) {
+            FlushViewOfFile(ptr, size);
+        }
         // R1_SAFETY: Ensure metadata/file size changes are also committed
         if (hFile_ != INVALID_HANDLE_VALUE) {
             FlushFileBuffers(hFile_);

pycauset-0.6.2.dev5/documentation/dev/R2_PERF_FINDINGS.md

@@ -1,79 +0,0 @@
-# R2_PERF — parity findings (R2.2)
-
-Measured with `python benchmarks/r2_parity.py` (dense float64, n=1024 matrices,
-best-of-3, PyCauset result forced through `np.asarray`; `invert`/`determinant`
-clear their derived caches before timing so both sides recompute). The ratio is
-`numpy_time / pycauset_time`; the R2_PERF bar is **≥ 0.90×**.
-
-Current state (threaded DYNAMIC_ARCH OpenBLAS, `OPENBLAS_NUM_THREADS=8` default):
-
-| op | ratio | verdict |
-| :-- | --: | :-- |
-| solve | 0.96× | PASS |
-| invert | 1.09× | PASS |
-| dot | ~1.8× | PASS |
-| determinant | 1.24× | PASS |
-| eigh | 0.98× | PASS |
-| add | 0.88× | FAIL (marginal) |
-| multiply | 0.72× | FAIL |
-| matmul | 0.80× | FAIL |
-
-## What landed in R2.2
-
-1. **`determinant` → LAPACK** — `CpuSolver::determinant` now uses `LAPACKE_dgetrf`/
-   `zgetrf` (NumPy's own backend) instead of Eigen's single-threaded `PartialPivLU`.
-   This took determinant from ~3× slower to ~1.24× (PASS).
-2. **Fair `invert`/`determinant` benchmarking** — the benchmark clears the derived
-   caches (`_invalidate_cached_derived`) before timing, so a warm inverse/determinant
-   cache is no longer compared against NumPy's fresh factorization.
-3. **`add` flakiness root-caused** — NOT a C++ Heisenbug. A stale installed wheel in
-   `site-packages` (no `__init__.py`) merged with the source checkout into a namespace
-   package, and `import_native_extension()` used `next(iter(pkg.__path__))`, whose
-   entry order is filesystem-dependent on Windows. ~50% of processes loaded a stale
-   `_pycauset.pyd` (predating the lazy `try_eval_fast` SIMD path) and took the blocked
-   `target = expr_` eval (~0.019 s) instead of the AVX2 path (~0.003 s). Fixed by
-   loading from the package's own `__file__` directory (see `python/pycauset/_internal/native.py`).
-4. **AVX2 f64 sub/mul/div kernels + full-span hardening** — `try_fast_simd` now routes
-   `subtract`/`elementwise_multiply`/`elementwise_divide` through AVX2 (was only `add`),
-   with stricter full-span guards (zero-offset strided views fall back correctly).
-
-## `matmul` — bundled OpenBLAS build/tuning (0.56× → 0.80×)
-
-`pc.matmul` has always hit `cblas_dgemm` (not a naive loop). The gap was the bundled
-OpenBLAS: the CMake fallback downloads `OpenBLAS-0.3.26-x64.zip`, a **generic**
-(single-core, no arch-specific kernels) build. NumPy links `scipy-openblas` (DYNAMIC_ARCH,
-Haswell, threaded).
-
-Fix attempted in R2.2: build OpenBLAS 0.3.28 from source with
-`DYNAMIC_ARCH=1 USE_THREAD=1 NUM_THREADS=24` (MinGW-w64 gcc/gfortran 15.2, see
-`build_openblas.ps1`), generating an MSVC import lib via `gendef`+`dlltool`, and relinking
-`pycauset_core.dll`. The MinGW runtime DLLs (`libgcc_s_seh-1`, `libgfortran-5`,
-`libquadmath-0`, `libwinpthread-1`) must be bundled alongside `libopenblas.dll`.
-
-Result: `matmul` 0.66× → ~0.80× (0.011 s → ~0.008 s at n=1024), `corename=Haswell`.
-
-### OpenBLAS thread-count tradeoff (important)
-
-The threaded OpenBLAS uses one thread pool for BLAS **and** LAPACK. At the default
-(20 threads on this machine) small LAPACK factorizations (`dgetrf`/`dgetri` for
-`invert`/`determinant`) pay SMP-server sync overhead and become **slower** than
-single-threaded. `pycauset` therefore pins `openblas_set_num_threads(8)` at import
-(overridable via `OPENBLAS_NUM_THREADS`), which keeps `invert`/`determinant` at parity
-while still speeding GEMM. At n=1024, 8 threads ≈ 0.80× matmul; more threads help GEMM
-only marginally but hurt LAPACK.
-
-Remaining `matmul` gap to 0.90× is the OpenBLAS version/tuning delta (0.3.28 vs NumPy's
-0.3.30 `scipy-openblas`); fully closing it needs either NumPy's exact OpenBLAS (its DLL is
-`scipy_`-symbol-prefixed, so a relink through a symbol shim) or a 0.3.30+ tuned build.
-
-## Remaining below-parity ops
-
-- **`add` (0.88×)** — essentially at parity; the residual is the `:memory:` backing
-  (pagefile-backed `CreateFileMappingA(INVALID_HANDLE_VALUE)` + `MemoryGovernor`
-  `request_ram`/`register_object` on every result allocation) vs NumPy's `malloc`.
-- **`multiply` (0.72×)** — eager `elementwise_multiply` (the MatrixBase `operator*` for
-  matrix×matrix is eager, unlike the lazy `+`/`-`/`÷`). Same SIMD kernel as `add`, but the
-  eager free-function path (~0.0030 s) is ~15% slower than the lazy add path (~0.0026 s).
-- **`matmul` (0.80×)** — OpenBLAS tuning (see above).
-
-These are tracked against the R2E engine track in `R2_ROADMAP.md` (`R2_PERF`).