Decoding Clean Code vs. Performance with Rust

Understanding Clean Code and Performance in Programming

The concept of clean code has been widely advocated across educational institutions and the tech industry, largely influenced by Robert C. Martin, also known as Uncle Bob. The philosophy behind clean code is to create layers of abstraction that make software readable, understandable, and maintainable. However, what happens when these principles are put to the test against real-world performance metrics?

The Experiment with Rust

In a recent experiment, a program was written in Rust to implement what many consider the epitome of clean code for handling geometric shapes like squares and circles. This code utilized polymorphism—a core principle of clean coding—where subclasses with shared behavior are preferred over conditional branching.

To evaluate the performance, a benchmark was set up where 10,240 shape objects were created, and their areas were calculated using an accumulator. Initially, this process took 54,956 nanoseconds per iteration.

Tweaking for Enhanced Performance

Chris from the original blog post discovered that performance could be significantly improved by simply altering how accumulations during the benchmark were handled. By switching from a single accumulator to four accumulators and summing them up post-iteration, there was a 3.1 times improvement in speed.

Breaking Down Polymorphism

The initial setup used polymorphism which required boxing values—this means each object had two pointers; one pointing to data and another to a method dispatch table. This added layers of indirection which were computationally expensive.

By replacing polymorphic code with enums and match statements (a common pattern in Rust), not only did it simplify the code but also boosted performance by 3.2 times from the baseline when using one accumulator and an astonishing 8.5 times when using four accumulators.

Further Optimization Using Lookup Tables

Taking optimization further, a lookup table-like construct was introduced where each shape held its dimensions as well as multipliers specific to its type (e.g., Pi for circles). This approach led to a speed increase of 6.4 times over the baseline; applying the four-accumulator technique here yielded an impressive 11 times faster performance.

The Magic Behind Multiple Accumulators

to understand why splitting accumulations worked so well requires diving a bit more technically—specifically looking at how modern CPUs handle operations via SIMD (Single Instruction Multiple Data) extensions which allow multiple data points to be processed simultaneously.

to investigate further Chris used tools like Radar2 on his x86_64 machine for decompiling and analyzing machine instructions generated by our modified Rust program.

to findings revealed that instead of standard operations like add or multiply instructions what we saw were SIMD-specific instructions which processed multiple data points at once effectively reducing overall computation time significantly when combined with our multi-accumulator setup.

to takeaway here is clear while clean coding practices aim for readability and maintainability they might not always align with optimal performance especially in systems where processing speed is critical.

to balance between maintaining clean code standards and achieving high performance can sometimes be achieved through thoughtful structuring and understanding underlying hardware capabilities as demonstrated in this experiment with Rust programming language.

Article created from: https://www.youtube.com/watch?v=GA4ONupSl8Y