tur/perf

(cached [p & [cache-size 1024])

cache pattern results within a cycle to avoid redundant evaluation.

Pattern<T> with memoised results for repeated time queries.

  (cached expensive-pat 512)

(cached-ttl [p cache-size ttl])

cache pattern results with a time-to-live expiry.

(inline-pattern [p])

specialise simple patterns for reduced call overhead.

(fuse-pattern [p])

fuse consecutive pattern operations to reduce overhead.

(defstruct CompiledPattern [])

a pattern compiled to native code (conceptual).

(compile-pattern [p])

attempt to compile a pattern to native code.

(eval-compiled [cp time])

evaluate a compiled pattern at a specific time.

(defstruct LazyPattern<T> [])

pattern whose construction is deferred until first use.

(make-lazy-pattern [thunk])

create a lazy pattern from a thunk.

(eval-lazy [lp time])

evaluate a lazy pattern, constructing it on first use.

(batch-eval [p times])

evaluate a pattern at multiple times.

Vector of pattern values corresponding to each time.

  (batch-eval my-pat [0.0 0.25 0.5 0.75])

(batch-eval-process [p times f])

evaluate a pattern at multiple times and transform results.

(optimize-pattern [p & [passes [fuse-pattern inline-pattern cached])

apply a list of optimization passes to a pattern.

(optimize [p])

apply the standard optimization pipeline.

(optimize-aggressive [p])

apply an aggressive optimization pipeline including large cache.

(bench-pattern [p iterations & [warmup 10])

measure evaluation throughput for a pattern.

Map with :total-ns, :avg-ns, and :iterations.

  (bench-pattern my-pat 10000)

(patterns-equal? [p1 p2 times & [tolerance 0.001])

compare two patterns for equality over a set of test times.

(profile-pattern [p])

wrap a pattern to collect timing data on each call.

(profile-stats [profiled-fn])

retrieve profiling statistics from a profiled pattern.

(zero-alloc-pattern [computation])

create a pattern guaranteed not to allocate in the hot path.

(zero-alloc-cycle [values])

zero-allocation cycling pattern over a pre-allocated vector.

(zero-alloc-sine [freq amp])

zero-allocation sine wave pattern.

(defstruct PatternPool [])

reusable pool of pattern instances.

(pool-new [size factory])

create a pattern pool with pre-allocated instances.

(pool-get [pool])

borrow a pattern from the pool (creates one if pool is empty).

(pool-return [pool idx])

return a pattern to the pool by index.

(simd-pattern-4 [p])

evaluate a pattern at 4 times simultaneously (conceptual).

(specialize-pattern [p time-range])

constant-fold a pattern over a specific time range.

(specialize-constant [p])

evaluate a pattern once at time 0 and return a constant.

(track-allocations [p])

wrap a pattern to track GC allocations per evaluation.