update original

Author: funkill

rust-cookbook/ci/dictionary.txt

@@ -365,6 +365,7 @@ symphonia
 syslog
 SyslogError
 SystemRandom
+systemtime
 SystemTime
 SystemTimeError
 tcpip

rust-cookbook/src/datetime.md

@@ -3,6 +3,9 @@
 | Recipe | Crates | Categories |
 |--------|--------|------------|
 | [Measure elapsed time][ex-measure-elapsed-time] | [![std-badge]][std] | [![cat-time-badge]][cat-time] |
+| [Deadline arithmetic with Duration][ex-deadline-arithmetic-std] | [![std-badge]][std] | [![cat-time-badge]][cat-time] |
+| [Convert SystemTime to UNIX timestamp][ex-convert-to-unix-timestamp-std] | [![std-badge]][std] | [![cat-time-badge]][cat-time] |
+| [Benchmark a closure with Instant][ex-benchmark-closure] | [![std-badge]][std] | [![cat-time-badge]][cat-time] |
 | [Perform checked date and time calculations][ex-datetime-arithmetic] | [![chrono-badge]][chrono] | [![cat-date-and-time-badge]][cat-date-and-time] |
 | [Convert a local time to another timezone][ex-convert-datetime-timezone] | [![chrono-badge]][chrono] | [![cat-date-and-time-badge]][cat-date-and-time] |
 | [Examine the date and time][ex-examine-date-and-time] | [![chrono-badge]][chrono] | [![cat-date-and-time-badge]][cat-date-and-time] |
@@ -11,6 +14,9 @@
 | [Parse string into DateTime struct][ex-parse-datetime] | [![chrono-badge]][chrono] | [![cat-date-and-time-badge]][cat-date-and-time] |
 
 [ex-measure-elapsed-time]: datetime/duration.html#measure-the-elapsed-time-between-two-code-sections
+[ex-deadline-arithmetic-std]: datetime/duration.html#deadline-arithmetic-with-instant
+[ex-convert-to-unix-timestamp-std]: datetime/duration.html#convert-systemtime-to-unix-timestamp
+[ex-benchmark-closure]: datetime/duration.html#benchmark-a-closure-with-instant
 [ex-datetime-arithmetic]: datetime/duration.html#perform-checked-date-and-time-calculations
 [ex-convert-datetime-timezone]: datetime/duration.html#convert-a-local-time-to-another-timezone
 [ex-examine-date-and-time]: datetime/parse.html#examine-the-date-and-time

rust-cookbook/src/datetime/duration.md

@@ -2,6 +2,12 @@
 
 {{#include duration/profile.md}}
 
+{{#include duration/deadline.md}}
+
+{{#include duration/convert_to_unix.md}}
+
+{{#include duration/benchmark.md}}
+
 {{#include duration/checked.md}}
 
 {{#include duration/timezone.md}}

rust-cookbook/src/datetime/duration/benchmark.md

@@ -0,0 +1,56 @@
+## Benchmark a closure with `Instant`
+
+[![std-badge]][std] [![cat-time-badge]][cat-time]
+
+Initializes a `weights` vector, calculates half of its total sum into `half_load`,
+and uses `benchmark` to measure the performance of `subset_sum` which takes a slice of weights and a target value and finds a subset whose weights sum to the target.
+
+`benchmark` measures the average time required to call a closure a specified number of times using [`Instant::now`] and [`Instant::elapsed`].
+It uses [`black_box`] to prevent the compiler from optimizing away the closure's computation since its return value is ignored.
+
+```rust,edition2021
+use std::time::{Duration, Instant};
+
+fn subset_sum(weights: &[u64], target: u64) -> Option<u32> {
+    for mask in 0..1u32 << weights.len() {
+        let sum: u64 = weights
+            .iter()
+            .enumerate()
+            .filter(|(i, _)| mask >> i & 1 == 1)
+            .map(|(_, weight)| weight)
+            .sum();
+
+        if sum == target {
+            return Some(mask);
+        }
+    }
+    None
+}
+
+fn benchmark<F, T>(runs: u32, mut f: F) -> Duration
+where
+    F: FnMut() -> T,
+{
+    let start = Instant::now();
+
+    for _ in 0..runs {
+        std::hint::black_box(f());
+    }
+
+    start.elapsed() / runs
+}
+
+fn main() {
+    let weights: Vec<u64> = (1..=18).map(|kg| kg * 2).collect();
+    let half_load = weights.iter().sum::<u64>() / 2;
+
+    for parcels in 12..=weights.len() {
+        let mean = benchmark(3, || subset_sum(&weights[..parcels], half_load));
+        println!("{:2} parcels: {:>10.2?}", parcels, mean);
+    }
+}
+```
+
+[`Instant::now`]: https://doc.rust-lang.org/std/time/struct.Instant.html#method.now
+[`Instant::elapsed`]: https://doc.rust-lang.org/std/time/struct.Instant.html#method.elapsed
+[`black_box`]: https://doc.rust-lang.org/std/hint/fn.black_box.html

rust-cookbook/src/datetime/duration/convert_to_unix.md

@@ -0,0 +1,23 @@
+## Convert `SystemTime` to Unix timestamp
+
+[![std-badge]][std] [![cat-time-badge]][cat-time]
+
+Converts the current [`SystemTime`] to seconds since the Unix epoch, then computes the original time
+by adding the unix timestamp to [`SystemTime::UNIX_EPOCH`] constant.
+
+```rust,edition2021
+use std::time::{SystemTime, SystemTimeError};
+
+fn main() -> Result<(), SystemTimeError> {
+    let now = SystemTime::now();
+    let since_unix_epoch = now.duration_since(SystemTime::UNIX_EPOCH)?;
+    println!("Unix timestamp: {}", since_unix_epoch.as_secs());
+
+    let from_unix_timestamp = SystemTime::UNIX_EPOCH + since_unix_epoch;
+    println!("Back to SystemTime: {:?}", from_unix_timestamp);
+
+    Ok(())
+}
+```
+[`SystemTime`]: https://doc.rust-lang.org/std/time/struct.SystemTime.html
+[`SystemTime::UNIX_EPOCH`]: https://doc.rust-lang.org/std/time/struct.SystemTime.html#associatedconstant.UNIX_EPOCH

rust-cookbook/src/datetime/duration/deadline.md

@@ -0,0 +1,26 @@
+## Deadline arithmetic with `Instant`
+
+[![std-badge]][std] [![cat-time-badge]][cat-time]
+
+Calculates a one second [`Duration`]. Computes `deadline` one second from [`Instant::now`].
+Sleeps for one second and compares `deadline` with [`Instant::now`] to check if the deadline has passed.
+
+```rust,edition2021
+# use std::thread;
+use std::time::{Duration, Instant};
+# fn sleep(duration: Duration) {
+#    thread::sleep(duration);
+# }
+
+fn main() {
+    let one_second = Duration::from_secs(1);
+    let deadline = Instant::now() + one_second;
+
+    sleep(Duration::from_secs(1));
+    if Instant::now() > deadline {
+        println!("Deadline has passed");
+    }
+}
+```
+[`Duration`]: https://doc.rust-lang.org/std/time/struct.Duration.html
+[`Instant::now`]: https://doc.rust-lang.org/std/time/struct.Instant.html#method.now