diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index cc4211e..5149ff9 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -30,8 +30,8 @@ jobs: runs-on: ${{ matrix.os }} strategy: matrix: - rust_version: ['1.60.0', 'stable', 'nightly'] - os: [ubuntu-20.04, ubuntu-22.04, macOS-11, macOS-12, windows-2019, windows-2022] + rust_version: ['1.70.0', 'stable', 'nightly'] + os: [ubuntu-22.04, ubuntu-24.04, macOS-13, macOS-14, windows-2019, windows-2022] steps: - uses: actions/checkout@v3 - name: Install Rust ${{ matrix.rust_version }} @@ -74,6 +74,42 @@ jobs: run: cross +nightly test --target ${{ matrix.target }} --no-default-features --features=prost -- --test-threads=1 env: RUSTFLAGS: "-C opt-level=1" + test-wasm-browser: + name: Test ${{ matrix.rust_version }}/${{ matrix.os }} (wasm32-unknown-unknown) + runs-on: ${{ matrix.os }} + strategy: + matrix: + rust_version: ['1.70.0', 'stable', 'nightly'] + os: [ubuntu-22.04, ubuntu-24.04, macOS-13, macOS-14, windows-2019, windows-2022] + steps: + - uses: actions/checkout@v3 + - name: Install Rust ${{ matrix.rust_version }} + run: rustup default ${{ matrix.rust_version }} + - name: Install wasm32-unknown-unknown target + run: rustup target add wasm32-unknown-unknown + - name: Install wasm-pack + run: cargo install wasm-pack + - name: Run Tests + run: wasm-pack test --node + test-wasi: + name: Test ${{ matrix.rust_version }}/${{ matrix.os }} (wasm32-wasi) + runs-on: ${{ matrix.os }} + strategy: + matrix: + rust_version: ['1.70.0', 'stable', 'nightly'] + os: [ubuntu-22.04, ubuntu-24.04, macOS-13, macOS-14, windows-2019, windows-2022] + steps: + - uses: actions/checkout@v3 + - name: Install Rust ${{ matrix.rust_version }} + run: rustup default ${{ matrix.rust_version }} + - name: Install wasm32-wasi target + run: rustup target add wasm32-wasi + - name: Install cargo-wasi + run: cargo install cargo-wasi + - name: Install wasmtime + run: curl https://wasmtime.dev/install.sh -sSf | bash + - name: Run Tests + run: cargo wasi test docs: runs-on: ubuntu-latest env: diff --git a/README.md b/README.md index 555f126..0b3b21b 100644 --- a/README.md +++ b/README.md @@ -15,8 +15,8 @@ [crate]: https://crates.io/crates/quanta [docs]: https://docs.rs/quanta -__quanta__ is a high-speed timing library, useful for getting the current time _very quickly_, as -well as manipulating it. +__quanta__ is a high-speed timing library, useful for getting the current time _very quickly_, as well as manipulating +it. ## code of conduct @@ -36,10 +36,10 @@ The API documentation of this library can be found at [docs.rs/quanta](https://d ## platform / architecture support -For most major platforms -- Linux, Windows, and macOS -- with processors made around or after 2008, -you should have no problems using `quanta` with full TSC support. `quanta` will always fallback to -the included stdlib timing facilities if TSC support is not present. The biggest caveat to this, as -evidenced in the compatibility matrix below, is that we only support the TSC on x86/x86_64 platforms. +For most major platforms -- Linux, Windows, and macOS -- with processors made around or after 2008, you should have no +problems using `quanta` with full TSC support. `quanta` will always fallback to the included stdlib timing facilities if +TSC support is not present. The biggest caveat to this, as evidenced in the compatibility matrix below, is that we only +support the TSC on `x86`/`x86_64` platforms. | Platform | stdlib fallback | TSC support? | CI tests? | @@ -54,17 +54,17 @@ evidenced in the compatibility matrix below, is that we only support the TSC on ## performance -`quanta` sits neck-and-neck with native OS time facilities: the cost of `Clock::now` is on par -`Instant::now` from the stdlib, if not better. +`quanta` sits neck-and-neck with native OS time facilities: the cost of `Clock::now` is on par `Instant::now` from the +stdlib, if not better. ## why use this over stdlib? -Beyond having a performance edge in specific situations, the ability to use mocked time makes it -easier to actually test that your application is doing the right thing when time is involved. +Beyond having a performance edge in specific situations, the ability to use mocked time makes it easier to actually test +that your application is doing the right thing when time is involved. -Additionally, and as mentioned in the general features section, `quanta` provides a safe/thin -wrapper over accessing the Time Stamp Counter, which allows measuring cycle counts over short -sections of code. This can be relevant/important for accurately measuring performance-critical sections of code. +Additionally, and as mentioned in the general features section, `quanta` provides a safe/thin wrapper over accessing the +Time Stamp Counter, which allows measuring cycle counts over short sections of code. This can be relevant/important for +accurately measuring performance-critical sections of code. ## alternative crates diff --git a/src/instant.rs b/src/instant.rs index 8ed226d..1e57dbe 100644 --- a/src/instant.rs +++ b/src/instant.rs @@ -292,8 +292,6 @@ mod tests { ignore = "WASM thread cannot sleep" )] fn test_now() { - let _guard = RECENT_LOCK.lock().unwrap(); - let t0 = Instant::now(); thread::sleep(Duration::from_millis(15)); let t1 = Instant::now(); @@ -328,8 +326,8 @@ mod tests { let threshold = Duration::from_millis(14); assert!( result > threshold, - "t1 should be greater than t0 by at least 14ms, was only {}ms (t0: {}, t1: {})", - result.as_millis(), + "t1 should be greater than t0 by at least 14ms, was only {:?} (t0: {}, t1: {})", + result, t0.0, t1.0 ); diff --git a/src/lib.rs b/src/lib.rs index 605ed99..24b699e 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -452,6 +452,7 @@ impl Clock { } #[cfg(test)] + #[allow(dead_code)] fn reset_timebase(&mut self) -> bool { match &mut self.inner { ClockType::Counter(reference, source, calibration) => { @@ -541,15 +542,16 @@ fn mul_div_po2_u64(value: u64, numer: u64, denom: u32) -> u64 { #[cfg(test)] mod tests { - use super::{Clock, Counter, Monotonic}; - use average::{Merge, Variance}; - use std::time::{Duration, Instant}; + use super::Clock; - #[cfg(all(target_arch = "wasm32", target_os = "unknown"))] - mod configure_wasm_tests { - // Until https://github.com/rustwasm/wasm-bindgen/issues/2571 is resolved, these tests will only run in browsers. - wasm_bindgen_test::wasm_bindgen_test_configure!(run_in_browser); - } + #[cfg(not(target_arch = "wasm32"))] + use super::{Counter, Monotonic}; + + #[cfg(not(target_arch = "wasm32"))] + use average::{Merge as _, Variance}; + + #[cfg(not(target_arch = "wasm32"))] + use std::time::{Duration, Instant}; #[test] #[cfg_attr( @@ -595,13 +597,9 @@ mod tests { assert!(scaled.0 > 0); } + #[cfg(not(target_arch = "wasm32"))] #[test] #[cfg_attr(not(feature = "flaky_tests"), ignore)] - #[cfg_attr( - all(target_arch = "wasm32", target_os = "unknown"), - wasm_bindgen_test::wasm_bindgen_test - )] - fn test_reference_source_calibration() { let mut clock = Clock::new(); let reference = Monotonic::default(); @@ -619,10 +617,10 @@ mod tests { // not matching our calculation of wall-clock time to the system's calculation of wall-clock time, in terms // of their absolute values. // - // As the system adjusts its clocks over time, whether due to NTP skew, or delays in updating the derived monotonic - // time, and so on, our original measurement base from the reference source -- which we use to anchor how we - // convert our scaled source measurement into the same reference timebase -- can skew further away from the - // current reference time in terms of the rate at which it ticks forward. + // As the system adjusts its clocks over time, whether due to NTP skew, or delays in updating the derived + // monotonic time, and so on, our original measurement base from the reference source -- which we use to + // anchor how we convert our scaled source measurement into the same reference timebase -- can skew further + // away from the current reference time in terms of the rate at which it ticks forward. // // Essentially, what we're saying here is that we want to test the scaling ratio that we generated in // calibration, but not necessarily that the resulting value -- which is meant to be in the same timebase as @@ -682,12 +680,9 @@ mod tests { assert!(overall.mean() < 1000.0); } + #[cfg(not(target_arch = "wasm32"))] #[test] #[cfg_attr(not(feature = "flaky_tests"), ignore)] - #[cfg_attr( - all(target_arch = "wasm32", target_os = "unknown"), - wasm_bindgen_test::wasm_bindgen_test - )] fn measure_source_reference_self_timing() { let source = Counter::default(); let reference = Monotonic::default();