DEV Community: Sadanand Dodawadakar

What make Rust blazing fast?

Sadanand Dodawadakar — Sat, 18 Jan 2025 10:48:30 +0000

Rust has earned immense popularity for being a blazing fast programming language, often competing or even outperforming established programming languages like C and C++. But what truly sets Rust apart? This story explores the technical features and design principles that make Rust a powerhouse for performance.

1. Zero-Cost Abstractions

Rust adheres to the principle of zero-cost abstractions, meaning that high-level constructs in the language introduce no additional runtime overhead. Features like iterators, closures, and traits compile down to highly optimised machine code.

let v = vec![1, 2, 3, 4];
let sum: i32 = v.iter().filter(|&&x| x % 2 == 0).sum();

Rust compiler optimises the iterator and filter into a loop with no abstraction penalty.

2. Memory Safety Without Garbage Collection

Unlike Java or Go, Rust achieves memory safety without relying on a garbage collector. This eliminates the performance overhead caused by periodic garbage collection pauses.

Ownership and Borrowing

Rust uses an ownership system with strict rules about how memory is accessed. The compiler ensures this at compile time.

Memory is not accessed after it is freed (no use-after-free errors).

Only one mutable reference or multiple immutable references exist simultaneously.

Deterministic Deallocation

Memory is deallocated immediately when it goes out of scope, akin to RAII in C++, leading to predictable performance.

3. Fearless Concurrency

Concurrency is notoriously difficult to get right due to data races. Rust enables “fearless concurrency” with its ownership model and type system.

Elimination of Data Races at Compile-Time
Data races are a common source of bugs and performance issues in concurrent systems. Rust leverages its ownership model and borrow checker to enforce concurrency rules at compile time

Exclusive Access: Rust ensures that data is either mutably borrowed by one thread or immutably borrowed by multiple threads, but not both. Two threads cannot mutate the same piece of data simultaneously.
No Undefined Behaviour: By catching concurrency issues during compilation, Rust eliminates runtime errors like segmentation faults, which can slow down or crash programs in other languages.

Compile-time safety ensures that Rust’s concurrent programs are “error-free by design”, eliminating expensive runtime checks, which often degrade performance.

Efficient Use of System Resources

Rust’s fearless concurrency directly translates to better system resource utilisation.

Fine-Grained Locking: Rust’s Mutex and RwLock primitives allow precise control over shared data, reducing contention and enabling efficient multi-threaded execution.

-** Zero-Cost Abstractions:** Unlike languages with garbage collection or runtime checks for thread safety, Rust relies on compile-time guarantees. This ensures no runtime performance penalties.
_

Low-Overhead Concurrency Primitives

Rust’s standard library provides efficient concurrency tools:

std::thread : Lightweight abstractions for spawning OS threads.
std::sync :High-performance synchronisation primitives like High-_performance synchronisation primitives like Condvar, Mutex , and RwLock.

Asynchronous Concurrency: Maximising Throughput

Rust’s asynchronous programming model, built around async/await, complements its multithreading capabilities:

Futures-Based Execution: Rust’s async tasks are lightweight and avoid blocking threads, allowing applications to handle millions of operations efficiently.
Event-Driven Execution: Frameworks like tokio and async-std use event loops to schedule tasks efficiently, reducing the need for expensive thread context switches._

Deterministic Behaviour and Predictable Performance

concurrency in Rust eliminates common pitfalls like race conditions and deadlocks:

Race Conditions: Rust enforces data access rules that prevent inconsistent states caused by unsynchronised threads.
Deadlocks: While Rust doesn’t eliminate deadlocks, its ownership model and explicit synchronisation primitives make potential deadlocks easier to identify and debug._

By eliminating these issues, Rust ensures that concurrent programs run “predictably and efficiently”, even under high workloads.

4. Monomorphisation of Generics

Rust uses monomorphisation for generics, generating specific code for each type used with a generic function or structure. This results in type-specific, highly optimised code at the cost of slightly larger binary sizes.

fn add<T: std::ops::Add<Output = T>>(a: T, b: T) -> T {
    a + b
}

fn main() {
    let int_sum = add(1, 2);      // Optimized for integers
    let float_sum = add(1.0, 2.0); // Optimized for floats
}

Compiler creates separate versions of add for integers and floats, eliminating runtime type checking and improving performance.

5. Minimal Runtime

