Added sleep_until functionality.

[ErisianArchitect]

I felt like sleep_until functionality was missing, so I added it in. I hope that's alright.

[alexheretic]

Could be implemented simply as:

Suggested change

	let accuracy = Duration::new(0, self.native_accuracy_ns);
	let start = Instant::now();
	let duration = instant.duration_since(start);
	if duration > accuracy {
	native_sleep(duration - accuracy);
	}
	// spin until instant
	while Instant::now() < instant {
	match self.spin_strategy {
	SpinStrategy::YieldThread => thread::yield_now(),
	SpinStrategy::SpinLoopHint => std::hint::spin_loop(),
	}
	}
	self.sleep(instant.saturating_duration_since(Instant::now()))

That would mean calling Instant::now() twice, we can also avoid the 2 calls by having a private fn sleep that takes both duration & start instant. But maybe this detail isn't really a big deal anyway so I'd be ok with the simpler version.

[ErisianArchitect]

self.sleep calls Instant::now() as well, so there would still be two calls. I'm not entirely sure what you mean by the private sleep fn. Wouldn't that just be the same thing?

[alexheretic]

The private fn would exist to solve that problem:

    fn sleep_from(self, start: Instant, duration: Duration) {
        let accuracy = Duration::new(0, self.native_accuracy_ns);
        if duration > accuracy {
            native_sleep(duration - accuracy);
        }
        // spin the rest of the duration
        while start.elapsed() < duration {
            match self.spin_strategy {
                SpinStrategy::YieldThread => thread::yield_now(),
                SpinStrategy::SpinLoopHint => std::hint::spin_loop(),
            }
        }
    }

    pub fn sleep(self, duration: Duration) {
        self.sleep_from(Instant::now(), duration)
    }

    pub fn sleep_until(self, deadline: Instant) {
        let start = Instant::now();
        self.sleep_from(start, deadline.saturating_duration_since(start))
    }

[ErisianArchitect]

elapsed() also calls Instant::now().

pub fn elapsed(&self) -> Duration {
    Instant::now() - *self
}

[ErisianArchitect]

At least by comparing Instant::now() against instant you save an instruction.

(Instant::now() - *self) < duration

compared to

Instant::now() < instant

[alexheretic]

elapsed() also calls Instant::now().

Yeah but there is no getting around calling now() in the spin loop. I'd rather both methods had common implementations.

[ErisianArchitect]

What if sleep_until was the common implementation that sleep called?

[alexheretic]

That's possible, but I don't think it makes quite as much sense. The first thing you have to do in sleep_until is compute the sleep duration, so we can compare to native sleep accuracy, so "sleeping a duration" seems to be the more founding operation to base both fns on.

start.elapsed() < duration vs Instant::now() < deadline is an implementation detail that applies to either impl (ie we could change that in sleep now regardless of sleep_until existence) so I don't think it is relevant.

[alexheretic]

Thanks yeah I think having this makes sense 👍