Advent of Code Day 5 parallel

extern crate crypto;
extern crate num_cpus;

use crypto::md5::Md5;
use crypto::digest::Digest;
use std::fmt::Write;
use std::io;
use std::thread;
use std::sync::mpsc::channel;
use std::u64;

#[derive(Clone, Copy, Debug)]
enum ThMsg {
    Digit(usize, char, u64),
    GroupSync,
}

use ThMsg::{Digit, GroupSync};

#[derive(Clone, Copy, Debug)]
enum MainMsg {
    Ack,
}

use MainMsg::Ack;

#[inline]
fn to_hex(n: u8) -> char {
    match n {
        0...9 => (('0' as u8) + n) as char,
        10...15 => (('a' as u8) + n - 10) as char,
        _ => '#',
    }
}

fn main() {
    let mut sh = Md5::new();
    sh.input_str("ojvtpuvg");

    let thcnt = num_cpus::get() as u64;
    println!("Starting {} threads", thcnt);

    let (thtx, mainrx) = channel();

    let mut maintxs = vec![];

    // create threads
    for i in 0..thcnt {
        let thtx = thtx.clone();
        let (maintx, thrx) = channel();
        maintxs.push(maintx);

        thread::spawn(move||{
            let mut idx = i;
            let mut buf = String::with_capacity(10);
            let mut syncpoint = 1_000_000;
            let syncstep = 1_000_000;
            let mut res = [0u8; 16];
            loop {
                let mut sh1 = sh.clone();
                write!(&mut buf, "{}", idx).unwrap();
                sh1.input_str(&buf);
                buf.clear();
                sh1.result(&mut res);
                if res[0] == 0 && res[1] == 0 && res[2]>>4 == 0 {
                    let i = (res[2] & 0xf) as usize;
                    if i < 8 {
                        thtx.send(Digit(i, to_hex(res[3]>>4), idx)).unwrap();
                    }
                }
                idx += thcnt;
                if idx >= syncpoint {
                    thtx.send(GroupSync).unwrap();
                    // wait other threads
                    thrx.recv().unwrap();
                    syncpoint += syncstep;
                }
            }
        });
    }

    // collect thread data
    let mut code2 = vec![(0xffff_ffff_ffff_ffffu64 ,'_'); 8];
    let mut synccnt = 0;
    loop {
        match mainrx.recv().unwrap() {
            GroupSync => {
                synccnt += 1;
                if synccnt == thcnt {
                    // all threads reached GroupSync state
                    // check for completion
                    if code2.iter().all(|&(_, ch)| ch != '_') {
                        println!("");
                        for &(_, ch) in &code2 {
                            print!("{}", ch);
                        }
                        println!("");
                        // done
                        break;
                    }
                    synccnt = 0;
                    // allow threads to continue
                    for tx in &maintxs {
                        tx.send(Ack).unwrap();
                    };
                };
            },
            Digit(i, ch, idx) => {
                if code2[i].0 > idx {
                    code2[i] = (idx, ch);
                }
                print!("Decoding: ");
                for &(_, c) in &code2 {
                    print!("{}", if c == '_' {ch} else {c});
                }
                print!("\r");
                io::Write::flush(&mut io::stdout()).unwrap();
            },
        }
    }
}