Function main

src/main.rs:110–161

()

}

fn main() {
    #[cfg(target_feature = "avx2")]
    println!("AVX2 enabled.");
    #[cfg(not(target_feature = "avx2"))]
    println!("AVX2 disabled.");

    let args: Vec<String> = env::args().collect();
    if args.len() < 4 {
        println!("Usage: <function name> <function params> <target selector> [num_threads]");
        process::exit(-1);
    }

    // Remove any leading 0x.
    let selector = args[3].to_lowercase();
    let selector = selector.trim_start_matches("0x");
    let selector = u32::from_str_radix(selector, 16)
        .expect("Invalid number.")
        .to_be();
    let function_name = SmallString::new(&args[1]);
    let function_params = SmallString::new(&args[2]);

    if function_name.length + function_params.length >= 115 {
        println!("Total length of <function name> and <function params> must be under 115 bytes.");
        process::exit(-1);
    }

    if std::mem::size_of::<u64>() != 8 {
        println!("Incompatible architecture.");
        println!("u64: {}", std::mem::size_of::<u64>());
        process::exit(-1);
    }

    println!("Function name: {}", args[1]);
    println!("Function params: {}", args[2]);
    println!(
        "Target selector: 0x{}",
        &(&format!("{:x}", (selector.to_be() as u64) | 0x0100000000))[1..]
    );

    let num_threads: usize = match args.get(4) {
        Some(value) => value
            .parse::<usize>()
            .expect("Failed to parse number of threads"),
        None => num_cpus::get(), // If args[4] is None, use the default value
    };

    if function_name.length <= 64 && function_params.length <= 64 {
        mine::<64>(&function_name, &function_params, selector, num_threads);
    } else {
        mine::<0>(&function_name, &function_params, selector, num_threads);
    }
}