PSDP — Same-Language Parallelization

Supported languages

PSDP generates a sequential / parallel pair within the same language. Production-ready across 16 languages, from enterprise to systems to scientific computing.

Enterprise	Java 8 / 17 / 21 · C# · Kotlin (+coroutines) · Scala
Systems	Rust · Go · C / C++ · Swift
Scripting	Python · Node.js · PHP
Functional / Scientific	Clojure · Erlang · Common Lisp · FORTRAN

Use cases

How it works — mathematical synchronization for bit-exact parallelism

The sufficient condition for parallel execution to return the same result as sequential is derived from PSDP’s proprietary mathematical synchronization mechanism over relational operators. At runtime, PSDP enforces this condition below a threshold and gives an analytic upper bound on numerical drift — eliminating the "numbers change when parallelized" phenomenon at the theory level. (Theoretical detail is disclosed in patent filings and the published paper; redacted on this page.)

// PSDP applied (OrderBatchProcessor_PSDP.java, excerpt)
// - sha256 of input/output exactly matches the original
//   sequential code (OrderBatchProcessor_ORIGINAL.java)
public class OrderBatchProcessor {
    public Result process(List<Order> orders) {
        return orders.parallelStream()        // only the parallel call differs
            .map(this::settle)
            .collect(PSDP.phaseSyncReduce(...));   // phase-synchronized reduce
    }
}

The diff between sequential and parallel is a few API calls only; no logic rewrites. Bench regression-tests sha256 equality between sequential and parallel output every CI run.

Technical specifications

• Injection methodRuntime injection. No source code rewrites; rebuild only.
• Bit-exact guaranteesha256 of sequential and parallel outputs match exactly. Eliminates the typical "parallel changes the numbers" failure mode.
• Mathematical sync guaranteePSDP’s proprietary synchronization condition is enforced at runtime, yielding an analytic upper bound on numerical drift (theoretical detail redacted).
• Hash-chained auditFNV1a64 + SHA-256 monotonic chain. 1-byte tampering is DETECTED. Append-only, no after-the-fact edits.
• Fault-injection rollback90/90 scenarios with zero barrier violations. Tombstone-based past-state restoration.
• 11 safety mechanismsCovered by claims 29-32, configurable across 5 profiles (GAME_MIN to SAFETY_MAX).

Verified benchmarks

Category	Kernel	Speedup	Notes
Compute	NENC (numerical equivalence)	3.38 ×	Near-linear in cores, CPU-bound
Graph	GRA (graph kernels)	2.17 ×	Memory-bandwidth ceiling, bit-exact preserved
Database (OLAP, partition-parallel)	TPC-H Q1 / Q6 column store, 12 M rows	4.38 – 5.20 ×	1c → 8c on Ryzen 9 7945; 25 / 25 runs bit-exact vs reference
Database (CDC replay)	commutativity-aware 20 M-op WAL replay	4.26 ×	vs serial baseline; 25 / 25 final-state hash matches
Database (multi-conn read)	SQLite WAL parallel-reader throughput	9.76 ×	14.2 → 138.6 qps, 1c → 12c
SIMD	svt_av1_quantize_fp (AVX-512)	3072 / 3072	Bit-exact PASS, ±5% vs AVX2 (memory-bound)

378 runs all bit-exact (100% PASS) / 90/90 fault-injection rollbacks are detailed in the PSDP paper (JP v5d, 910 KB PDF, 2026-03-04). Database numbers above re-measured 2026-05-18 on AMD Ryzen 9 PRO 7945 (12c / 24t, OpenJDK 21); the earlier “DB 1.02 ×” figure was a wall-time aggregation artefact (workload-normalisation across non-PSDP phases) and is superseded by the partition / CDC / WAL-reader cases shown here. 75+ runs all deterministic.

Versus alternatives

Intel TBB	Parallelization framework, but requires source rewrites; no bit-exact guarantee. PSDP: no source changes + bit-exact + audit trail.
OpenMP	pragma-based, requires explicit annotation; reproducibility is implementation-dependent. PSDP: runtime injection + result-invariance + audit fitness.
Java parallelStream	Result order non-deterministic; reduce on floats is non-reproducible. PSDP's phaseSyncReduce makes reduce order deterministic too.
C# Parallel.ForEach	Same: side-effect order non-deterministic. PSDP provides bit-exact within-language parallelism.
GPU parallelism (CUDA / Metal)	Cross-language, results are arch-dependent. PSDP stays within the same language and same binary, runs on CPU.

Where PSDP excels (memory-bound large batches & compute-intensive)

PSDP delivers 2.97-4.23x speedup on ms-class or larger compute-intensive workloads where Bernstein commutativity holds. Particularly effective domains:

ML inference	matmul / convolution dominant, batch latency hundreds of ms to seconds, PSDP 2.97-4.23x
HFT computation	Tick-by-tick valuation, easy Bernstein region split, low-latency parallel
Scientific computing	FEM / fluid / molecular dynamics, clear domain decomposition + sync points
Large-scale batch DB walk	SlimeTree-VSAM-style in-memory backends with sequential cursor (memory-BW bound) — PSDP 6-8x scaling expected

