JP Patent App. 2026-046620 (independent product)

PSDP — Same-Language Parallelization

Inject deterministic parallelization into your existing applications — without rewriting source code.

PSDP (Phase-Synchronous Deterministic Parallelism) is JAVATEL's independent runtime-injection product line for parallelizing existing Java, C#, Rust, Go, Kotlin and 11 more — 16 languages in total, delivering 2.97–4.23× speedup with bit-exact output and a hash-chained audit trail.

Slime-Boy: Wait — 4× speedup without changing my source? Really? ▾

“No source rewrites” — how is that even possible?

Your OrderBatch.java stays byte-for-byte identical — git diff shows nothing.
At build time, PSDP reads the bytecode, finds the parallelizable regions, and injects a parallel version alongside (Java agent / .NET profiler API / Rust proc-macro — the mechanism is language-specific).
At runtime: 1 core → sequential path. 4 cores → parallel path. You write no dispatch code.
The classic “parallel changed my answer” failure mode is excluded by theory via PSDP’s proprietary mathematical synchronization mechanism (details disclosed in patent filings and published paper; redacted here).
Every production run, bench compares sha256 of sequential vs parallel output. Mismatch → instant rollback.

So: not one line of your code touched / just rebuild / output unchanged at the bit level / 4× on 4 cores (precisely 2.97–4.23×, depending on cores and algorithm shape). For audit, “zero code change” is the selling point.

Peak speedup

4.23 ×

Bit-exact runs

378 / 378

Fault rollbacks

90 / 90

Determinism (378/378)

100%

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

Financial trading systems

Parallelize overnight batch and risk computation; cut window time by 3× with cent-exact bit-exact guarantee. SAFETY_MAX profile satisfies audit needs.

Regulated Java / C# parallelization

Parallelize finance and insurance core systems under J-SOX / SEC oversight, with hash-chained audit trail. Result invariance enables recompute, comparison, and audit.

Cloud cost reduction

3–4× speedup on existing workloads = 1/3 the infrastructure. Compress AWS / GCP / Azure instance count and size with no code changes.

HFT (high-frequency trading)

Low-latency order processing and market-data parallelization. GAME_MIN profile minimizes safety overhead to prioritize frame time.

Scientific computing

Bit-exact parallelization of FFT, Conv2D, LU decomposition. Eliminates the "parallel result differs, can't compare" failure mode.

ML inference acceleration

Parallelize trained-model inference pipelines with deterministic guarantees. Compatible with A/B comparison, regression validation, and security audit.

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	TPC (transaction)	1.02 ×	I/O-bound, but result-invariance still guaranteed
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).

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.

Licensing

SlimeNENC customers	PSDP tool (converter / developer-side) is free. PSDP runtime (deployed production) is billed at 2%/year of conversion cost only. No contractual renegotiation needed (same patent 2026-046620).
Direct customers	Runtime-billed, separate pricing. Editions: Trial / Individual / Corporate / OEM.
Method	Ed25519-signed license + 3-hop air-gap activation (for financial institutions).
License server	license.javatel.jp (AWS Lightsail, HSTS / OCSP stapling)

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, SlimeSyCUDA)

Related products

SlimeNENC family: an independent family that bit-exact-modernizes COBOL / JCL / MUMPS legacy assets into Java, Rust, C#, Kotlin, Go. The natural pairing — SlimeNENC migrates legacy to Java, then PSDP injects parallelization on the migrated Java — requires no additional contractual negotiation on the customer side.