One of the standout features of Rust is its minimal runtime overhead. This design choice ensures that Rust programs are not only safe and concurrent but also incredibly fast. Let’s break this concept down in detail.

Runtime overhead refers to the extra processing and resource consumption added by a language’s runtime environment to manage features like memory allocation, garbage collection, thread management, and more.

Languages like Java introduce significant runtime overhead due to their reliance on garbage collection and virtual machines (e.g., JVM for Java). Rust, on the other hand, avoids these overheads, delivering near-zero-cost abstractions and runtime efficiency.

6. Static Linking

Rust uses static linking by default, embedding all dependencies and required code directly into the executable. This ensures:

Faster runtime because there’s no need to dynamically resolve external libraries.
Predictable performance, as the binary includes everything needed for execution._

While this increases the executable size, it eliminates runtime delays due to dynamic linking, making execution faster. However, “static linking may increase the load time.”

We will do the comparison of rust compiled binary and C compiled binary to understand intricacies in details in the following sections.

7. LLVM Optimisations

Rust leverages the LLVM backend, which performs aggressive optimisations to generate highly efficient executables. Key LLVM optimisations include:

Inlining: Embeds function calls directly into the caller’s code to avoid the overhead of function calls.
Loop Unrolling: Optimises loops by reducing branching operations.
Dead Code Elimination: Strips unused code from the final executable, ensuring only essential instructions remain.

8. Low-Level Control with High-Level Guarantees

Rust allows direct control over hardware and memory, similar to C/C++, while maintaining safety through its ownership model. In cases where performance-critical operations are needed, unsafe blocks provide the freedom to bypass some safety checks for raw hardware access.

Rust ensures safe memory access by default, reducing debugging overhead.
Unsafe code regions, when necessary, compile to raw, low-level instructions without safety checks, maximising speed.

9. Efficient Memory Layout

Rust compilers carefully optimise data structures for cache alignment and memory layout. Using attributes like #[repr(C)], Rust ensures predictable layouts that match system architecture, reducing cache misses and improving access times.

#[repr(C)]
struct Point {
    x: f64,
    y: f64,
}

This ensures Point is laid out in memory as contiguous x and y values, enabling efficient hardware-level access.

10. LTO (Link-Time Optimisation)

Rust supports Link-Time Optimization (LTO), which optimizes the binary by analysing and optimising across crate boundaries. LTO ensures:

Removal of redundant code and function calls.
Cross-module inlining, improving execution speed._

[profile.release]
lto = "thin"

11. Whole-Program Compilation

Rust compiles the entire program, including dependencies, into a single executable. This enables the compiler to:

Inline functions across library boundaries.
Optimise the entire program holistically, unlike languages that compile individual files separately.

12. Optimised Panic Handling

Rust includes panic handling for safety, but it optimises for the common case where no panics occur:

Panic code paths are generated separately, leaving the main execution path lightweight.
Release builds can further strip panic messages for minimal overhead._

Final Thoughts

Rust’s speed is a product of deliberate design, combining low-level control, memory safety, and zero-cost abstractions to deliver exceptional performance. It excels in scenarios requiring both high efficiency and reliability, making it a compelling choice for modern systems.

Ultimately, Rust strikes a remarkable balance, offering developers the tools to build fast and safe software while acknowledging the complexity that comes with such power.

Generics in Go: Transforming Code Reusability

Sadanand Dodawadakar — Tue, 07 Jan 2025 16:25:47 +0000

Generics, introduced in Go 1.18, have revolutionised the way of writing reusable and type-safe code. Generics bring flexibility and power while maintaining Go’s philosophy of simplicity. However, understanding nuances, benefits, and how generics compare to traditional approaches (like interface{} ) requires a closer look.

Let’s explore the intricacies of generics, delve into constraints, compare generics to interface{}, and demonstrate their practical applications. We’ll also touch upon performance considerations and binary size implications. Let’s dive in!

What is Generics?

Generics allow developers to write functions and data structures that can operate on any type while maintaining type safety. Instead of relying on interface{}, which involves type assertions in runtime, generics let you specify a set of constraints that dictate the permissible operations on the types.

Syntax

func FunctionName[T TypeConstraint](parameterName T) ReturnType {
    // Function body using T
}

T: A type parameter, representing a placeholder for the type.

TypeConstraint: Restricts the type of T to a specific type or a set of types.

