Performance Optimization and Unsafe Rust

# CHAPTER 29

Performance Optimization and Unsafe Rust #

1. Chapter Introduction #

2. Learning Objectives #

• Compile Rust code using the --release flag for maximum optimization.

• Understand what the unsafe keyword does (and doesn't) do.

• Dereference raw pointers.

• Call external C functions using FFI (Foreign Function Interface).

• Implement an unsafe trait safely.

3. The --release Flag #

When you are ready to deploy to a production server or run a benchmark, you MUST use the release flag:

cargo build --release

This tells the LLVM backend compiler to aggressively optimize your code (loop unrolling, inlining functions). Code compiled with --release can run 10x to 100x faster than debug code!

4. What is unsafe Rust? #

1. 1. Dereference a raw pointer.

1. 2. Call an unsafe function (or a C function).

1. 3. Access or modify a mutable static variable.

1. 4. Implement an unsafe trait.

Crucially: unsafe does NOT turn off the Borrow Checker! It only unlocks these four specific abilities.

5. Raw Pointers #

• They are allowed to ignore borrowing rules (you can have multiple mutable pointers to the same data).

• They are NOT guaranteed to point to valid memory (they can be null or dangling).

You can *create* a raw pointer in safe Rust, but you can only *dereference* (read/write) it inside an unsafe block.

fn main() {
    let mut num = 5;

    // Create raw pointers (Safe)
    let r1 = &num as *const i32;
    let r2 = &mut num as *mut i32;

    // Dereference raw pointers (UNSAFE!)
    unsafe {
        println!("r1 is: {}", *r1);
        *r2 = 10;
        println!("r2 is now: {}", *r2);
    }
}

6. Foreign Function Interface (FFI) #

// Declare the external C function
extern "C" {
    fn abs(input: i32) -> i32;
}

fn main() {
    unsafe {
        // Calling the C function inside an unsafe block
        println!("Absolute value of -3 according to C: {}", abs(-3));
    }
}

7. Mutable Static Variables #

static mut COUNTER: u32 = 0;

fn add_to_count(inc: u32) {
    unsafe {
        COUNTER += inc;
    }
}

fn main() {
    add_to_count(3);
    unsafe {
        println!("COUNTER: {}", COUNTER);
    }
}

*(Best Practice: Avoid static mut. Use Arc<Mutex<T>> for global state instead!)*

8. Common Mistakes #

• Deploying Debug Builds: Running cargo run on a production server. Always use cargo build --release and run the binary from target/release/.

• Abusing unsafe: Some developers get frustrated by the Borrow Checker and wrap their whole app in unsafe blocks to use C-style pointers. This defeats the entire purpose of using Rust.

9. Best Practices #

• Encapsulate unsafe: If you must use unsafe (like wrapping a C library), build a safe Rust wrapper around it. The external user of your library should only call safe Rust functions, while the unsafe code is isolated and heavily audited internally.

10. Exercises #

1. 1. Write a program that loops 10 million times and does math.

1. 2. Run it using cargo run. Note how long it takes.

1. 3. Run it using cargo run --release. Be amazed at the speed difference.

11. MCQs with Answers #

Q3. Are raw pointers (*const T) guaranteed to be valid and not null? a) Yes b) No, unlike references, raw pointers can be null or dangling Answer: b) No.

Q4. Can you create a raw pointer in Safe Rust? a) Yes b) No Answer: a) Yes (You just can't dereference it outside of an unsafe block).

12. Interview Questions #

• Q: Explain what the unsafe keyword does in Rust. Why does Rust include it if the goal of the language is safety? (Answer: Because interacting with hardware, operating systems, and C libraries inherently requires trusting the programmer over the compiler).

• Q: What is the difference between a Reference (&) and a Raw Pointer (*const) in Rust?

13. Summary #

14. Next Chapter Recommendation #