fix: pin wasm batch-MSM dispatch to baseline (avoid #480 wasmtime chonk regression) (#568)

Author: AztecBot

barretenberg/cpp/src/barretenberg/ecc/scalar_multiplication/pippenger_batched.hpp

@@ -182,11 +182,19 @@ void pippenger_round_parallel_batched(std::span<std::span<typename Curve::Scalar
     // footprint, which tracks the span. A sparse-but-wide MSM (few non-zeros, large domain) must stay
     // "large" — splitting by active count instead drops it into the concurrent pool and thrashes cache.
     const size_t pool_width = bb::get_num_cpus();
+#ifdef __wasm__
+    // wasm runs every MSM single-threaded, so the split uses a fixed point-count bound rather than
+    // MSM_MIN_PTS_PER_THREAD (SIZE_MAX here, which would classify every member as small). The loop
+    // below tests `n < mt_threshold` and the intended classification is `n <= SMALL_MSM_BATCH_THRESHOLD`,
+    // so the exclusive bound is one past it.
+    const size_t mt_threshold = SMALL_MSM_BATCH_THRESHOLD + 1;
+#else
     // overflow-safe MSM_MIN_PTS_PER_THREAD * pool_width
     const size_t mt_threshold =
         (pool_width <= 1 || MSM_MIN_PTS_PER_THREAD > std::numeric_limits<size_t>::max() / pool_width)
             ? std::numeric_limits<size_t>::max()
             : MSM_MIN_PTS_PER_THREAD * pool_width;
+#endif
     std::vector<size_t> small_members;
     std::vector<size_t> large_members;
     small_members.reserve(K);
@@ -228,6 +236,11 @@ void pippenger_round_parallel_batched(std::span<std::span<typename Curve::Scalar
     //   - max n <= Σn / pool_width (n is the work proxy): with largest-first ordering (below) the
     //     makespan is max(largest, Σn / pool_width), so a dominant member can't strand one worker.
     //   - pool_width >= CONCURRENT_MIN_POOL_WIDTH: fewer threads make the win too small to justify.
+#ifdef __wasm__
+    // wasm keeps large members on the sequential shared-arena dispatch: with single-threaded MSMs the
+    // concurrent path's per-worker live arenas buy nothing over one reused arena.
+    const bool large_members_concurrent = false;
+#else
     static constexpr size_t CONCURRENT_MIN_MEMBERS = 100;
     static constexpr size_t CONCURRENT_MIN_POOL_WIDTH = 4;
     size_t total_large_n = 0;
@@ -239,6 +252,7 @@ void pippenger_round_parallel_batched(std::span<std::span<typename Curve::Scalar
     const bool large_members_concurrent = pool_width >= CONCURRENT_MIN_POOL_WIDTH &&
                                           large_members.size() > CONCURRENT_MIN_MEMBERS &&
                                           max_large_n <= total_large_n / pool_width;
+#endif
 
     // Shared dynamically-sized arena for the sequential (large-member) calls. Sized to
     // the max requirement across those members so each MSM_fast finds enough space; a

barretenberg/cpp/src/barretenberg/ecc/scalar_multiplication/scalar_multiplication_fast.hpp

@@ -190,6 +190,14 @@ inline constexpr size_t MSM_MIN_PTS_PER_THREAD = SIZE_MAX;
 inline constexpr size_t MSM_MIN_PTS_PER_THREAD = 256;
 #endif
 
+// Point-count bound for the batch driver's concurrent/sequential split on wasm. Intra-MSM work is
+// always single-threaded on wasm (MSM_MIN_PTS_PER_THREAD == SIZE_MAX), so the native split rule
+// `n < MSM_MIN_PTS_PER_THREAD * pool_width` would classify every member as small and route them all
+// through the concurrent pool, whose per-worker arena is sized to the largest member and caps the
+// worker count by memory budget. This finite bound keeps large members on the sequential shared-arena
+// path so the concurrent pool retains full worker width. Members at or below it dispatch one-per-worker.
+inline constexpr size_t SMALL_MSM_BATCH_THRESHOLD = size_t{ 1 } << 13;
+
 // Per-MSM_fast arena sizer. Returns 0 for shapes that fall back to the Jacobian-fast path
 // (no affine arena). Mirrors the inline budget calc inside `pippenger_round_parallel`;
 // declared here so the test suite can exercise the same sizer.