Real example: SlimeTree-VSAM 1-billion-record sequential batch (synergy case) — SlimeTree-VSAM standalone is already 480× faster than PostgreSQL in same-host bench (1B sequential = 4.4 min vs PostgreSQL 19.5 hours). Adding PSDP integration for 8-thread parallel walk, even with memory BW sharing, gives an expected 4.4 min → 30-60 sec (6-8x scaling). Combined: 1,900-3,800× faster than PostgreSQL — the only solution that fits the broken overnight-batch window in large financial mainframes.

Projection synthesized from SlimeTree-VSAM's impl_v6 micro / scale bench (Zen 4 / WSL2 same host) and PSDP's ML inference bench 2.97-4.23x scaling. SlimeTree-VSAM was announced in the 2026-05-24 news.

Workloads where PSDP gives limited benefit

The above is PSDP's domain. By contrast, the patterns below see small speedups or none. We disclose this for transparency.

I/O-bound	If the CPU is idle waiting on DB / network, PSDP cannot shorten wait time — PSDP parallelizes compute, not I/O. Right tool: async I/O or queue separation (outside PSDP scope).
HashMap / tree-walk dispatch-heavy	Pointer-chasing code with high branch density where Bernstein commutativity does not hold — synchronization overhead exceeds gains.
Tiny workload (~ms or less)	Bernstein setup is on the ms scale; if each task is μs-class, relative overhead dominates. Batch tasks together first.
Already parallel (rayon / Tokio etc.)	Exclusive with other within-language parallelism. Requires removing the existing parallel layer before PSDP injection.

Real example: SlimeTree-RLM impl_v4 (Rust) — HashMap-heavy / dispatch-bound code (Hot Shelf treap, Cold Shelf RB-tree, SCC decomposition). Per-slot operations run at μs scale, making Bernstein synchronization overhead disproportionately large. Estimated PSDP injection speedup is only 1.0-1.1x — not PSDP's domain (compute-intensive matmul-class), so PSDP application is deferred.

PSDP delivers 2.97-4.23x on algorithms where computation itself dominates time (ML inference, HFT, scientific computing). For codebases matching the 4 patterns above we recommend alternative approaches (async I/O, cache optimization, batching).

Pricing & licensing (Provisional, 2026-05-18 — example at 10,000 LOC)

Path	LOC	Buy-in / LOC	Buy-in total	Runtime rate	Runtime / year	Support
SlimeNENC (converter)	10,000	US$ 9.95	US$ 99,500	—	—	Full
PSDP for SlimeNENC customer	10,000	US$ 0.00	US$ 0	2%/year	US$ 1,990	Full
PSDP direct (via SIer / partner)	10,000	US$ 1.00	US$ 10,000	20%/year	US$ 2,000	Full (via partner)
PSDP end-user direct (30% OFF)	10,000	US$ 0.70	US$ 7,000	20%/year	US$ 1,400	FAQ only

Across the first three paths, the per-LOC annual runtime cost is designed to converge to the same band; only the one-time buy-in differs, reflecting the value of the SlimeNENC converter tool when bundled. The end-user-direct path is for self-deploying customers (FAQ-only support, no SI engagement — for hands-on help please go through a partner).

Activation method	Ed25519-signed license + 3-hop air-gap activation (for financial institutions).
License server	license.javatel.jp (AWS Lightsail, HSTS / OCSP stapling)
Patent	JP App. 2026-046620 (no contractual renegotiation between paths)

For SIer / partners: partners selling at the direct list price earn a substantial margin on the one-time buy-in, and the same margin applies recurringly to the annual runtime subscription — year after year, for as long as the customer keeps PSDP in production. Concrete tier numbers are part of the partner agreement and shared after registration. See /partners/ for partner enrolment.

Direct-customer Editions (Provisional, 2026-05-18 — subject to change)

Edition	PSDP-managed LOC cap	One-time buy-in	Annual runtime	Notes
Trial	10,000	US$ 0	US$ 0 (14 days)	Full features, non-commercial
Individual	50,000	LOC × $1.00 (cap $50)	LOC × $0.20	Community support, commercial use OK
Corporate	1,000,000	LOC × $1.00	LOC × $0.20	Email support, SLA 99%, audit-chain export
Enterprise	unlimited	LOC × $1.00	LOC × $0.20 (cap $1,000,000/year)	24h SLA 99.9%, 3-hop air-gap activation, finance/medical
OEM	unlimited + relicense	negotiated	negotiated	Source-escrow option, embeddable runtime

“PSDP-managed LOC” = the line count of source files inside the namespaces / packages declared as PSDP-managed in psdp.toml, measured by cloc/tokei against the year-initial git revision. Runtime self-reports the same figure for cross-verification. The above schedule is provisional: caps, minimums, and SLA tiers may be revised before the GA pricing announcement.

Patents

• JP Patent App. 2026-046620 (PSDP core / Phase-Synchronous Deterministic Parallelism)
• JP Patent App. 2026-046625 (phase-sync implementation, 11 safety mechanisms, claims 29-32)
• Additional applications in preparation (SIMD / GPU extensions)

Related products

Try the service (PSDP) → Contact us SlimeNENC family All products