Function mine

src/main.rs:31–108

(
    function_name: &SmallString,
    function_params: &SmallString,
    selector: u32,
    num_threads: usize,
)

}

fn mine<const N: usize>(
    function_name: &SmallString,
    function_params: &SmallString,
    selector: u32,
    num_threads: usize,
) {
    let end = 0xfffffffff0000000u64;
    let go = AtomicBool::new(true);

    #[cfg(target_feature = "avx2")]
    const STEP: u64 = 4;
    #[cfg(not(target_feature = "avx2"))]
    const STEP: u64 = 1;

    ThreadPoolBuilder::new()
        .num_threads(num_threads)
        .build_global()
        .expect("Failed to create thread pool.");

    println!("Starting mining with {num_threads} threads.");

    let stopwatch = Instant::now();

    (0..num_threads).into_par_iter().for_each(|thread_idx| {
        let mut idx = 0u64;
        let mut nonce = thread_idx as u64 * STEP;
        let step = num_threads as u64 * STEP;
        while nonce < end {
            nonce += step;
            if !go.load(Ordering::Relaxed) {
                break;
            }

            #[cfg(not(target_feature = "avx2"))]
            {
                log_progress!(thread_idx, idx, 0x3fffff, nonce);

                let mut s0 = Sponge::default();
                unsafe { s0.fill::<N>(&function_name, nonce, &function_params) };

                if selector == unsafe { s0.compute_selectors() } {
                    let out = unsafe {
                        s0.fill_and_get_name::<N>(&function_name, nonce, &function_params)
                    };
                    log_result_and_break!(out, stopwatch, go);
                }
            }
            #[cfg(target_feature = "avx2")]
            {
                log_progress!(thread_idx, idx, 0x1fffff, nonce);

                let mut sponges =
                    unsafe { SpongesAvx::new::<N>(&function_name, nonce, &function_params) };

                let maybe_idx = unsafe {
                    sponges
                        .compute_selectors()
                        .iter()