CODEWITHSUNDEEP
rustlibc
Harvey Adcock
Harvey Adcock

Reputation: 971

Is there a Rust equivalent to the clock function in C++?

I'm trying to test the efficiency of parts of my code, and C++ has a clock function in ctime that allows measurement of the processor time consumed by the program using the clock_t type. Is there some Rust equivalent that isn't just measuring the absolute time between two points in the code?

Upvotes: 7

Views: 1740

Answers (2)

malbarbo
malbarbo

Reputation: 11177

I've been using this code:

extern crate libc;

use std::mem;
use std::io;
use std::time::Duration;

pub fn cpu_time() -> Duration {
    unsafe {
        let mut tp = mem::uninitialized();
        if sys::clock_gettime(sys::CLOCK_PROCESS_CPUTIME_ID, &mut tp) == 0 {
            Duration::new(tp.tv_sec as u64, tp.tv_nsec as u32)
        } else {
            panic!("cpu_time: {}", io::Error::last_os_error());
        }
    }
}

mod sys {
    use libc::{c_int, timespec};
    extern "C" {
        pub fn clock_gettime(clk_id: c_int, tp: *mut timespec) -> c_int;
    }
    pub const CLOCK_PROCESS_CPUTIME_ID: c_int = 2;
}

Upvotes: 3

Shepmaster
Shepmaster

Reputation: 430663

If it's required to use clock, then you will need to add a bit of a shim. At least on OS X, it appears that libc doesn't expose clock, but it does give you clock_t (which is the harder part of the equation). Exposing clock is then straight-forward: 

extern crate libc;

mod ffi {
    extern {
        pub fn clock() -> ::libc::clock_t;
    }
}

fn main() {
    let start = unsafe { ffi::clock() };

    let mut dummy = 0;
    for i in 0..20000 { dummy += i };

    let end = unsafe { ffi::clock() };
    println!("{}, {}, {}, {}", dummy, start, end, end - start);
}

I'd probably make a wrapper that marks clock as safe to call in any circumstance though.

Upvotes: 5

Related Questions