parameterName T: The parameter uses the generic type T.

ReturnType: The function can also return a value of type T.

Example

func Sum[T int | float64](a, b T) T {
    return a + b
}

func Sum: Declares the name of the function, Sum

[T int | float64]: Specifies a type parameter list that introduces T as a type parameter, constrained to specific types (int or float64). Sum function can take only parameters either int or float64, not in combination, both have to either int or float64. We will explore this further in below sections.

(a, b T): Declares two parameters, a and b, both of type T (the generic type).

T: Specifies the return type of the function, which matches the type parameter T.

Constraints: Building blocks of Generics

Constraints define what operations are valid for a generic type. Go provides powerful tools for constraints, including the experimental constraints package(golang.org/x/exp/constraints).

Built-in Constraints

Go introduced built-in constraints with generics to provide type safety while allowing flexibility in defining reusable and generic code. These constraints enable developers to enforce rules on the types used in generic functions or types.

Go has below built-in constraints

any: Represents any type. It’s an alias for interface{}. This is used when no constraints are needed

func PrintValues[T any](values []T) {
    for _, v := range values {
        fmt.Println(v)
    }
}

comparable: Allows types that support equality comparison(== and !=). Useful for maps keys, duplicate detection or equality checks. This can not be used for maps, slices and functions, since these types don’t support direct comparison.

func CheckDuplicates[T comparable](items []T) []T {
    seen := make(map[T]bool)
    duplicates := []T{}
    for _, item := range items {
        if seen[item] {
            duplicates = append(duplicates, item)
        } else {
            seen[item] = true
        }
    }
    return duplicates
}

Experimental constraints

constraints.Complex: Permits complex numeric types(complex64 and complex128).
constraints.Float: Permits float numeric types(float32 and float64)
constraints.Integer: Permits any integer both signed and unsigned (int8, int16, int32, int64, int, uint8, uint16, uint32, uint64 and uint)
constraints.Signed: Permits any signed integer(int8, int16, int32, int64 and int)
constraints.Unsigned: Permits any unsigned integer (uint8, uint16, uint32, uint64 and uint).
constraint.Ordered: Permits types that allow comparison (<. <=, >, >=), all numeric types and string are supported(int, float64, string, etc).

import (
     "golang.org/x/exp/constraints"
     "fmt"
)

func SortSlice[T constraints.Ordered](items []T) []T {
    sorted := append([]T{}, items...) // Copy slice
    sort.Slice(sorted, func(i, j int) bool {
        return sorted[i] < sorted[j]
    })
    return sorted
}

func main() {
    nums := []int{5, 2, 9, 1}
    fmt.Println(SortSlice(nums)) // Output: [1 2 5 9]

    words := []string{"banana", "apple", "cherry"}
    fmt.Println(SortSlice(words)) // Output: [apple banana cherry]
}

Custom Constraints

Custom constraints are interfaces that define a set of types or type behaviours that a generic type parameter must satisfy. By creating your own constraints, we can;

Restrict types to a specific subset, such as numeric types.
Require types to implement specific methods or behaviors.
Add more control and specificity to your generic functions and types.

Syntax

type Numeric interface {
    int | float64 | uint
}

Example

type Number interface {
    int | int64 | float64
}

func Sum[T Number](a, b T) T {
    return a + b
}

Sum function can be called using only int, int64 and float64 parameters.

Constraints by method

If you want to enforce a type must implement certain methods, you can define it using those methods.

type Formatter interface {
    Format() string
}

func PrintFormatted[T Formatter](value T) {
    fmt.Println(value.Format())
}

The Formatter constraint requires that any type used as T must have a Format method that returns a string.

Combining Constraints

Custom constraints can combine type sets and method requirements

type AdvancedNumeric interface {
    int | float64
    Abs() float64
}

func Process[T AdvancedNumeric](val T) float64 {
    return val.Abs()
}

This constraint includes both specific types (int, float54) and requires the presence of an abs method.

Generics vs interface{}

Before introduction of generics, interface{} was used to achieve flexibility. However, this approach has limitations.

Type Safety

interface{}: Relies on runtime type assertions, increasing the chance of errors at runtime.
Generics: Offers compile-time type safety, catching errors early during development.

Performance

interface{}: Slower due to additional runtime type checks.
Generics: Faster, as the compiler generates optimised code paths specific to types.

