Add Instant monotonicity section

Author: Mark-Simulacrum

posts/2022-04-07-Rust-1.60.0.md

@@ -124,6 +124,32 @@ In this example, enabling the serde feature will enable the serde dependency. It
 
 Incremental compilation is re-enabled for the 1.60 release. The Rust team continues to work on fixing bugs in incremental, but no problems causing widespread breakage are known at this time, so we have chosen to reenable incremental compilation. Additionally, the compiler team is continuing to work on long-term strategy to avoid future problems of this kind. That process is in relatively early days, so we don't have anything to share yet on that front.
 
+### `Instant` monotonicity guarantees
+
+On all platforms `Instant` will try to use an OS API that guarantees monotonic
+behavior if available (which is the case on all tier 1 platforms). In practice
+such guarantees are -- under rare circumstances -- broken by hardware,
+virtualization or operating system bugs. To work around these bugs and platforms
+not offering monotonic clocks `Instant::duration_since`, `Instant::elapsed` and
+`Instant::sub` saturate to zero. In older Rust versions this lead to a panic
+instead. `Instant::checked_duration_since` can be used to detect and handle
+situations where monotonicity is violated, or `Instant`s are subtracted in the
+wrong order.
+
+This workaround obscures programming errors where earlier and later instants are
+accidentally swapped. For this reason future Rust versions may reintroduce
+panics in at least those cases.
+
+Prior to 1.60, the monotonicity guarantees were provided through mutexes or
+atomics in std, which can introduce large performance overheads to
+`Instant::now()`. Additionally, the panicking behavior meant that Rust software
+could panic in a subset of environments, which was largely undesirable, as the
+authors of that software may not be in a place to upgrade the operating system,
+hardware, or virtualization system they are running on. Further, introducing
+unexpected panics into these environments make Rust software less reliable and
+portable, which is of higher concern than exposing typically uninteresting
+platform bugs to end users.
+
 ### Stabilized APIs
 
 The following methods and trait implementations are now stabilized: