Struct RandomxVm 

pub struct RandomxVm<'a, T: 'a> { /* private fields */ }

Implementations

impl RandomxVm<'_, RandomxCache>

pub fn new( flags: RandomxFlags, cache: &RandomxCache, ) -> Result<Self, RandomxError>

impl RandomxVm<'_, RandomxDataset>

pub fn new_fast( flags: RandomxFlags, dataset: &RandomxDataset, ) -> Result<Self, RandomxError>

Examples found in repository

examples/multithreaded.rs (line 32)

fn main() {
    const NUM_THREADS: u32 = 8;
    // number of hashes to perform in each thread, not the total.
    const NUM_HASHES: u32 = 5000;

    let start = Instant::now();

    // Try adding `| RandomxFlags::LARGEPAGES`.
    let flags = RandomxFlags::default() | RandomxFlags::FULLMEM;
    let dataset = Arc::new(RandomxDataset::new(flags, b"key", NUM_THREADS as u8).unwrap());

    println!("Dataset initialised in {}ms", start.elapsed().as_millis());

    let mut handles = Vec::new();

    let start = Instant::now();

    for i in 0..NUM_THREADS {
        let dataset = dataset.clone();

        handles.push(thread::spawn(move || {
            let mut nonce: u32 = i;
            let vm = RandomxVm::new_fast(flags, &dataset).unwrap();

            for _ in 0..NUM_HASHES {
                let _ = vm.hash(&nonce.to_be_bytes());

                // e.g. thread 0 will use nonces 0, 8, 16, ...
                // and thread 1 will use nonces 1, 9, 17, ...
                nonce += NUM_THREADS;
            }
        }));
    }

    for handle in handles {
        let _ = handle.join();
    }

    println!(
        "Completed {} hashes in {}ms",
        NUM_THREADS * NUM_HASHES,
        start.elapsed().as_millis()
    );
}

impl<T> RandomxVm<'_, T>

pub fn hash(&self, input: &[u8]) -> [u8; 32]

Calculate the RandomX hash of some data.

use randomx_bindings::*;
let flags = RandomxFlags::default();
let cache = RandomxCache::new(flags, "key".as_bytes())?;
let vm = RandomxVm::new(flags, &cache)?;
let hash = vm.hash("input".as_bytes());

Examples found in repository

examples/multithreaded.rs (line 35)

fn main() {
    const NUM_THREADS: u32 = 8;
    // number of hashes to perform in each thread, not the total.
    const NUM_HASHES: u32 = 5000;

    let start = Instant::now();

    // Try adding `| RandomxFlags::LARGEPAGES`.
    let flags = RandomxFlags::default() | RandomxFlags::FULLMEM;
    let dataset = Arc::new(RandomxDataset::new(flags, b"key", NUM_THREADS as u8).unwrap());

    println!("Dataset initialised in {}ms", start.elapsed().as_millis());

    let mut handles = Vec::new();

    let start = Instant::now();

    for i in 0..NUM_THREADS {
        let dataset = dataset.clone();

        handles.push(thread::spawn(move || {
            let mut nonce: u32 = i;
            let vm = RandomxVm::new_fast(flags, &dataset).unwrap();

            for _ in 0..NUM_HASHES {
                let _ = vm.hash(&nonce.to_be_bytes());

                // e.g. thread 0 will use nonces 0, 8, 16, ...
                // and thread 1 will use nonces 1, 9, 17, ...
                nonce += NUM_THREADS;
            }
        }));
    }

    for handle in handles {
        let _ = handle.join();
    }

    println!(
        "Completed {} hashes in {}ms",
        NUM_THREADS * NUM_HASHES,
        start.elapsed().as_millis()
    );
}

Trait Implementations

impl<T> Drop for RandomxVm<'_, T>

fn drop(&mut self)

Executes the destructor for this type.

impl<T> Send for RandomxVm<'_, T>