Struct Clock 

pub struct Clock { /* private fields */ }

A millisecond clock that only moves when it is told to.

A handle and not a value. Cloning one gives a second handle onto the same reading, which is what lets every stripe of every database on a server read the time a command is being judged against without any of them being told separately. Moving the clock is one store however many stripes there are.

Why a shared reading is not a shared line

It is read on every command on every thread, so the obvious worry is a line that bounces between cores. It does not, because a refresh only writes when the millisecond has actually changed and a turn of the loop is a few microseconds. The reading changes about a thousand times a second and is read millions of times, so the line sits in every core’s cache in the shared state and the writer disturbs it about as often as a timer would.

Implementations

impl Clock

pub fn system() -> Clock

A clock that follows the system, read once now.

pub fn fixed(ms: u64) -> Clock

A clock that reads ms until somebody moves it.

pub fn now_ms(&self) -> u64

The current reading, in milliseconds since the unix epoch.

pub fn refresh(&self)

Take a new reading, which a system clock does from the operating system and a fixed clock does not do at all.

Called once per turn of the shard loop, from the maintenance slice. The store only happens when the millisecond has changed, which is what keeps a reading every thread is looking at from being a line every thread is fighting over.

Shared and not exclusive, because on a server running more than one thread every one of them turns a loop and every one of them refreshes. Two threads that read the operating system a nanosecond apart write the same millisecond, and a thread that reads the field between the two stores gets that millisecond either way.

pub fn set(&self, ms: u64)

Move the clock to ms by hand.

On a system clock the next Clock::refresh will overwrite this, so it is only meaningful on a fixed one.

pub fn advance(&self, ms: u64)

Move a clock forward by ms.

A read and a store and not an add, because it saturates. Nothing moves a clock this way but a test, which is one thread.

pub fn fine_now_ms() -> u64

Read the operating system’s clock right now.

A time before the unix epoch reads as zero rather than failing. There is nothing useful a database can do about a machine whose clock says 1969, and every key expiring immediately is a more honest outcome than a panic on a path that has no error to return.

Trait Implementations

impl Clone for Clock

fn clone(&self) -> Clock

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Clock

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Clock

fn default() -> Clock

Returns the “default value” for a type.