Multi-thread Processing in Rust

Billy Chan — Fri, 07 Oct 2022 15:33:45 +0000

Most program we wrote is single threaded. Since most of the task is IO bound. It make sense to keep it simple by writing a single threaded program. But what if we have a CPU bound task? Let say, cracking a MD5 hash? Don't ask me why cracking MD5 hash, it's just one of CPU intensive task that I can think of, purely for demo purpose.

A naive hashing algorithm will be like this.

// Iterate from 0 util we found the target number
let mut i = 0_u32;
loop {
    // Hash our guessing number and compare with the target hash
    // Stop the loop if we found the target number
    if md5::compute(i.to_string()).eq(&TARGET_HASH) {
        break;
    }
    // What's our next guess?
    i += 1;
}

For the hashing task we can distribute the work to N threads. With each thread start search the target number starting from N and continue the search by incrementing the number by N.

So, for example we've 3 threads. The search space for each thread would be:

Thread 1: 1, 4, 7, 10...
Thread 2: 2, 5, 8, 11...
Thread 3: 3, 6, 9, 12...

That's how we divide the task to N threads with each thread work on a unique and non-overlapping search space.

// A MPSC channel to inform the main thread some worker found the solution
let (tx, rx) = mpsc::channel();
print!("Parallel hashing with {} threads: ", num_workers);

// Spawn workers
for worker in 0..num_workers {
    // Clone the transmission end and move it into the spawned worker
    let tx1 = tx.clone();
    thread::spawn(move || {
        // The guess number start from the worker number
        let mut i = worker;
        // Iterate from 0 util we found the target number
        loop {
            // Hash our guessing number and compare with the target hash
            let hash = md5::compute(i.to_string());
            // Stop the loop if we found the target number
            // And inform the main thread that we found the target number
            if hash.eq(&TARGET_HASH) {
                tx1.send("Found!").unwrap();
                break;
            }
            // What's our next guess?
            i += num_workers;
        }
    });
}

while let Ok(_) = rx.recv() {
    // Exit main thread, this will kill all spawn threads
    break;
}

Source code available on GitHub.

The Question Mark `?` Operator in Rust

Billy Chan — Wed, 05 Oct 2022 16:18:01 +0000

The question mark ? operator is used for early exit an function with return type that's compatible with the value of the ? is used on. Such as Err(e) but not many people know it can be used on None as well.

The ? operator is commonly used with Result<T, E> to propagate error up the call chain. We can define a unified error enum to host all errors. Remember to take advantage of Rust's conversion method From<T> to cast foreign errors into the unified error enum. That way, we take advantage of ? operator, it will perform the conversion behind the scene.

// Unified `Error` enum
#[derive(Debug)]
enum Error {
    ParseIntError(std::num::ParseIntError),
    ParseFloatError(std::num::ParseFloatError),
}

impl std::fmt::Display for Error {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Self::ParseIntError(e) => write!(f, "ParseIntError: {}", e.to_string()),
            Self::ParseFloatError(e) => write!(f, "ParseFloatError: {}", e.to_string()),
        }
    }
}

impl std::error::Error for Error {}

// Convert `std::num::ParseIntError` to `Error`
impl From<std::num::ParseIntError> for Error {
    fn from(err: std::num::ParseIntError) -> Self {
        Self::ParseIntError(err)
    }
}

// Convert `std::num::ParseFloatError` to `Error`
impl From<std::num::ParseFloatError> for Error {
    fn from(err: std::num::ParseFloatError) -> Self {
        Self::ParseFloatError(err)
    }
}

fn main() -> Result<(), Error> {
    // Parse an integer and unwrap it, or throw `Error::ParseIntError`
    let _: i32 = "123".parse()?;
    let _: i32 = "not_an_integer".parse()?;

    // Parse a float and unwrap it, or throw `Error::ParseFloatError`
    let _: f64 = "not_a_number".parse()?;

    Ok(())
}

The ? operator could also perform early return on Option<T> return type.

fn get_first_char_of_second_word(phrase: &str) -> Option<char> {
    // Return `None` if the phrase consist of a single word
    phrase.split(" ").skip(1).next()?.chars().next()
}

fn main() {
    assert_eq!(get_first_char_of_second_word("Hello World"), Some('W'));
    assert_eq!(get_first_char_of_second_word("Hello?"), None);
}

DEV Community: Billy Chan

Multi-thread Processing in Rust

The Question Mark `?` Operator in Rust