Code Readability

interface{}: Often verbose and less intuitive, making the code harder to maintain.
Generics: Cleaner syntax leads to more intuitive and maintainable code.

Binary Size

interface{}: Results in smaller binaries as it doesn’t duplicate code for different types.
Generics: Slightly increases binary size due to type specialisation for better performance.

Example

func Add(a, b interface{}) interface{} {
    return a.(int) + b.(int)
}

Code works well, type assertion is overhead. Add function can called with any argument, both a and b parameters can be of different types, however code will crash in the runtime.

func AddGeneric[T int | float64](a, b T) T {
    return a + b
}

Generics eliminate the risk of runtime panics caused by incorrect type assertions and improve clarity.

Performance

Generics produce specialised code for each type, leading to better runtime performance compared to interface{}.

Binary Size

A trade-off exists: generics increase binary size due to code duplication for each type, but this is often negligible compared to the benefits.

Limitations of Go Generics

Complexity in Constraints: While constraints like constraints.Ordered simplify common use cases, defining highly customized constraints can become verbose.

No Type Inference in Structs: Unlike functions, you must specify the type parameter explicitly for structs.

s := Stack[int]{} // Type parameter is required

Limited to Compile-Time Constraints: Go generics focus on compile-time safety, whereas languages like Rust offer more powerful constraints using lifetimes and traits.

Let’s Benchmark — Better done than said

We will implement a simple Queue with both interface{} and generic and benchmark the results.

Interface{} Queue implementation

package main

import (
 "testing"
)

type QueueI struct {
 items []interface{}
}

func (q *QueueI) Enqueue(item interface{}) {
 q.items = append(q.items, item)
}

func (q *QueueI) Dequeue() interface{} {
 item := q.items[0]
 q.items = q.items[1:]
 return item
}

func BenchmarkInterfaceQueue(b *testing.B) {
 queue := QueueI{}
 for i := 0; i < b.N; i++ {
  queue.Enqueue(i)
  queue.Dequeue()
 }
}

Generic Queue Implementation

package main

import (
 "testing"
)

type QueueG[T any] struct {
 items []T
}

func (q *QueueG[T]) Enqueue(item T) {
 q.items = append(q.items, item)
}

func (q *QueueG[T]) Dequeue() T {
 item := q.items[0]
 q.items = q.items[1:]
 return item
}

func BenchmarkGenericQueue(b *testing.B) {
 queue := QueueG[int]{}
 for i := 0; i < b.N; i++ {
  queue.Enqueue(i)
  queue.Dequeue()
 }
}

go test -bench=. -benchmem
goos: darwin
goarch: amd64
pkg: becnh
cpu: VirtualApple @ 2.50GHz
BenchmarkGenericQueue-10        74805141                16.05 ns/op            8 B/op          1 allocs/op
BenchmarkInterfaceQueue-10      25719405                44.65 ns/op           24 B/op          1 allocs/op
PASS
ok      becnh   4.522s

Analysis of Results

Execution Time:
The generic implementation is approximately 63.64% faster than the interface{} version because it avoids runtime type assertions and operates directly on the given type.
Allocations:
The interface{} version makes 3x more allocations, primarily due to boxing/unboxing when inserting and retrieving values. This adds overhead to garbage collection.

For larger workloads, such as 1 million enqueue/dequeue operations, the performance gap widens. Real-world applications with high-throughput requirements (e.g., message queues, job schedulers) benefit significantly from generics.

Final Thoughts

Generics in Go strike a balance between power and simplicity, offers a practical solution for writing reusable and type-safe code. While not as feature-rich as Rust or C++, align perfectly with Go’s minimalist philosophy. Understanding constraints like constraints.Ordered and leveraging generics effectively can greatly enhance code quality and maintainability.

As generics continue to evolve, they are destined to play a central role in Go’s ecosystem. So, dive in, experiment, and embrace the new era of type safety and flexibility in Go programming!

Checkout github repository for some samples on generics.

sadananddodawadakar / GoGenerics

Repository contains working examples of go generics

Go Generics: Comprehensive Examples Repository

Welcome to the Go Generics Repository! This repository is a one-stop resource for understanding, learning, and mastering generics in Go, introduced in version 1.18. Generics bring the power of type parameters to Go, enabling developers to write reusable and type-safe code without compromising on performance or readability.

