Testing accelerated backend

[Gorkowski]

I started to explore different backends and building out a timing function, some pretty nice gains are on the table it seems.

Options:

• Numba
  A just-in-time compiler for Python that can accelerate NumPy-style code with minimal syntax changes. In practice, many of the NumPy APIs we're using aren’t yet supported or vectorized under Numba, so we'd end up rewriting most functions—or it still fallbacks to Python object mode.

• Taichi (via LLVM)
  A data-oriented DSL that compiles kernels down through LLVM. We write Taichi-style kernels rather than plain Python, but it gives you explicit control over parallelism and memory layout on CPU (and GPU). It’s similar in concept to NVIDIA Warp: we trade a new API for high throughput and fine-grained scheduling.

• C++ (did not test this)
  Hand-written C++ lets us exploit every ounce of performance—SIMD intrinsics, custom memory pools, zero-overhead abstractions—but requires a full rewrite plus build tooling, Python bindings (pybind11/CPython API), and careful maintenance of cross-platform builds.

Ran the test on calculating the coagulation gain rate

We want efficiency to be close to 1 or greater (it accounts for cpu clock speed, so should be the same on different computers)
call=the function call
cycles= cpu cycles

Metric	Taichi coagulation gain rate(2000 runs × 50 calls each)	Current Python coagulation gain rate(100 runs × 25 calls each)
Throughput (calls/s)	2,635	77
Cycles/call (cycles)	1,136,614	38,880,563
Est. Flops (flops/call)	358,200	358,200
Efficiency (flops/cycle)	0.3151	0.0092
Median time (ms/call)	0.380 [± 0.084]	12.982 [± 0.640]
Min time (ms/call)	0.334	12.517

@mahf708 @wkchuang

[Gorkowski]

#732