Reduce the size of Duration to 8 bytes

Cargo.toml

@@ -127,6 +127,7 @@ twoway = "0.2.0"
 ordered-float = "1.0"
 nom = "5.0.0-beta1"
 servo_arc = "0.1.1"
+bitfield = "0.13.2"
 profiler = { path = "components/profiler" }
 mime = "0.3.13"
 match_template = { path = "components/match_template" }

components/tikv_util/src/time.rs

@@ -29,7 +29,7 @@ pub fn duration_to_sec(d: Duration) -> f64 {
 
 /// Converts Duration to nanoseconds.
 #[inline]
-pub fn duration_to_nanos(d: Duration) -> u64 {
+pub fn duration_as_nanos(d: Duration) -> u64 {
     let nanos = u64::from(d.subsec_nanos());
     // Most of case, we can't have so large Duration, so here just panic if overflow now.
     d.as_secs() * 1_000_000_000 + nanos
@@ -435,7 +435,7 @@ mod tests {
             let exp_sec = ms as f64 / 1000.0;
             let act_sec = duration_to_sec(d);
             assert!((act_sec - exp_sec).abs() < f64::EPSILON);
-            assert_eq!(ms * 1_000_000, duration_to_nanos(d));
+            assert_eq!(ms * 1_000_000, duration_as_nanos(d));
         }
     }
 

fuzz/targets/mod.rs

@@ -210,15 +210,15 @@ fn fuzz_duration(
     let _ = t.hours();
     let _ = t.minutes();
     let _ = t.secs();
-    let _ = t.micro_secs();
-    let _ = t.nano_secs();
-    let _ = t.to_secs();
+    let _ = t.subsec_micros();
+    let _ = t.subsec_nanos();
+    let _ = t.as_secs_f64();
     let _ = t.is_zero();
     let _ = t.to_decimal();
     let u = t;
     u.round_frac(cursor.read_as_i8()?)?;
     let mut v = Vec::new();
-    let _ = v.encode_duration(&t);
+    let _ = v.encode_duration(t);
     Ok(())
 }
 

src/coprocessor/codec/chunk/column.rs

@@ -104,7 +104,7 @@ impl Column {
             Datum::F64(v) => self.append_f64(*v),
             Datum::Bytes(ref v) => self.append_bytes(v),
             Datum::Dec(ref v) => self.append_decimal(v),
-            Datum::Dur(ref v) => self.append_duration(v),
+            Datum::Dur(v) => self.append_duration(*v),
             Datum::Time(ref v) => self.append_time(v),
             Datum::Json(ref v) => self.append_json(v),
             _ => Err(box_err!("unsupported datum {:?}", data)),
@@ -280,7 +280,7 @@ impl Column {
     }
 
     /// Append a duration datum to the column.
-    pub fn append_duration(&mut self, d: &Duration) -> Result<()> {
+    pub fn append_duration(&mut self, d: Duration) -> Result<()> {
         self.data.encode_duration(d)?;
         self.finish_append_fixed()
     }

src/coprocessor/codec/data_type/vector.rs

@@ -567,7 +567,7 @@ impl VectorValue {
                     }
                     Some(ref val) => {
                         output.push(datum::DURATION_FLAG);
-                        output.encode_i64(val.to_nanos())?;
+                        output.encode_i64(val.as_nanos())?;
                     }
                 }
                 Ok(())

src/coprocessor/codec/datum.rs

@@ -122,7 +122,7 @@ impl Datum {
             Datum::U64(u) => self.cmp_u64(ctx, u),
             Datum::F64(f) => self.cmp_f64(ctx, f),
             Datum::Bytes(ref bs) => self.cmp_bytes(ctx, bs),
-            Datum::Dur(ref d) => self.cmp_dur(ctx, d),
+            Datum::Dur(d) => self.cmp_dur(ctx, d),
             Datum::Dec(ref d) => self.cmp_dec(ctx, d),
             Datum::Time(ref t) => self.cmp_time(ctx, t),
             Datum::Json(ref j) => self.cmp_json(j),
@@ -173,7 +173,7 @@ impl Datum {
                 cmp_f64(ff, f)
             }
             Datum::Dur(ref d) => {
-                let ff = d.to_secs();
+                let ff = d.as_secs_f64();
                 cmp_f64(ff, f)
             }
             Datum::Time(ref t) => {
@@ -225,14 +225,14 @@ impl Datum {
         }
     }
 
-    fn cmp_dur(&self, ctx: &mut EvalContext, d: &Duration) -> Result<Ordering> {
+    fn cmp_dur(&self, ctx: &mut EvalContext, d: Duration) -> Result<Ordering> {
         match *self {
-            Datum::Dur(ref d2) => Ok(d2.cmp(d)),
+            Datum::Dur(ref d2) => Ok(d2.cmp(&d)),
             Datum::Bytes(ref bs) => {
                 let d2 = Duration::parse(bs, MAX_FSP)?;
-                Ok(d2.cmp(d))
+                Ok(d2.cmp(&d))
             }
-            _ => self.cmp_f64(ctx, d.to_secs()),
+            _ => self.cmp_f64(ctx, d.as_secs_f64()),
         }
     }
 
@@ -386,7 +386,7 @@ impl Datum {
             Datum::I64(i) => i,
             Datum::U64(u) => u as i64,
             Datum::F64(f) => f.to_bits() as i64,
-            Datum::Dur(ref d) => d.to_nanos(),
+            Datum::Dur(ref d) => d.as_nanos(),
             Datum::Time(_)
             | Datum::Bytes(_)
             | Datum::Dec(_)
@@ -904,7 +904,7 @@ pub trait DatumEncoder: BytesEncoder + DecimalEncoder + JsonEncoder {
                 }
                 Datum::Dur(ref d) => {
                     self.write_u8(DURATION_FLAG)?;
-                    self.encode_i64(d.to_nanos())?;
+                    self.encode_i64(d.as_nanos())?;
                 }
                 Datum::Dec(ref d) => {
                     self.write_u8(DECIMAL_FLAG)?;