This repository contains carefully curated examples that cover a wide range of topics, from basic syntax to advanced patterns and practical use cases. Whether you're a beginner or an experienced Go developer, this collection will help you leverage generics effectively in your projects.

🚀 What's Inside

🔰 Basic Generic Programs

These examples introduce the foundational concepts of generics, helping you grasp the syntax and core features:

GenericMap: Demonstrates a generic map function to transform slices of any type.
Swap: A simple yet powerful example of swapping two values generically.
FilterSlice: Shows how to filter…

View on GitHub

Hidden Power of Go: Unveiling the Secrets of a Robust Language

Sadanand Dodawadakar — Wed, 01 Jan 2025 20:49:20 +0000

Golang is celebrated for its simplicity, efficiency, and developer-friendly features. While most developers are familiar with Go’s hallmark features like go-routines, channels, and its standard library, there’s a wealth of hidden power. In this article, we will explore Go’s lesser-known capabilities that can significantly enhance your development process and application performance.

The runtime Package: A Peek Under the Hood

The runtime package offers a set of tools that allow you to inspect and manipulate Go’s runtime system. It’s not just for debugging; it’s also a window into how Go works.

Go-routine Inspection
The runtime.NumGoroutine function provides the current number of goroutines running in your application, useful for monitoring concurrency.

package main

import (
    "fmt"
    "runtime"
)

func main() {
    fmt.Printf("Number of Goroutines: %d\n", runtime.NumGoroutine())
}

*Callers and Callstack *
Using runtime.Callers and runtime.CallersFrames, you can inspect the call stack programmatically. This is especially useful in debugging complex issues.

package main

import (
    "fmt"
    "runtime"
)


func printCallers() {
    pc := make([]uintptr, 10)
    n := runtime.Callers(2, pc)
    frames := runtime.CallersFrames(pc[:n])
    for frame, more := frames.Next(); more; frame, more = frames.Next() {
        fmt.Printf("%s\n    %s:%d\n", frame.Function, frame.File, frame.Line)
    }
}

Manual Garbage Collection:
While Go has an automatic garbage collector, you can trigger garbage collection manually using runtime.GC() in scenarios where deterministic cleanup is necessary.

package main

import (
    "fmt"
    "runtime"
)

func InvokeGC() {
    runtime.GC()
}

Dynamic Memory Stats:
Use runtime.ReadMemStats to gather detailed memory usage statistics, aiding in performance optimisation.

package main() 

import (
    "fmt"
    "runtime"
)

func PrintMemStates() {
    var stats runtime.MemStats
    runtime.ReadMemStats(&stats)
    fmt.Printf("Allocated memory: %v KB\n", stats.Alloc/1024)
}

Advanced Debugging with the debug Package

The debug package complements runtime by offering tools for deep runtime diagnostics. It’s especially useful for debugging complex issues in production.

Stack Trace Retrieval
The debug.Stack function lets you capture stack traces programmatically for logging or monitoring purposes.

package main

import (
    "fmt"
    "runtime/debug"
)

func main() {
    fmt.Printf("Stack Trace:\n%s\n", debug.Stack())
}

Symbolic Metadata

Access build information, including dependencies and module versions, using debug.ReadBuildInfo. This is invaluable for debugging version mismatches in production.

package main

import (
    "fmt"
    "runtime/debug"
)

func main() {
    info, ok := debug.ReadBuildInfo()
    if ok {
        fmt.Printf("Build Info:\n%s\n", info.String())
    }
}

Memory Management
The debug.FreeOSMemory function forces the release of unused memory back to the operating system, which can be a lifesaver in resource-constrained environments.

package main

import (
    "fmt"
    "runtime/debug"
)

func triggerGCWithFreeOSMemeory() {
    debug.FreeOSMemory
}

Embedding Files with embed: Simplified Asset Management

Introduced in Go 1.16, the embed package allows you to include files and directories into your Go binaries, making it easier to distribute standalone applications.

package main

import (
    "embed"
    "fmt"
)

//go:embed config.json
var configFile string

func main() {
    fmt.Println("Embedded Config:", configFile)
}

This eliminates the need for external configuration file management during deployment.

Build Tags: Conditional Compilation

Go’s build tags allow you to include or exclude files during compilation based on conditions like OS or architecture.

// +build linux

package main

import "fmt"

func main() {
    fmt.Println("This code runs only on Linux.")
}