Use chrono::time_point instead of time_t (#4868)

Summary:
By convention, time_t almost always stores the integral number of seconds since
00:00 hours, Jan 1, 1970 UTC, according to http://www.cplusplus.com/reference/ctime/time_t/.
We surely want more precision than seconds.
Pull Request resolved: https://github.com/facebook/rocksdb/pull/4868

Differential Revision: D13633046

Pulled By: riversand963

fbshipit-source-id: 4e01e23a22e8838023c51a91247a286dbf3a5396

diff --git a/HISTORY.md b/HISTORY.md
index 822b919ef93937d0144a3bdf47c0168d51c9a5ad..9040717fc6459f1cc2274433152a40698ca1c026 100644 (file)
--- a/HISTORY.md
+++ b/HISTORY.md
@@ -1,4 +1,8 @@
 # Rocksdb Change Log
+## 5.18.2 (01/23/2019)
+### Public API Change
+* Change time resolution in FileOperationInfo.
+
 ## 5.18.0 (11/30/2018)
 ### New Features
 * Introduced `JemallocNodumpAllocator` memory allocator. When being use, block cache will be excluded from core dump.

diff --git a/db/listener_test.cc b/db/listener_test.cc
index cbbffc8cb7561f85f284fb3c9df2a076f7cf37c3..894769d88d9833cbb9b5eb8c89122fe0b39526aa 100644 (file)
--- a/db/listener_test.cc
+++ b/db/listener_test.cc
@@ -905,6 +905,7 @@ class TestFileOperationListener : public EventListener {
     if (info.status.ok()) {
       ++file_reads_success_;
     }
+    ReportDuration(info);
   }
 
   void OnFileWriteFinish(const FileOperationInfo& info) override {
@@ -912,6 +913,7 @@ class TestFileOperationListener : public EventListener {
     if (info.status.ok()) {
       ++file_writes_success_;
     }
+    ReportDuration(info);
   }
 
   bool ShouldBeNotifiedOnFileIO() override { return true; }
@@ -920,6 +922,13 @@ class TestFileOperationListener : public EventListener {
   std::atomic<size_t> file_reads_success_;
   std::atomic<size_t> file_writes_;
   std::atomic<size_t> file_writes_success_;
+
+ private:
+  void ReportDuration(const FileOperationInfo& info) const {
+    auto duration = std::chrono::duration_cast<std::chrono::nanoseconds>(
+        info.finish_timestamp - info.start_timestamp);
+    ASSERT_GT(duration.count(), 0);
+  }
 };
 
 TEST_F(EventListenerTest, OnFileOperationTest) {

diff --git a/include/rocksdb/listener.h b/include/rocksdb/listener.h
index 8ceb2ed4c0bc100d13fa181d78ed16fb9ae840c9..9b4e8a866645cc920a8b13014881c22c8a910752 100644 (file)
--- a/include/rocksdb/listener.h
+++ b/include/rocksdb/listener.h
@@ -4,6 +4,7 @@
 
 #pragma once
 
+#include <chrono>
 #include <memory>
 #include <string>
 #include <unordered_map>
@@ -144,13 +145,18 @@ struct TableFileDeletionInfo {
 };
 
 struct FileOperationInfo {
+  using TimePoint = std::chrono::time_point<std::chrono::system_clock,
+                                            std::chrono::nanoseconds>;
+
   const std::string& path;
   uint64_t offset;
   size_t length;
-  time_t start_timestamp;
-  time_t finish_timestamp;
+  const TimePoint& start_timestamp;
+  const TimePoint& finish_timestamp;
   Status status;
-  FileOperationInfo(const std::string& _path) : path(_path) {}
+  FileOperationInfo(const std::string& _path, const TimePoint& start,
+                    const TimePoint& finish)
+      : path(_path), start_timestamp(start), finish_timestamp(finish) {}
 };
 
 struct FlushJobInfo {

diff --git a/util/file_reader_writer.cc b/util/file_reader_writer.cc
index 821d657b0a50695c5f33c0ab211cdfd5d3cf5fa4..9e40d4d4082badfa70a953c8f981977ac4022554 100644 (file)
--- a/util/file_reader_writer.cc
+++ b/util/file_reader_writer.cc
@@ -99,17 +99,18 @@ Status RandomAccessFileReader::Read(uint64_t offset, size_t n, Slice* result,
         }
         Slice tmp;
 
-        time_t start_ts = 0;
+        FileOperationInfo::TimePoint start_ts;
         uint64_t orig_offset = 0;
         if (ShouldNotifyListeners()) {
-          start_ts = std::chrono::system_clock::to_time_t(
-              std::chrono::system_clock::now());
+          start_ts = std::chrono::system_clock::now();
           orig_offset = aligned_offset + buf.CurrentSize();
         }
         s = file_->Read(aligned_offset + buf.CurrentSize(), allowed, &tmp,
                         buf.Destination());
         if (ShouldNotifyListeners()) {
-          NotifyOnFileReadFinish(orig_offset, tmp.size(), start_ts, s);
+          auto finish_ts = std::chrono::system_clock::now();
+          NotifyOnFileReadFinish(orig_offset, tmp.size(), start_ts, finish_ts,
+                                 s);
         }
 
         buf.Size(buf.CurrentSize() + tmp.size());
@@ -145,16 +146,17 @@ Status RandomAccessFileReader::Read(uint64_t offset, size_t n, Slice* result,
         Slice tmp_result;
 
 #ifndef ROCKSDB_LITE
-        time_t start_ts = 0;
+        FileOperationInfo::TimePoint start_ts;
         if (ShouldNotifyListeners()) {
-          start_ts = std::chrono::system_clock::to_time_t(
-              std::chrono::system_clock::now());
+          start_ts = std::chrono::system_clock::now();
         }
 #endif
         s = file_->Read(offset + pos, allowed, &tmp_result, scratch + pos);
 #ifndef ROCKSDB_LITE
         if (ShouldNotifyListeners()) {
-          NotifyOnFileReadFinish(offset + pos, tmp_result.size(), start_ts, s);
+          auto finish_ts = std::chrono::system_clock::now();
+          NotifyOnFileReadFinish(offset + pos, tmp_result.size(), start_ts,
+                                 finish_ts, s);
         }
 #endif
 
@@ -442,18 +444,18 @@ Status WritableFileWriter::WriteBuffered(const char* data, size_t size) {
       TEST_SYNC_POINT("WritableFileWriter::Flush:BeforeAppend");
 
 #ifndef ROCKSDB_LITE
-      time_t start_ts = 0;
+      FileOperationInfo::TimePoint start_ts;
       uint64_t old_size = writable_file_->GetFileSize();
       if (ShouldNotifyListeners()) {
-        start_ts = std::chrono::system_clock::to_time_t(
-            std::chrono::system_clock::now());
+        start_ts = std::chrono::system_clock::now();
         old_size = next_write_offset_;
       }
 #endif
       s = writable_file_->Append(Slice(src, allowed));
 #ifndef ROCKSDB_LITE
       if (ShouldNotifyListeners()) {
-        NotifyOnFileWriteFinish(old_size, allowed, start_ts, s);
+        auto finish_ts = std::chrono::system_clock::now();
+        NotifyOnFileWriteFinish(old_size, allowed, start_ts, finish_ts, s);
       }
 #endif
       if (!s.ok()) {
@@ -518,15 +520,15 @@ Status WritableFileWriter::WriteDirect() {
     {
       IOSTATS_TIMER_GUARD(write_nanos);
       TEST_SYNC_POINT("WritableFileWriter::Flush:BeforeAppend");
-      time_t start_ts(0);
+      FileOperationInfo::TimePoint start_ts;
       if (ShouldNotifyListeners()) {
-        start_ts = std::chrono::system_clock::to_time_t(
-            std::chrono::system_clock::now());
+        start_ts = std::chrono::system_clock::now();
       }
       // direct writes must be positional
       s = writable_file_->PositionedAppend(Slice(src, size), write_offset);
       if (ShouldNotifyListeners()) {
-        NotifyOnFileWriteFinish(write_offset, size, start_ts, s);
+        auto finish_ts = std::chrono::system_clock::now();
+        NotifyOnFileWriteFinish(write_offset, size, start_ts, finish_ts, s);
       }
       if (!s.ok()) {
         buf_.Size(file_advance + leftover_tail);

diff --git a/util/file_reader_writer.h b/util/file_reader_writer.h
index ec7acebcc4ffb65ab158023a6ce2c1072260a8b6..1083c685cb7da786280c7f5dcabfd8bd85fabc36 100644 (file)
--- a/util/file_reader_writer.h
+++ b/util/file_reader_writer.h
@@ -64,15 +64,13 @@ class SequentialFileReader {
 class RandomAccessFileReader {
  private:
 #ifndef ROCKSDB_LITE
-  void NotifyOnFileReadFinish(uint64_t offset, size_t length, time_t start_ts,
+  void NotifyOnFileReadFinish(uint64_t offset, size_t length,
+                              const FileOperationInfo::TimePoint& start_ts,
+                              const FileOperationInfo::TimePoint& finish_ts,
                               const Status& status) const {
-    FileOperationInfo info(file_name_);
+    FileOperationInfo info(file_name_, start_ts, finish_ts);
     info.offset = offset;
     info.length = length;
-    info.start_timestamp = start_ts;
-    time_t finish_ts =
-        std::chrono::system_clock::to_time_t(std::chrono::system_clock::now());
-    info.finish_timestamp = finish_ts;
     info.status = status;
 
     for (auto& listener : listeners_) {
@@ -157,15 +155,13 @@ class RandomAccessFileReader {
 class WritableFileWriter {
  private:
 #ifndef ROCKSDB_LITE
-  void NotifyOnFileWriteFinish(uint64_t offset, size_t length, time_t start_ts,
+  void NotifyOnFileWriteFinish(uint64_t offset, size_t length,
+                               const FileOperationInfo::TimePoint& start_ts,
+                               const FileOperationInfo::TimePoint& finish_ts,
                                const Status& status) {
-    FileOperationInfo info(file_name_);
+    FileOperationInfo info(file_name_, start_ts, finish_ts);
     info.offset = offset;
     info.length = length;
-    info.start_timestamp = start_ts;
-    time_t finish_ts =
-        std::chrono::system_clock::to_time_t(std::chrono::system_clock::now());
-    info.finish_timestamp = finish_ts;
     info.status = status;
 
     for (auto& listener : listeners_) {