Julia: код без абстракций работает в 6,5 мс

Based on the text you provided, the sentence "What we did prior to this point were" is incomplete. However, based on the context of the optimization steps described (converting abstract types to concrete types, avoiding list comprehensions, reducing allocations, and avoiding high-level linear algebra libraries), the sentence likely continues to summarize the nature of these optimizations.

Here is the logical completion of that sentence, followed by a summary of the entire optimization journey described in your text:

"What we did prior to this point were manual, low-level code transformations that replaced high-level abstractions with explicit loops and arithmetic operations to eliminate memory allocations and reduce runtime overhead."

Alternatively, it might continue to compare the result with the previous benchmarks:

"What we did prior to this point were a series of aggressive manual unrollings and type specializations that brought Julia's performance within 1.6x of the C++ implementation."

The text describes a classic "Julia optimization funnel," moving from idiomatic (but slow) code to "unsafe" (but fast) manual code. Here is the breakdown of the steps taken:

1. Fix #1: Use Concrete Types

   • Change: Converted abstract types to concrete types in the Particle struct.
   • Result: Eliminated type instability.
   • Speedup: ~3x improvement. (C++ was still ~20x faster).

2. Fix #2: Avoid List Comprehensions

   • Change: Replaced [expr for i in 1:n] with explicit for loops.
   • Reason: List comprehensions allocate memory to build an array, whereas simple loops avoid this allocation and allow JIT compilation to optimize better.
   • Speedup: 1.5x improvement.

3. Fix #3: Reduce Allocation

   • Change: Replaced vector operations (e.g., dX = Pi.X - Pj.X) with scalar variables (e.g., dX1, dX2, dX3).
   • Reason: Accessing elements of an array creates a new object every time. Storing differences in scalars prevents creating temporary arrays.
   • Speedup: 3.68x improvement (Total memory dropped from 126 MiB to 22 MiB).

4. Fix #4: No Linear Algebra Functions

   • Change: Replaced norm(), cross(), and dot() with their explicit mathematical expansions (e.g., sqrt(x*x + y*y + z*z)).
   • Reason: High-level functions like cross often allocate temporary arrays internally before returning a result. Explicit formulas compute everything in place.
   • Speedup: 2.10x improvement.
   • Outcome: Achieved 0 bytes allocated and 0% GC pressure.

5. Final Result: Fine Tuning

   • Current State: Julia achieved 6.487 ms.
   • Baseline: C++ achieved 4.0 ms.
   • Performance Gap: C++ is now only 1.62 times faster than the highly optimized Julia code.

The text illustrates that while idiomatic Julia is fast enough for most applications, pushing the limits requires sacrificing readability (manual unrolling, scalar arithmetic) to achieve C++-level performance. The goal is not always to match C++, but to minimize allocations and ensure the code stays within the @code_warntype stable regime so the Julia compiler can fully optimize it.