Fix Windows strcmp for Unicode (#8190)

Summary:
The code for strcmp that was present does work when compiled for Windows unicode file paths.

Needs backporting to:
* 6.17.fb
* 6.18.fb
* 6.19.fb

Pull Request resolved: https://github.com/facebook/rocksdb/pull/8190

Reviewed By: akankshamahajan15

Differential Revision: D27765588

Pulled By: jay-zhuang

fbshipit-source-id: 89f8a5ac61fd7edc758340dfd335b0a5f96dae6e

CMakeLists.txt

@@ -637,7 +637,6 @@ set(SOURCES
         db/write_batch_base.cc
         db/write_controller.cc
         db/write_thread.cc
-        env/composite_env.cc
         env/env.cc
         env/env_chroot.cc
         env/env_encryption.cc

HISTORY.md

@@ -35,7 +35,6 @@
 
 ### Public API Change
 * Add a public API WriteBufferManager::dummy_entries_in_cache_usage() which reports the size of dummy entries stored in cache (passed to WriteBufferManager). Dummy entries are used to account for DataBlocks.
-* Add a SystemClock class that contains the time-related methods from Env.  The original methods in Env may be deprecated in a future release.  This class will allow easier testing, development, and expansion of time-related features.
 * Add a public API GetRocksBuildProperties and GetRocksBuildInfoAsString to get properties about the current build.  These properties may include settings related to the GIT settings (branch, timestamp).  This change also sets the "build date" based on the GIT properties, rather than the actual build time, thereby enabling more reproducible builds.
 
 ## 6.16.0 (12/18/2020)

Makefile

@@ -497,6 +497,12 @@ ifeq ($(USE_FOLLY_DISTRIBUTED_MUTEX),1)
   LIB_OBJECTS += $(patsubst %.cpp, $(OBJ_DIR)/%.o, $(FOLLY_SOURCES))
 endif
 
+# range_tree is not compatible with non GNU libc on ppc64
+# see https://jira.percona.com/browse/PS-7559
+ifneq ($(PPC_LIBC_IS_GNU),0)
+  LIB_OBJECTS += $(patsubst %.cc, $(OBJ_DIR)/%.o, $(RANGE_TREE_SOURCES))
+endif
+
 GTEST = $(OBJ_DIR)/$(GTEST_DIR)/gtest/gtest-all.o
 TESTUTIL = $(OBJ_DIR)/test_util/testutil.o
 TESTHARNESS = $(OBJ_DIR)/test_util/testharness.o $(TESTUTIL) $(GTEST)
@@ -2173,8 +2179,8 @@ SNAPPY_DOWNLOAD_BASE ?= https://github.com/google/snappy/archive
 LZ4_VER ?= 1.9.3
 LZ4_SHA256 ?= 030644df4611007ff7dc962d981f390361e6c97a34e5cbc393ddfbe019ffe2c1
 LZ4_DOWNLOAD_BASE ?= https://github.com/lz4/lz4/archive
-ZSTD_VER ?= 1.4.7
-ZSTD_SHA256 ?= 085500c8d0b9c83afbc1dc0d8b4889336ad019eba930c5d6a9c6c86c20c769c8
+ZSTD_VER ?= 1.4.9
+ZSTD_SHA256 ?= acf714d98e3db7b876e5b540cbf6dee298f60eb3c0723104f6d3f065cd60d6a8
 ZSTD_DOWNLOAD_BASE ?= https://github.com/facebook/zstd/archive
 CURL_SSL_OPTS ?= --tlsv1
 

TARGETS

@@ -207,7 +207,6 @@ cpp_library(
         "db/write_batch_base.cc",
         "db/write_controller.cc",
         "db/write_thread.cc",
-        "env/composite_env.cc",
         "env/env.cc",
         "env/env_chroot.cc",
         "env/env_encryption.cc",
@@ -512,7 +511,6 @@ cpp_library(
         "db/write_batch_base.cc",
         "db/write_controller.cc",
         "db/write_thread.cc",
-        "env/composite_env.cc",
         "env/env.cc",
         "env/env_chroot.cc",
         "env/env_encryption.cc",

buckifier/buckify_rocksdb.py

@@ -141,11 +141,15 @@ def generate_targets(repo_path, deps_map):
     TARGETS.add_library(
         "rocksdb_lib",
         src_mk["LIB_SOURCES"] +
+        # always add range_tree, it's only excluded on ppc64, which we don't use internally
+        src_mk["RANGE_TREE_SOURCES"] +
         src_mk["TOOL_LIB_SOURCES"])
     # rocksdb_whole_archive_lib
     TARGETS.add_library(
         "rocksdb_whole_archive_lib",
         src_mk["LIB_SOURCES"] +
+        # always add range_tree, it's only excluded on ppc64, which we don't use internally
+        src_mk["RANGE_TREE_SOURCES"] +
         src_mk["TOOL_LIB_SOURCES"],
         deps=None,
         headers=None,

build_tools/build_detect_platform

@@ -668,6 +668,23 @@ else
   fi
 fi
 
+if test -n "`echo $TARGET_ARCHITECTURE | grep ^ppc64`"; then
+  # check for GNU libc on ppc64
+  $CXX -x c++ - -o /dev/null 2>/dev/null <<EOF
+    #include <stdio.h>
+    #include <stdlib.h>
+    #include <gnu/libc-version.h>
+
+    int main(int argc, char *argv[]) {
+      printf("GNU libc version: %s\n", gnu_get_libc_version());
+      return 0;
+    }
+EOF
+  if [ "$?" != 0 ]; then
+      PPC_LIBC_IS_GNU=0
+  fi
+fi
+
 if test "$TRY_SSE_ETC"; then
   # The USE_SSE flag now means "attempt to compile with widely-available
   # Intel architecture extensions utilized by specific optimizations in the
@@ -861,3 +878,6 @@ echo "LUA_PATH=$LUA_PATH" >> "$OUTPUT"
 if test -n "$USE_FOLLY_DISTRIBUTED_MUTEX"; then
   echo "USE_FOLLY_DISTRIBUTED_MUTEX=$USE_FOLLY_DISTRIBUTED_MUTEX" >> "$OUTPUT"
 fi
+if test -n "$PPC_LIBC_IS_GNU"; then
+  echo "PPC_LIBC_IS_GNU=$PPC_LIBC_IS_GNU" >> "$OUTPUT"
+fi

cache/cache_bench.cc

@@ -13,7 +13,6 @@ int main() {
 
 #include <stdio.h>
 #include <sys/types.h>
-
 #include <cinttypes>
 #include <limits>
 
@@ -21,7 +20,6 @@ int main() {
 #include "rocksdb/cache.h"
 #include "rocksdb/db.h"
 #include "rocksdb/env.h"
-#include "rocksdb/system_clock.h"
 #include "util/coding.h"
 #include "util/gflags_compat.h"
 #include "util/hash.h"
@@ -212,7 +210,6 @@ class CacheBench {
 
   bool Run() {
     ROCKSDB_NAMESPACE::Env* env = ROCKSDB_NAMESPACE::Env::Default();
-    const auto& clock = env->GetSystemClock();
 
     PrintEnv();
     SharedState shared(this);
@@ -227,7 +224,7 @@ class CacheBench {
         shared.GetCondVar()->Wait();
       }
       // Record start time
-      uint64_t start_time = clock->NowMicros();
+      uint64_t start_time = env->NowMicros();
 
       // Start all threads
       shared.SetStart();
@@ -239,7 +236,7 @@ class CacheBench {
       }
 
       // Record end time
-      uint64_t end_time = clock->NowMicros();
+      uint64_t end_time = env->NowMicros();
       double elapsed = static_cast<double>(end_time - start_time) * 1e-6;
       uint32_t qps = static_cast<uint32_t>(
           static_cast<double>(FLAGS_threads * FLAGS_ops_per_thread) / elapsed);

db/blob/blob_file_builder.cc

@@ -53,6 +53,7 @@ BlobFileBuilder::BlobFileBuilder(
     std::vector<std::string>* blob_file_paths,
     std::vector<BlobFileAddition>* blob_file_additions)
     : file_number_generator_(std::move(file_number_generator)),
+      env_(env),
       fs_(fs),
       immutable_cf_options_(immutable_cf_options),
       min_blob_size_(mutable_cf_options->min_blob_size),
@@ -70,7 +71,7 @@ BlobFileBuilder::BlobFileBuilder(
       blob_count_(0),
       blob_bytes_(0) {
   assert(file_number_generator_);
-  assert(env);
+  assert(env_);
   assert(fs_);
   assert(immutable_cf_options_);
   assert(file_options_);
@@ -78,7 +79,6 @@ BlobFileBuilder::BlobFileBuilder(
   assert(blob_file_paths_->empty());
   assert(blob_file_additions_);
   assert(blob_file_additions_->empty());
-  clock_ = env->GetSystemClock();
 }
 
 BlobFileBuilder::~BlobFileBuilder() = default;
@@ -185,7 +185,7 @@ Status BlobFileBuilder::OpenBlobFileIfNeeded() {
   FileTypeSet tmp_set = immutable_cf_options_->checksum_handoff_file_types;
   Statistics* const statistics = immutable_cf_options_->statistics;
   std::unique_ptr<WritableFileWriter> file_writer(new WritableFileWriter(
-      std::move(file), blob_file_paths_->back(), *file_options_, clock_,
+      std::move(file), blob_file_paths_->back(), *file_options_, env_,
       io_tracer_, statistics, immutable_cf_options_->listeners,
       immutable_cf_options_->file_checksum_gen_factory,
       tmp_set.Contains(FileType::kBlobFile)));
@@ -193,7 +193,7 @@ Status BlobFileBuilder::OpenBlobFileIfNeeded() {
   constexpr bool do_flush = false;
 
   std::unique_ptr<BlobLogWriter> blob_log_writer(new BlobLogWriter(
-      std::move(file_writer), clock_, statistics, blob_file_number,
+      std::move(file_writer), env_, statistics, blob_file_number,
       immutable_cf_options_->use_fsync, do_flush));
 
   constexpr bool has_ttl = false;

db/blob/blob_file_builder.h

@@ -18,7 +18,6 @@ namespace ROCKSDB_NAMESPACE {
 
 class VersionSet;
 class FileSystem;
-class SystemClock;
 struct ImmutableCFOptions;
 struct MutableCFOptions;
 struct FileOptions;
@@ -73,8 +72,8 @@ class BlobFileBuilder {
   Status CloseBlobFileIfNeeded();
 
   std::function<uint64_t()> file_number_generator_;
+  Env* env_;
   FileSystem* fs_;
-  std::shared_ptr<SystemClock> clock_;
   const ImmutableCFOptions* immutable_cf_options_;
   uint64_t min_blob_size_;
   uint64_t blob_file_size_;

db/blob/blob_file_builder_test.cc

@@ -39,10 +39,8 @@ class TestFileNumberGenerator {
 
 class BlobFileBuilderTest : public testing::Test {
  protected:
-  BlobFileBuilderTest() : mock_env_(Env::Default()) {
-    fs_ = mock_env_.GetFileSystem().get();
-    clock_ = mock_env_.GetSystemClock();
-  }
+  BlobFileBuilderTest()
+      : mock_env_(Env::Default()), fs_(mock_env_.GetFileSystem().get()) {}
 
   void VerifyBlobFile(uint64_t blob_file_number,
                       const std::string& blob_file_path,
@@ -59,10 +57,11 @@ class BlobFileBuilderTest : public testing::Test {
         fs_->NewRandomAccessFile(blob_file_path, file_options_, &file, dbg));
 
     std::unique_ptr<RandomAccessFileReader> file_reader(
-        new RandomAccessFileReader(std::move(file), blob_file_path, clock_));
+        new RandomAccessFileReader(std::move(file), blob_file_path,
+                                   &mock_env_));
 
     constexpr Statistics* statistics = nullptr;
-    BlobLogSequentialReader blob_log_reader(std::move(file_reader), clock_,
+    BlobLogSequentialReader blob_log_reader(std::move(file_reader), &mock_env_,
                                             statistics);
 
     BlobLogHeader header;
@@ -110,7 +109,6 @@ class BlobFileBuilderTest : public testing::Test {
 
   MockEnv mock_env_;
   FileSystem* fs_;
-  std::shared_ptr<SystemClock> clock_;
   FileOptions file_options_;
 };
 

db/blob/blob_file_cache_test.cc

@@ -42,15 +42,15 @@ void WriteBlobFile(uint32_t column_family_id,
 
   std::unique_ptr<WritableFileWriter> file_writer(
       new WritableFileWriter(std::move(file), blob_file_path, FileOptions(),
-                             immutable_cf_options.env->GetSystemClock()));
+                             immutable_cf_options.env));
 
   constexpr Statistics* statistics = nullptr;
   constexpr bool use_fsync = false;
   constexpr bool do_flush = false;
 
-  BlobLogWriter blob_log_writer(
-      std::move(file_writer), immutable_cf_options.env->GetSystemClock(),
-      statistics, blob_file_number, use_fsync, do_flush);
+  BlobLogWriter blob_log_writer(std::move(file_writer),
+                                immutable_cf_options.env, statistics,
+                                blob_file_number, use_fsync, do_flush);
 
   constexpr bool has_ttl = false;
   constexpr ExpirationRange expiration_range;

db/blob/blob_file_reader.cc

@@ -119,7 +119,7 @@ Status BlobFileReader::OpenFile(
 
   file_reader->reset(new RandomAccessFileReader(
       std::move(file), blob_file_path,
-      immutable_cf_options.env->GetSystemClock(), io_tracer,
+      immutable_cf_options.env, io_tracer,
       immutable_cf_options.statistics, BLOB_DB_BLOB_FILE_READ_MICROS,
       blob_file_read_hist, immutable_cf_options.rate_limiter,
       immutable_cf_options.listeners));

db/blob/blob_file_reader_test.cc

@@ -50,15 +50,15 @@ void WriteBlobFile(const ImmutableCFOptions& immutable_cf_options,
 
   std::unique_ptr<WritableFileWriter> file_writer(
       new WritableFileWriter(std::move(file), blob_file_path, FileOptions(),
-                             immutable_cf_options.env->GetSystemClock()));
+                             immutable_cf_options.env));
 
   constexpr Statistics* statistics = nullptr;
   constexpr bool use_fsync = false;
   constexpr bool do_flush = false;
 
-  BlobLogWriter blob_log_writer(
-      std::move(file_writer), immutable_cf_options.env->GetSystemClock(),
-      statistics, blob_file_number, use_fsync, do_flush);
+  BlobLogWriter blob_log_writer(std::move(file_writer),
+                                immutable_cf_options.env, statistics,
+                                blob_file_number, use_fsync, do_flush);
 
   BlobLogHeader header(column_family_id, compression_type, has_ttl,
                        expiration_range_header);
@@ -260,15 +260,15 @@ TEST_F(BlobFileReaderTest, Malformed) {
 
     std::unique_ptr<WritableFileWriter> file_writer(
         new WritableFileWriter(std::move(file), blob_file_path, FileOptions(),
-                               immutable_cf_options.env->GetSystemClock()));
+                               immutable_cf_options.env));
 
     constexpr Statistics* statistics = nullptr;
     constexpr bool use_fsync = false;
     constexpr bool do_flush = false;
 
-    BlobLogWriter blob_log_writer(
-        std::move(file_writer), immutable_cf_options.env->GetSystemClock(),
-        statistics, blob_file_number, use_fsync, do_flush);
+    BlobLogWriter blob_log_writer(std::move(file_writer),
+                                  immutable_cf_options.env, statistics,
+                                  blob_file_number, use_fsync, do_flush);
 
     BlobLogHeader header(column_family_id, kNoCompression, has_ttl,
                          expiration_range);

db/blob/blob_log_sequential_reader.cc

@@ -13,10 +13,10 @@
 namespace ROCKSDB_NAMESPACE {
 
 BlobLogSequentialReader::BlobLogSequentialReader(
-    std::unique_ptr<RandomAccessFileReader>&& file_reader,
-    const std::shared_ptr<SystemClock>& clock, Statistics* statistics)
+    std::unique_ptr<RandomAccessFileReader>&& file_reader, Env* env,
+    Statistics* statistics)
     : file_(std::move(file_reader)),
-      clock_(clock),
+      env_(env),
       statistics_(statistics),
       next_byte_(0) {}
 
@@ -27,7 +27,7 @@ Status BlobLogSequentialReader::ReadSlice(uint64_t size, Slice* slice,
   assert(slice);
   assert(file_);
 
-  StopWatch read_sw(clock_, statistics_, BLOB_DB_BLOB_FILE_READ_MICROS);
+  StopWatch read_sw(env_, statistics_, BLOB_DB_BLOB_FILE_READ_MICROS);
   Status s = file_->Read(IOOptions(), next_byte_, static_cast<size_t>(size),
                          slice, buf, nullptr);
   next_byte_ += size;

db/blob/blob_log_sequential_reader.h

@@ -16,7 +16,6 @@ class RandomAccessFileReader;
 class Env;
 class Statistics;
 class Status;
-class SystemClock;
 
 /**
  * BlobLogSequentialReader is a general purpose log stream reader
@@ -36,8 +35,7 @@ class BlobLogSequentialReader {
 
   // Create a reader that will return log records from "*file_reader".
   BlobLogSequentialReader(std::unique_ptr<RandomAccessFileReader>&& file_reader,
-                          const std::shared_ptr<SystemClock>& clock,
-                          Statistics* statistics);
+                          Env* env, Statistics* statistics);
 
   // No copying allowed
   BlobLogSequentialReader(const BlobLogSequentialReader&) = delete;
@@ -65,8 +63,7 @@ class BlobLogSequentialReader {
   Status ReadSlice(uint64_t size, Slice* slice, char* buf);
 
   const std::unique_ptr<RandomAccessFileReader> file_;
-  std::shared_ptr<SystemClock> clock_;
-
+  Env* env_;
   Statistics* statistics_;
 
   Slice buffer_;

db/blob/blob_log_writer.cc

@@ -11,7 +11,7 @@
 #include "db/blob/blob_log_format.h"
 #include "file/writable_file_writer.h"
 #include "monitoring/statistics.h"
-#include "rocksdb/system_clock.h"
+#include "rocksdb/env.h"
 #include "test_util/sync_point.h"
 #include "util/coding.h"
 #include "util/stop_watch.h"
@@ -19,11 +19,11 @@
 namespace ROCKSDB_NAMESPACE {
 
 BlobLogWriter::BlobLogWriter(std::unique_ptr<WritableFileWriter>&& dest,
-                             const std::shared_ptr<SystemClock>& clock,
-                             Statistics* statistics, uint64_t log_number,
-                             bool use_fs, bool do_flush, uint64_t boffset)
+                             Env* env, Statistics* statistics,
+                             uint64_t log_number, bool use_fs, bool do_flush,
+                             uint64_t boffset)
     : dest_(std::move(dest)),
-      clock_(clock),
+      env_(env),
       statistics_(statistics),
       log_number_(log_number),
       block_offset_(boffset),
@@ -36,7 +36,7 @@ BlobLogWriter::~BlobLogWriter() = default;
 Status BlobLogWriter::Sync() {
   TEST_SYNC_POINT("BlobLogWriter::Sync");
 
-  StopWatch sync_sw(clock_, statistics_, BLOB_DB_BLOB_FILE_SYNC_MICROS);
+  StopWatch sync_sw(env_, statistics_, BLOB_DB_BLOB_FILE_SYNC_MICROS);
   Status s = dest_->Sync(use_fsync_);
   RecordTick(statistics_, BLOB_DB_BLOB_FILE_SYNCED);
   return s;
@@ -148,7 +148,7 @@ Status BlobLogWriter::EmitPhysicalRecord(const std::string& headerbuf,
                                          const Slice& key, const Slice& val,
                                          uint64_t* key_offset,
                                          uint64_t* blob_offset) {
-  StopWatch write_sw(clock_, statistics_, BLOB_DB_BLOB_FILE_WRITE_MICROS);
+  StopWatch write_sw(env_, statistics_, BLOB_DB_BLOB_FILE_WRITE_MICROS);
   Status s = dest_->Append(Slice(headerbuf));
   if (s.ok()) {
     s = dest_->Append(key);

db/blob/blob_log_writer.h

@@ -9,6 +9,7 @@
 #include <string>
 
 #include "db/blob/blob_log_format.h"
+#include "rocksdb/env.h"
 #include "rocksdb/slice.h"
 #include "rocksdb/statistics.h"
 #include "rocksdb/status.h"
@@ -17,7 +18,7 @@
 namespace ROCKSDB_NAMESPACE {
 
 class WritableFileWriter;
-class SystemClock;
+
 /**
  * BlobLogWriter is the blob log stream writer. It provides an append-only
  * abstraction for writing blob data.
@@ -31,8 +32,7 @@ class BlobLogWriter {
   // Create a writer that will append data to "*dest".
   // "*dest" must be initially empty.
   // "*dest" must remain live while this BlobLogWriter is in use.
-  BlobLogWriter(std::unique_ptr<WritableFileWriter>&& dest,
-                const std::shared_ptr<SystemClock>& clock,
+  BlobLogWriter(std::unique_ptr<WritableFileWriter>&& dest, Env* env,
                 Statistics* statistics, uint64_t log_number, bool use_fsync,
                 bool do_flush, uint64_t boffset = 0);
   // No copying allowed
@@ -69,7 +69,7 @@ class BlobLogWriter {
 
  private:
   std::unique_ptr<WritableFileWriter> dest_;
-  std::shared_ptr<SystemClock> clock_;
+  Env* env_;
   Statistics* statistics_;
   uint64_t log_number_;
   uint64_t block_offset_;  // Current offset in block

db/builder.cc

@@ -125,8 +125,6 @@ Status BuildTable(
   assert(env);
   FileSystem* fs = db_options.fs.get();
   assert(fs);
-  const auto& clock = env->GetSystemClock();
-
   TableProperties tp;
   if (iter->Valid() || !range_del_agg->IsEmpty()) {
     TableBuilder* builder;
@@ -154,7 +152,7 @@ Status BuildTable(
       file->SetIOPriority(io_priority);
       file->SetWriteLifeTimeHint(write_hint);
       file_writer.reset(new WritableFileWriter(
-          std::move(file), fname, file_options, clock, io_tracer,
+          std::move(file), fname, file_options, env, io_tracer,
           ioptions.statistics, ioptions.listeners,
           ioptions.file_checksum_gen_factory,
           tmp_set.Contains(FileType::kTableFile)));
@@ -258,7 +256,7 @@ Status BuildTable(
     // Finish and check for file errors
     TEST_SYNC_POINT("BuildTable:BeforeSyncTable");
     if (s.ok() && !empty) {
-      StopWatch sw(clock, ioptions.statistics, TABLE_SYNC_MICROS);
+      StopWatch sw(env, ioptions.statistics, TABLE_SYNC_MICROS);
       *io_status = file_writer->Sync(ioptions.use_fsync);
     }
     TEST_SYNC_POINT("BuildTable:BeforeCloseTableFile");

db/column_family.cc

@@ -557,8 +557,8 @@ ColumnFamilyData::ColumnFamilyData(
 
   // if _dummy_versions is nullptr, then this is a dummy column family.
   if (_dummy_versions != nullptr) {
-    internal_stats_.reset(new InternalStats(
-        ioptions_.num_levels, db_options.env->GetSystemClock(), this));
+    internal_stats_.reset(
+        new InternalStats(ioptions_.num_levels, db_options.env, this));
     table_cache_.reset(new TableCache(ioptions_, file_options, _table_cache,
                                       block_cache_tracer, io_tracer));
     blob_file_cache_.reset(

db/compaction/compaction_iterator.cc

@@ -80,7 +80,6 @@ CompactionIterator::CompactionIterator(
       earliest_write_conflict_snapshot_(earliest_write_conflict_snapshot),
       snapshot_checker_(snapshot_checker),
       env_(env),
-      clock_(env_->GetSystemClock()),
       report_detailed_time_(report_detailed_time),
       expect_valid_internal_key_(expect_valid_internal_key),
       range_del_agg_(range_del_agg),
@@ -220,7 +219,7 @@ bool CompactionIterator::InvokeFilterIfNeeded(bool* need_skip,
     // to get sequence number.
     Slice& filter_key = ikey_.type == kTypeValue ? ikey_.user_key : key_;
     {
-      StopWatchNano timer(clock_, report_detailed_time_);
+      StopWatchNano timer(env_, report_detailed_time_);
       filter = compaction_filter_->FilterV2(
           compaction_->level(), filter_key, value_type, value_,
           &compaction_filter_value_, compaction_filter_skip_until_.rep());

db/compaction/compaction_iterator.h

@@ -248,7 +248,6 @@ class CompactionIterator {
   const SequenceNumber earliest_write_conflict_snapshot_;
   const SnapshotChecker* const snapshot_checker_;
   Env* env_;
-  std::shared_ptr<SystemClock> clock_;
   bool report_detailed_time_;
   bool expect_valid_internal_key_;
   CompactionRangeDelAggregator* range_del_agg_;

db/compaction/compaction_job.cc

@@ -321,7 +321,6 @@ CompactionJob::CompactionJob(
       db_options_(db_options),
       file_options_(file_options),
       env_(db_options.env),
-      clock_(env_->GetSystemClock()),
       io_tracer_(io_tracer),
       fs_(db_options.fs, io_tracer),
       file_options_for_read_(
@@ -421,7 +420,7 @@ void CompactionJob::Prepare() {
 
   if (c->ShouldFormSubcompactions()) {
     {
-      StopWatch sw(clock_, stats_, SUBCOMPACTION_SETUP_TIME);
+      StopWatch sw(env_, stats_, SUBCOMPACTION_SETUP_TIME);
       GenSubcompactionBoundaries();
     }
     assert(sizes_.size() == boundaries_.size() + 1);
@@ -587,7 +586,7 @@ Status CompactionJob::Run() {
 
   const size_t num_threads = compact_->sub_compact_states.size();
   assert(num_threads > 0);
-  const uint64_t start_micros = clock_->NowMicros();
+  const uint64_t start_micros = env_->NowMicros();
 
   // Launch a thread for each of subcompactions 1...num_threads-1
   std::vector<port::Thread> thread_pool;
@@ -606,7 +605,7 @@ Status CompactionJob::Run() {
     thread.join();
   }
 
-  compaction_stats_.micros = clock_->NowMicros() - start_micros;
+  compaction_stats_.micros = env_->NowMicros() - start_micros;
   compaction_stats_.cpu_micros = 0;
   for (size_t i = 0; i < compact_->sub_compact_states.size(); i++) {
     compaction_stats_.cpu_micros +=
@@ -896,7 +895,7 @@ void CompactionJob::ProcessKeyValueCompaction(SubcompactionState* sub_compact) {
   assert(sub_compact);
   assert(sub_compact->compaction);
 
-  uint64_t prev_cpu_micros = clock_->CPUNanos() / 1000;
+  uint64_t prev_cpu_micros = env_->NowCPUNanos() / 1000;
 
   ColumnFamilyData* cfd = sub_compact->compaction->column_family_data();
 
@@ -1186,7 +1185,7 @@ void CompactionJob::ProcessKeyValueCompaction(SubcompactionState* sub_compact) {
   }
 
   sub_compact->compaction_job_stats.cpu_micros =
-      clock_->CPUNanos() / 1000 - prev_cpu_micros;
+      env_->NowCPUNanos() / 1000 - prev_cpu_micros;
 
   if (measure_io_stats_) {
     sub_compact->compaction_job_stats.file_write_nanos +=
@@ -1465,7 +1464,7 @@ Status CompactionJob::FinishCompactionOutputFile(
 
   // Finish and check for file errors
   if (s.ok()) {
-    StopWatch sw(clock_, stats_, COMPACTION_OUTFILE_SYNC_MICROS);
+    StopWatch sw(env_, stats_, COMPACTION_OUTFILE_SYNC_MICROS);
     io_s = sub_compact->outfile->Sync(db_options_.use_fsync);
   }
   if (s.ok() && io_s.ok()) {
@@ -1741,7 +1740,7 @@ Status CompactionJob::OpenCompactionOutputFile(
   const auto& listeners =
       sub_compact->compaction->immutable_cf_options()->listeners;
   sub_compact->outfile.reset(new WritableFileWriter(
-      std::move(writable_file), fname, file_options_, clock_, io_tracer_,
+      std::move(writable_file), fname, file_options_, env_, io_tracer_,
       db_options_.statistics.get(), listeners,
       db_options_.file_checksum_gen_factory.get(),
       tmp_set.Contains(FileType::kTableFile)));

db/compaction/compaction_job.h

@@ -50,7 +50,6 @@ class Arena;
 class ErrorHandler;
 class MemTable;
 class SnapshotChecker;
-class SystemClock;
 class TableCache;
 class Version;
 class VersionEdit;
@@ -160,7 +159,6 @@ class CompactionJob {
   const FileOptions file_options_;
 
   Env* env_;
-  std::shared_ptr<SystemClock> clock_;
   std::shared_ptr<IOTracer> io_tracer_;
   FileSystemPtr fs_;
   // env_option optimized for compaction table reads

db/compaction/compaction_job_test.cc

@@ -5,8 +5,6 @@
 
 #ifndef ROCKSDB_LITE
 
-#include "db/compaction/compaction_job.h"
-
 #include <algorithm>
 #include <array>
 #include <cinttypes>
@@ -16,13 +14,13 @@
 
 #include "db/blob/blob_index.h"
 #include "db/column_family.h"
+#include "db/compaction/compaction_job.h"
 #include "db/db_impl/db_impl.h"
 #include "db/error_handler.h"
 #include "db/version_set.h"
 #include "file/writable_file_writer.h"
 #include "rocksdb/cache.h"
 #include "rocksdb/db.h"
-#include "rocksdb/file_system.h"
 #include "rocksdb/options.h"
 #include "rocksdb/write_buffer_manager.h"
 #include "table/mock_table.h"
@@ -279,13 +277,12 @@ class CompactionJobTestBase : public testing::Test {
     new_db.SetLastSequence(0);
 
     const std::string manifest = DescriptorFileName(dbname_, 1);
-    std::unique_ptr<WritableFileWriter> file_writer;
-    const auto& fs = env_->GetFileSystem();
-    Status s = WritableFileWriter::Create(
-        fs, manifest, fs->OptimizeForManifestWrite(env_options_), &file_writer,
-        nullptr);
-
+    std::unique_ptr<WritableFile> file;
+    Status s = env_->NewWritableFile(
+        manifest, &file, env_->OptimizeForManifestWrite(env_options_));
     ASSERT_OK(s);
+    std::unique_ptr<WritableFileWriter> file_writer(new WritableFileWriter(
+        NewLegacyWritableFileWrapper(std::move(file)), manifest, env_options_));
     {
       log::Writer log(std::move(file_writer), 0, false);
       std::string record;

db/corruption_test.cc

@@ -19,6 +19,7 @@
 #include "db/db_test_util.h"
 #include "db/log_format.h"
 #include "db/version_set.h"
+#include "env/composite_env_wrapper.h"
 #include "file/filename.h"
 #include "port/stack_trace.h"
 #include "rocksdb/cache.h"
@@ -538,15 +539,14 @@ TEST_F(CorruptionTest, RangeDeletionCorrupted) {
   ASSERT_EQ(static_cast<size_t>(1), metadata.size());
   std::string filename = dbname_ + metadata[0].name;
 
-  FileOptions file_opts;
-  const auto& fs = options_.env->GetFileSystem();
-  std::unique_ptr<RandomAccessFileReader> file_reader;
-  ASSERT_OK(RandomAccessFileReader::Create(fs, filename, file_opts,
-                                           &file_reader, nullptr));
+  std::unique_ptr<RandomAccessFile> file;
+  ASSERT_OK(options_.env->NewRandomAccessFile(filename, &file, EnvOptions()));
+  std::unique_ptr<RandomAccessFileReader> file_reader(
+      new RandomAccessFileReader(NewLegacyRandomAccessFileWrapper(file),
+                                 filename));
 
   uint64_t file_size;
-  ASSERT_OK(
-      fs->GetFileSize(filename, file_opts.io_options, &file_size, nullptr));
+  ASSERT_OK(options_.env->GetFileSize(filename, &file_size));
 
   BlockHandle range_del_handle;
   ASSERT_OK(FindMetaBlock(

db/db_compaction_test.cc

@@ -11,7 +11,6 @@
 
 #include "db/blob/blob_index.h"
 #include "db/db_test_util.h"
-#include "env/mock_env.h"
 #include "port/port.h"
 #include "port/stack_trace.h"
 #include "rocksdb/concurrent_task_limiter.h"

db/db_dynamic_level_test.cc

@@ -13,7 +13,6 @@
 #if !defined(ROCKSDB_LITE)
 
 #include "db/db_test_util.h"
-#include "env/mock_env.h"
 #include "port/port.h"
 #include "port/stack_trace.h"
 #include "util/random.h"

db/db_flush_test.cc

@@ -11,7 +11,6 @@
 
 #include "db/db_impl/db_impl.h"
 #include "db/db_test_util.h"
-#include "env/mock_env.h"
 #include "file/filename.h"
 #include "port/port.h"
 #include "port/stack_trace.h"

db/db_impl/db_impl.cc

@@ -151,13 +151,12 @@ DBImpl::DBImpl(const DBOptions& options, const std::string& dbname,
       own_info_log_(options.info_log == nullptr),
       initial_db_options_(SanitizeOptions(dbname, options)),
       env_(initial_db_options_.env),
-      clock_(initial_db_options_.env->GetSystemClock()),
       io_tracer_(std::make_shared<IOTracer>()),
       immutable_db_options_(initial_db_options_),
       fs_(immutable_db_options_.fs, io_tracer_),
       mutable_db_options_(initial_db_options_),
       stats_(immutable_db_options_.statistics.get()),
-      mutex_(stats_, clock_, DB_MUTEX_WAIT_MICROS,
+      mutex_(stats_, env_, DB_MUTEX_WAIT_MICROS,
              immutable_db_options_.use_adaptive_mutex),
       default_cf_handle_(nullptr),
       max_total_in_memory_state_(0),
@@ -192,7 +191,7 @@ DBImpl::DBImpl(const DBOptions& options, const std::string& dbname,
       bg_purge_scheduled_(0),
       disable_delete_obsolete_files_(0),
       pending_purge_obsolete_files_(0),
-      delete_obsolete_files_last_run_(clock_->NowMicros()),
+      delete_obsolete_files_last_run_(env_->NowMicros()),
       last_stats_dump_time_microsec_(0),
       next_job_id_(1),
       has_unpersisted_data_(false),
@@ -753,7 +752,7 @@ void DBImpl::PersistStats() {
     return;
   }
   TEST_SYNC_POINT("DBImpl::PersistStats:StartRunning");
-  uint64_t now_seconds = clock_->NowMicros() / kMicrosInSecond;
+  uint64_t now_seconds = env_->NowMicros() / kMicrosInSecond;
 
   Statistics* statistics = immutable_db_options_.statistics.get();
   if (!statistics) {
@@ -1654,8 +1653,8 @@ Status DBImpl::GetImpl(const ReadOptions& read_options, const Slice& key,
   }
 #endif  // NDEBUG
 
-  PERF_CPU_TIMER_GUARD(get_cpu_nanos, clock_);
-  StopWatch sw(clock_, stats_, DB_GET);
+  PERF_CPU_TIMER_GUARD(get_cpu_nanos, env_);
+  StopWatch sw(env_, stats_, DB_GET);
   PERF_TIMER_GUARD(get_snapshot_time);
 
   auto cfh = static_cast_with_check<ColumnFamilyHandleImpl>(
@@ -1845,8 +1844,8 @@ std::vector<Status> DBImpl::MultiGet(
     const std::vector<ColumnFamilyHandle*>& column_family,
     const std::vector<Slice>& keys, std::vector<std::string>* values,
     std::vector<std::string>* timestamps) {
-  PERF_CPU_TIMER_GUARD(get_cpu_nanos, clock_);
-  StopWatch sw(clock_, stats_, DB_MULTIGET);
+  PERF_CPU_TIMER_GUARD(get_cpu_nanos, env_);
+  StopWatch sw(env_, stats_, DB_MULTIGET);
   PERF_TIMER_GUARD(get_snapshot_time);
 
 #ifndef NDEBUG
@@ -1977,7 +1976,7 @@ std::vector<Status> DBImpl::MultiGet(
     }
 
     if (read_options.deadline.count() &&
-        clock_->NowMicros() >
+        env_->NowMicros() >
             static_cast<uint64_t>(read_options.deadline.count())) {
       break;
     }
@@ -1986,8 +1985,8 @@ std::vector<Status> DBImpl::MultiGet(
   if (keys_read < num_keys) {
     // The only reason to break out of the loop is when the deadline is
     // exceeded
-    assert(clock_->NowMicros() >
-           static_cast<uint64_t>(read_options.deadline.count()));
+    assert(env_->NowMicros() >
+        static_cast<uint64_t>(read_options.deadline.count()));
     for (++keys_read; keys_read < num_keys; ++keys_read) {
       stat_list[keys_read] = Status::TimedOut();
     }
@@ -2426,8 +2425,8 @@ Status DBImpl::MultiGetImpl(
     autovector<KeyContext*, MultiGetContext::MAX_BATCH_SIZE>* sorted_keys,
     SuperVersion* super_version, SequenceNumber snapshot,
     ReadCallback* callback) {
-  PERF_CPU_TIMER_GUARD(get_cpu_nanos, clock_);
-  StopWatch sw(clock_, stats_, DB_MULTIGET);
+  PERF_CPU_TIMER_GUARD(get_cpu_nanos, env_);
+  StopWatch sw(env_, stats_, DB_MULTIGET);
 
   // For each of the given keys, apply the entire "get" process as follows:
   // First look in the memtable, then in the immutable memtable (if any).
@@ -2438,7 +2437,7 @@ Status DBImpl::MultiGetImpl(
   uint64_t curr_value_size = 0;
   while (keys_left) {
     if (read_options.deadline.count() &&
-        clock_->NowMicros() >
+        env_->NowMicros() >
             static_cast<uint64_t>(read_options.deadline.count())) {
       s = Status::TimedOut();
       break;
@@ -3141,8 +3140,7 @@ FileSystem* DBImpl::GetFileSystem() const {
 Status DBImpl::StartIOTrace(Env* env, const TraceOptions& trace_options,
                             std::unique_ptr<TraceWriter>&& trace_writer) {
   assert(trace_writer != nullptr);
-  return io_tracer_->StartIOTrace(env->GetSystemClock(), trace_options,
-                                  std::move(trace_writer));
+  return io_tracer_->StartIOTrace(env, trace_options, std::move(trace_writer));
 }
 
 Status DBImpl::EndIOTrace() {
@@ -4423,7 +4421,7 @@ Status DBImpl::IngestExternalFiles(
   for (const auto& arg : args) {
     auto* cfd = static_cast<ColumnFamilyHandleImpl*>(arg.column_family)->cfd();
     ingestion_jobs.emplace_back(
-        clock_, versions_.get(), cfd, immutable_db_options_, file_options_,
+        env_, versions_.get(), cfd, immutable_db_options_, file_options_,
         &snapshots_, arg.options, &directories_, &event_logger_, io_tracer_);
   }
 
@@ -4691,7 +4689,7 @@ Status DBImpl::CreateColumnFamilyWithImport(
   // Import sst files from metadata.
   auto cfh = static_cast_with_check<ColumnFamilyHandleImpl>(*handle);
   auto cfd = cfh->cfd();
-  ImportColumnFamilyJob import_job(clock_, versions_.get(), cfd,
+  ImportColumnFamilyJob import_job(env_, versions_.get(), cfd,
                                    immutable_db_options_, file_options_,
                                    import_options, metadata.files, io_tracer_);
 
@@ -4947,7 +4945,7 @@ void DBImpl::WaitForIngestFile() {
 Status DBImpl::StartTrace(const TraceOptions& trace_options,
                           std::unique_ptr<TraceWriter>&& trace_writer) {
   InstrumentedMutexLock lock(&trace_mutex_);
-  tracer_.reset(new Tracer(clock_, trace_options, std::move(trace_writer)));
+  tracer_.reset(new Tracer(env_, trace_options, std::move(trace_writer)));
   return Status::OK();
 }
 

db/db_impl/db_impl.h

@@ -54,6 +54,9 @@
 #include "rocksdb/transaction_log.h"
 #include "rocksdb/write_buffer_manager.h"
 #include "table/scoped_arena_iterator.h"
+#include "trace_replay/block_cache_tracer.h"
+#include "trace_replay/io_tracer.h"
+#include "trace_replay/trace_replay.h"
 #include "util/autovector.h"
 #include "util/hash.h"
 #include "util/repeatable_thread.h"
@@ -1056,7 +1059,6 @@ class DBImpl : public DB {
   bool own_info_log_;
   const DBOptions initial_db_options_;
   Env* const env_;
-  std::shared_ptr<SystemClock> clock_;
   std::shared_ptr<IOTracer> io_tracer_;
   const ImmutableDBOptions immutable_db_options_;
   FileSystemPtr fs_;

db/db_impl/db_impl_compaction_flush.cc

@@ -2564,7 +2564,7 @@ void DBImpl::BackgroundCallFlush(Env::Priority thread_pri) {
                       s.ToString().c_str(), error_cnt);
       log_buffer.FlushBufferToLog();
       LogFlush(immutable_db_options_.info_log);
-      clock_->SleepForMicroseconds(1000000);
+      env_->SleepForMicroseconds(1000000);
       mutex_.Lock();
     }
 
@@ -2637,7 +2637,7 @@ void DBImpl::BackgroundCallCompaction(PrepickedCompaction* prepicked_compaction,
     if (s.IsBusy()) {
       bg_cv_.SignalAll();  // In case a waiter can proceed despite the error
       mutex_.Unlock();
-      clock_->SleepForMicroseconds(10000);  // prevent hot loop
+      env_->SleepForMicroseconds(10000);  // prevent hot loop
       mutex_.Lock();
     } else if (!s.ok() && !s.IsShutdownInProgress() &&
                !s.IsManualCompactionPaused() && !s.IsColumnFamilyDropped()) {
@@ -2655,7 +2655,7 @@ void DBImpl::BackgroundCallCompaction(PrepickedCompaction* prepicked_compaction,
                       "Accumulated background error counts: %" PRIu64,
                       s.ToString().c_str(), error_cnt);
       LogFlush(immutable_db_options_.info_log);
-      clock_->SleepForMicroseconds(1000000);
+      env_->SleepForMicroseconds(1000000);
       mutex_.Lock();
     } else if (s.IsManualCompactionPaused()) {
       ManualCompactionState* m = prepicked_compaction->manual_compaction_state;

db/db_impl/db_impl_files.cc

@@ -120,7 +120,7 @@ void DBImpl::FindObsoleteFiles(JobContext* job_context, bool force,
              mutable_db_options_.delete_obsolete_files_period_micros == 0) {
     doing_the_full_scan = true;
   } else {
-    const uint64_t now_micros = clock_->NowMicros();
+    const uint64_t now_micros = env_->NowMicros();
     if ((delete_obsolete_files_last_run_ +
          mutable_db_options_.delete_obsolete_files_period_micros) <
         now_micros) {

db/db_impl/db_impl_open.cc

@@ -293,7 +293,7 @@ Status DBImpl::NewDB(std::vector<std::string>* new_filenames) {
     file->SetPreallocationBlockSize(
         immutable_db_options_.manifest_preallocation_size);
     std::unique_ptr<WritableFileWriter> file_writer(new WritableFileWriter(
-        std::move(file), manifest, file_options, clock_, io_tracer_,
+        std::move(file), manifest, file_options, env_, io_tracer_,
         nullptr /* stats */, immutable_db_options_.listeners, nullptr,
         tmp_set.Contains(FileType::kDescriptorFile)));
     log::Writer log(std::move(file_writer), 0, false);
@@ -301,7 +301,7 @@ Status DBImpl::NewDB(std::vector<std::string>* new_filenames) {
     new_db.EncodeTo(&record);
     s = log.AddRecord(record);
     if (s.ok()) {
-      s = SyncManifest(clock_, &immutable_db_options_, log.file());
+      s = SyncManifest(env_, &immutable_db_options_, log.file());
     }
   }
   if (s.ok()) {
@@ -1297,7 +1297,7 @@ Status DBImpl::RestoreAliveLogFiles(const std::vector<uint64_t>& wal_numbers) {
 Status DBImpl::WriteLevel0TableForRecovery(int job_id, ColumnFamilyData* cfd,
                                            MemTable* mem, VersionEdit* edit) {
   mutex_.AssertHeld();
-  const uint64_t start_micros = clock_->NowMicros();
+  const uint64_t start_micros = env_->NowMicros();
 
   FileMetaData meta;
   std::vector<BlobFileAddition> blob_file_additions;
@@ -1399,7 +1399,7 @@ Status DBImpl::WriteLevel0TableForRecovery(int job_id, ColumnFamilyData* cfd,
   }
 
   InternalStats::CompactionStats stats(CompactionReason::kFlush, 1);
-  stats.micros = clock_->NowMicros() - start_micros;
+  stats.micros = env_->NowMicros() - start_micros;
 
   if (has_output) {
     stats.bytes_written = meta.fd.GetFileSize();
@@ -1491,7 +1491,7 @@ IOStatus DBImpl::CreateWAL(uint64_t log_file_num, uint64_t recycle_log_number,
     const auto& listeners = immutable_db_options_.listeners;
     FileTypeSet tmp_set = immutable_db_options_.checksum_handoff_file_types;
     std::unique_ptr<WritableFileWriter> file_writer(new WritableFileWriter(
-        std::move(lfile), log_fname, opt_file_options, clock_, io_tracer_,
+        std::move(lfile), log_fname, opt_file_options, env_, io_tracer_,
         nullptr /* stats */, listeners, nullptr,
         tmp_set.Contains(FileType::kWalFile)));
     *new_log = new log::Writer(std::move(file_writer), log_file_num,

db/db_impl/db_impl_secondary.cc

@@ -327,8 +327,8 @@ Status DBImplSecondary::GetImpl(const ReadOptions& read_options,
                                 ColumnFamilyHandle* column_family,
                                 const Slice& key, PinnableSlice* pinnable_val) {
   assert(pinnable_val != nullptr);
-  PERF_CPU_TIMER_GUARD(get_cpu_nanos, clock_);
-  StopWatch sw(clock_, stats_, DB_GET);
+  PERF_CPU_TIMER_GUARD(get_cpu_nanos, env_);
+  StopWatch sw(env_, stats_, DB_GET);
   PERF_TIMER_GUARD(get_snapshot_time);
 
   auto cfh = static_cast<ColumnFamilyHandleImpl*>(column_family);

db/db_impl/db_impl_write.cc

@@ -160,7 +160,7 @@ Status DBImpl::WriteImpl(const WriteOptions& write_options,
     RecordTick(stats_, WRITE_WITH_WAL);
   }
 
-  StopWatch write_sw(clock_, immutable_db_options_.statistics.get(), DB_WRITE);
+  StopWatch write_sw(env_, immutable_db_options_.statistics.get(), DB_WRITE);
 
   write_thread_.JoinBatchGroup(&w);
   if (w.state == WriteThread::STATE_PARALLEL_MEMTABLE_WRITER) {
@@ -465,7 +465,7 @@ Status DBImpl::PipelinedWriteImpl(const WriteOptions& write_options,
                                   uint64_t* log_used, uint64_t log_ref,
                                   bool disable_memtable, uint64_t* seq_used) {
   PERF_TIMER_GUARD(write_pre_and_post_process_time);
-  StopWatch write_sw(clock_, immutable_db_options_.statistics.get(), DB_WRITE);
+  StopWatch write_sw(env_, immutable_db_options_.statistics.get(), DB_WRITE);
 
   WriteContext write_context;
 
@@ -621,7 +621,7 @@ Status DBImpl::UnorderedWriteMemtable(const WriteOptions& write_options,
                                       SequenceNumber seq,
                                       const size_t sub_batch_cnt) {
   PERF_TIMER_GUARD(write_pre_and_post_process_time);
-  StopWatch write_sw(clock_, immutable_db_options_.statistics.get(), DB_WRITE);
+  StopWatch write_sw(env_, immutable_db_options_.statistics.get(), DB_WRITE);
 
   WriteThread::Writer w(write_options, my_batch, callback, log_ref,
                         false /*disable_memtable*/);
@@ -676,7 +676,7 @@ Status DBImpl::WriteImplWALOnly(
   WriteThread::Writer w(write_options, my_batch, callback, log_ref,
                         disable_memtable, sub_batch_cnt, pre_release_callback);
   RecordTick(stats_, WRITE_WITH_WAL);
-  StopWatch write_sw(clock_, immutable_db_options_.statistics.get(), DB_WRITE);
+  StopWatch write_sw(env_, immutable_db_options_.statistics.get(), DB_WRITE);
 
   write_thread->JoinBatchGroup(&w);
   assert(w.state != WriteThread::STATE_PARALLEL_MEMTABLE_WRITER);
@@ -1093,7 +1093,7 @@ IOStatus DBImpl::WriteToWAL(const WriteThread::WriteGroup& write_group,
   }
 
   if (io_s.ok() && need_log_sync) {
-    StopWatch sw(clock_, stats_, WAL_FILE_SYNC_MICROS);
+    StopWatch sw(env_, stats_, WAL_FILE_SYNC_MICROS);
     // It's safe to access logs_ with unlocked mutex_ here because:
     //  - we've set getting_synced=true for all logs,
     //    so other threads won't pop from logs_ while we're here,
@@ -1457,8 +1457,8 @@ Status DBImpl::DelayWrite(uint64_t num_bytes,
   uint64_t time_delayed = 0;
   bool delayed = false;
   {
-    StopWatch sw(clock_, stats_, WRITE_STALL, &time_delayed);
-    uint64_t delay = write_controller_.GetDelay(clock_, num_bytes);
+    StopWatch sw(env_, stats_, WRITE_STALL, &time_delayed);
+    uint64_t delay = write_controller_.GetDelay(env_, num_bytes);
     if (delay > 0) {
       if (write_options.no_slowdown) {
         return Status::Incomplete("Write stall");
@@ -1475,14 +1475,14 @@ Status DBImpl::DelayWrite(uint64_t num_bytes,
       const uint64_t kDelayInterval = 1000;
       uint64_t stall_end = sw.start_time() + delay;
       while (write_controller_.NeedsDelay()) {
-        if (clock_->NowMicros() >= stall_end) {
+        if (env_->NowMicros() >= stall_end) {
           // We already delayed this write `delay` microseconds
           break;
         }
 
         delayed = true;
         // Sleep for 0.001 seconds
-        clock_->SleepForMicroseconds(kDelayInterval);
+        env_->SleepForMicroseconds(kDelayInterval);
       }
       mutex_.Lock();
       write_thread_.EndWriteStall();

db/db_iter.cc

@@ -8,10 +8,9 @@
 // found in the LICENSE file. See the AUTHORS file for names of contributors.
 
 #include "db/db_iter.h"
-
+#include <string>
 #include <iostream>
 #include <limits>
-#include <string>
 
 #include "db/dbformat.h"
 #include "db/merge_context.h"
@@ -25,7 +24,6 @@
 #include "rocksdb/iterator.h"
 #include "rocksdb/merge_operator.h"
 #include "rocksdb/options.h"
-#include "rocksdb/system_clock.h"
 #include "table/internal_iterator.h"
 #include "table/iterator_wrapper.h"
 #include "trace_replay/trace_replay.h"
@@ -45,7 +43,6 @@ DBIter::DBIter(Env* _env, const ReadOptions& read_options,
                ColumnFamilyData* cfd, bool expose_blob_index)
     : prefix_extractor_(mutable_cf_options.prefix_extractor.get()),
       env_(_env),
-      clock_(_env->GetSystemClock()),
       logger_(cf_options.info_log),
       user_comparator_(cmp),
       merge_operator_(cf_options.merge_operator),
@@ -130,7 +127,7 @@ void DBIter::Next() {
   assert(valid_);
   assert(status_.ok());
 
-  PERF_CPU_TIMER_GUARD(iter_next_cpu_nanos, clock_);
+  PERF_CPU_TIMER_GUARD(iter_next_cpu_nanos, env_);
   // Release temporarily pinned blocks from last operation
   ReleaseTempPinnedData();
   local_stats_.skip_count_ += num_internal_keys_skipped_;
@@ -577,7 +574,7 @@ bool DBIter::MergeValuesNewToOld() {
       const Slice val = iter_.value();
       Status s = MergeHelper::TimedFullMerge(
           merge_operator_, ikey.user_key, &val, merge_context_.GetOperands(),
-          &saved_value_, logger_, statistics_, clock_, &pinned_value_, true);
+          &saved_value_, logger_, statistics_, env_, &pinned_value_, true);
       if (!s.ok()) {
         valid_ = false;
         status_ = s;
@@ -620,7 +617,7 @@ bool DBIter::MergeValuesNewToOld() {
   // client can differentiate this scenario and do things accordingly.
   Status s = MergeHelper::TimedFullMerge(
       merge_operator_, saved_key_.GetUserKey(), nullptr,
-      merge_context_.GetOperands(), &saved_value_, logger_, statistics_, clock_,
+      merge_context_.GetOperands(), &saved_value_, logger_, statistics_, env_,
       &pinned_value_, true);
   if (!s.ok()) {
     valid_ = false;
@@ -643,7 +640,7 @@ void DBIter::Prev() {
   assert(valid_);
   assert(status_.ok());
 
-  PERF_CPU_TIMER_GUARD(iter_prev_cpu_nanos, clock_);
+  PERF_CPU_TIMER_GUARD(iter_prev_cpu_nanos, env_);
   ReleaseTempPinnedData();
   ResetInternalKeysSkippedCounter();
   bool ok = true;
@@ -924,7 +921,7 @@ bool DBIter::FindValueForCurrentKey() {
         s = MergeHelper::TimedFullMerge(
             merge_operator_, saved_key_.GetUserKey(), nullptr,
             merge_context_.GetOperands(), &saved_value_, logger_, statistics_,
-            clock_, &pinned_value_, true);
+            env_, &pinned_value_, true);
       } else if (last_not_merge_type == kTypeBlobIndex) {
         status_ =
             Status::NotSupported("BlobDB does not support merge operator.");
@@ -935,7 +932,7 @@ bool DBIter::FindValueForCurrentKey() {
         s = MergeHelper::TimedFullMerge(
             merge_operator_, saved_key_.GetUserKey(), &pinned_value_,
             merge_context_.GetOperands(), &saved_value_, logger_, statistics_,
-            clock_, &pinned_value_, true);
+            env_, &pinned_value_, true);
       }
       break;
     case kTypeValue:
@@ -1073,7 +1070,7 @@ bool DBIter::FindValueForCurrentKeyUsingSeek() {
       Status s = MergeHelper::TimedFullMerge(
           merge_operator_, saved_key_.GetUserKey(), &val,
           merge_context_.GetOperands(), &saved_value_, logger_, statistics_,
-          clock_, &pinned_value_, true);
+          env_, &pinned_value_, true);
       if (!s.ok()) {
         valid_ = false;
         status_ = s;
@@ -1100,7 +1097,7 @@ bool DBIter::FindValueForCurrentKeyUsingSeek() {
 
   Status s = MergeHelper::TimedFullMerge(
       merge_operator_, saved_key_.GetUserKey(), nullptr,
-      merge_context_.GetOperands(), &saved_value_, logger_, statistics_, clock_,
+      merge_context_.GetOperands(), &saved_value_, logger_, statistics_, env_,
       &pinned_value_, true);
   if (!s.ok()) {
     valid_ = false;
@@ -1251,8 +1248,8 @@ void DBIter::SetSavedKeyToSeekForPrevTarget(const Slice& target) {
 }
 
 void DBIter::Seek(const Slice& target) {
-  PERF_CPU_TIMER_GUARD(iter_seek_cpu_nanos, clock_);
-  StopWatch sw(clock_, statistics_, DB_SEEK);
+  PERF_CPU_TIMER_GUARD(iter_seek_cpu_nanos, env_);
+  StopWatch sw(env_, statistics_, DB_SEEK);
 
 #ifndef ROCKSDB_LITE
   if (db_impl_ != nullptr && cfd_ != nullptr) {
@@ -1325,8 +1322,8 @@ void DBIter::Seek(const Slice& target) {
 }
 
 void DBIter::SeekForPrev(const Slice& target) {
-  PERF_CPU_TIMER_GUARD(iter_seek_cpu_nanos, clock_);
-  StopWatch sw(clock_, statistics_, DB_SEEK);
+  PERF_CPU_TIMER_GUARD(iter_seek_cpu_nanos, env_);
+  StopWatch sw(env_, statistics_, DB_SEEK);
 
 #ifndef ROCKSDB_LITE
   if (db_impl_ != nullptr && cfd_ != nullptr) {
@@ -1406,7 +1403,7 @@ void DBIter::SeekToFirst() {
     Seek(*iterate_lower_bound_);
     return;
   }
-  PERF_CPU_TIMER_GUARD(iter_seek_cpu_nanos, clock_);
+  PERF_CPU_TIMER_GUARD(iter_seek_cpu_nanos, env_);
   // Don't use iter_::Seek() if we set a prefix extractor
   // because prefix seek will be used.
   if (!expect_total_order_inner_iter()) {
@@ -1467,7 +1464,7 @@ void DBIter::SeekToLast() {
     return;
   }
 
-  PERF_CPU_TIMER_GUARD(iter_seek_cpu_nanos, clock_);
+  PERF_CPU_TIMER_GUARD(iter_seek_cpu_nanos, env_);
   // Don't use iter_::Seek() if we set a prefix extractor
   // because prefix seek will be used.
   if (!expect_total_order_inner_iter()) {

db/db_iter.h

@@ -21,7 +21,7 @@
 #include "util/autovector.h"
 
 namespace ROCKSDB_NAMESPACE {
-class SystemClock_;
+
 class Version;
 
 // This file declares the factory functions of DBIter, in its original form
@@ -298,7 +298,6 @@ class DBIter final : public Iterator {
 
   const SliceTransform* prefix_extractor_;
   Env* const env_;
-  std::shared_ptr<SystemClock> clock_;
   Logger* logger_;
   UserComparatorWrapper user_comparator_;
   const MergeOperator* const merge_operator_;

db/db_log_iter_test.cc

@@ -13,7 +13,6 @@
 #if !defined(ROCKSDB_LITE)
 
 #include "db/db_test_util.h"
-#include "env/mock_env.h"
 #include "port/stack_trace.h"
 
 namespace ROCKSDB_NAMESPACE {

db/db_test_util.cc

@@ -10,7 +10,6 @@
 #include "db/db_test_util.h"
 
 #include "db/forward_iterator.h"
-#include "env/mock_env.h"
 #include "rocksdb/convenience.h"
 #include "rocksdb/env_encryption.h"
 #include "rocksdb/utilities/object_registry.h"

db/db_test_util.h

@@ -23,6 +23,7 @@
 
 #include "db/db_impl/db_impl.h"
 #include "db/dbformat.h"
+#include "env/mock_env.h"
 #include "file/filename.h"
 #include "memtable/hash_linklist_rep.h"
 #include "rocksdb/cache.h"
@@ -39,6 +40,7 @@
 #include "rocksdb/utilities/checkpoint.h"
 #include "table/mock_table.h"
 #include "table/scoped_arena_iterator.h"
+#include "test_util/mock_time_env.h"
 #include "test_util/sync_point.h"
 #include "test_util/testharness.h"
 #include "util/cast_util.h"
@@ -48,7 +50,6 @@
 #include "utilities/merge_operators.h"
 
 namespace ROCKSDB_NAMESPACE {
-class MockEnv;
 
 namespace anon {
 class AtomicCounter {

db/db_wal_test.cc

@@ -8,10 +8,10 @@
 // found in the LICENSE file. See the AUTHORS file for names of contributors.
 
 #include "db/db_test_util.h"
+#include "env/composite_env_wrapper.h"
 #include "options/options_helper.h"
 #include "port/port.h"
 #include "port/stack_trace.h"
-#include "rocksdb/file_system.h"
 #include "test_util/sync_point.h"
 #include "utilities/fault_injection_env.h"
 #include "utilities/fault_injection_fs.h"
@@ -1229,7 +1229,7 @@ class RecoveryTestHelper {
     *count = 0;
 
     std::shared_ptr<Cache> table_cache = NewLRUCache(50, 0);
-    FileOptions file_options;
+    EnvOptions env_options;
     WriteBufferManager write_buffer_manager(db_options.db_write_buffer_size);
 
     std::unique_ptr<VersionSet> versions;
@@ -1237,22 +1237,22 @@ class RecoveryTestHelper {
     WriteController write_controller;
 
     versions.reset(new VersionSet(
-        test->dbname_, &db_options, file_options, table_cache.get(),
+        test->dbname_, &db_options, env_options, table_cache.get(),
         &write_buffer_manager, &write_controller,
         /*block_cache_tracer=*/nullptr, /*io_tracer=*/nullptr));
 
     wal_manager.reset(
-        new WalManager(db_options, file_options, /*io_tracer=*/nullptr));
+        new WalManager(db_options, env_options, /*io_tracer=*/nullptr));
 
     std::unique_ptr<log::Writer> current_log_writer;
 
     for (size_t j = kWALFileOffset; j < wal_count + kWALFileOffset; j++) {
       uint64_t current_log_number = j;
       std::string fname = LogFileName(test->dbname_, current_log_number);
-      std::unique_ptr<WritableFileWriter> file_writer;
-      ASSERT_OK(WritableFileWriter::Create(db_options.env->GetFileSystem(),
-                                           fname, file_options, &file_writer,
-                                           nullptr));
+      std::unique_ptr<WritableFile> file;
+      ASSERT_OK(db_options.env->NewWritableFile(fname, &file, env_options));
+      std::unique_ptr<WritableFileWriter> file_writer(new WritableFileWriter(
+          NewLegacyWritableFileWrapper(std::move(file)), fname, env_options));
       current_log_writer.reset(
           new log::Writer(std::move(file_writer), current_log_number,
                           db_options.recycle_log_file_num > 0));

db/error_handler.cc

@@ -670,7 +670,7 @@ void ErrorHandler::RecoverFromRetryableBGIOError() {
       // a period of time and redo auto resume if it is allowed.
       TEST_SYNC_POINT("RecoverFromRetryableBGIOError:BeforeWait0");
       TEST_SYNC_POINT("RecoverFromRetryableBGIOError:BeforeWait1");
-      int64_t wait_until = db_->clock_->NowMicros() + wait_interval;
+      int64_t wait_until = db_->env_->NowMicros() + wait_interval;
       cv_.TimedWait(wait_until);
       TEST_SYNC_POINT("RecoverFromRetryableBGIOError:AfterWait0");
     } else {

db/external_sst_file_ingestion_job.cc

@@ -293,13 +293,12 @@ Status ExternalSstFileIngestionJob::Prepare(
 
   // TODO: The following is duplicated with Cleanup().
   if (!status.ok()) {
-    IOOptions io_opts;
     // We failed, remove all files that we copied into the db
     for (IngestedFileInfo& f : files_to_ingest_) {
       if (f.internal_file_path.empty()) {
         continue;
       }
-      Status s = fs_->DeleteFile(f.internal_file_path, io_opts, nullptr);
+      Status s = env_->DeleteFile(f.internal_file_path);
       if (!s.ok()) {
         ROCKS_LOG_WARN(db_options_.info_log,
                        "AddFile() clean up for file %s failed : %s",
@@ -393,7 +392,7 @@ Status ExternalSstFileIngestionJob::Run() {
     int64_t temp_current_time = 0;
     uint64_t current_time = kUnknownFileCreationTime;
     uint64_t oldest_ancester_time = kUnknownOldestAncesterTime;
-    if (clock_->GetCurrentTime(&temp_current_time).ok()) {
+    if (env_->GetCurrentTime(&temp_current_time).ok()) {
       current_time = oldest_ancester_time =
           static_cast<uint64_t>(temp_current_time);
     }
@@ -411,7 +410,7 @@ void ExternalSstFileIngestionJob::UpdateStats() {
   // Update internal stats for new ingested files
   uint64_t total_keys = 0;
   uint64_t total_l0_files = 0;
-  uint64_t total_time = clock_->NowMicros() - job_start_time_;
+  uint64_t total_time = env_->NowMicros() - job_start_time_;
 
   EventLoggerStream stream = event_logger_->Log();
   stream << "event"
@@ -467,7 +466,6 @@ void ExternalSstFileIngestionJob::UpdateStats() {
 }
 
 void ExternalSstFileIngestionJob::Cleanup(const Status& status) {
-  IOOptions io_opts;
   if (!status.ok()) {
     // We failed to add the files to the database
     // remove all the files we copied
@@ -475,7 +473,7 @@ void ExternalSstFileIngestionJob::Cleanup(const Status& status) {
       if (f.internal_file_path.empty()) {
         continue;
       }
-      Status s = fs_->DeleteFile(f.internal_file_path, io_opts, nullptr);
+      Status s = env_->DeleteFile(f.internal_file_path);
       if (!s.ok()) {
         ROCKS_LOG_WARN(db_options_.info_log,
                        "AddFile() clean up for file %s failed : %s",
@@ -487,7 +485,7 @@ void ExternalSstFileIngestionJob::Cleanup(const Status& status) {
   } else if (status.ok() && ingestion_options_.move_files) {
     // The files were moved and added successfully, remove original file links
     for (IngestedFileInfo& f : files_to_ingest_) {
-      Status s = fs_->DeleteFile(f.external_file_path, io_opts, nullptr);
+      Status s = env_->DeleteFile(f.external_file_path);
       if (!s.ok()) {
         ROCKS_LOG_WARN(
             db_options_.info_log,

db/external_sst_file_ingestion_job.h

@@ -16,14 +16,13 @@
 #include "logging/event_logger.h"
 #include "options/db_options.h"
 #include "rocksdb/db.h"
-#include "rocksdb/file_system.h"
+#include "rocksdb/env.h"
 #include "rocksdb/sst_file_writer.h"
 #include "util/autovector.h"
 
 namespace ROCKSDB_NAMESPACE {
 
 class Directories;
-class SystemClock;
 
 struct IngestedFileInfo {
   // External file path
@@ -74,13 +73,13 @@ struct IngestedFileInfo {
 class ExternalSstFileIngestionJob {
  public:
   ExternalSstFileIngestionJob(
-      const std::shared_ptr<SystemClock>& clock, VersionSet* versions,
-      ColumnFamilyData* cfd, const ImmutableDBOptions& db_options,
-      const EnvOptions& env_options, SnapshotList* db_snapshots,
+      Env* env, VersionSet* versions, ColumnFamilyData* cfd,
+      const ImmutableDBOptions& db_options, const EnvOptions& env_options,
+      SnapshotList* db_snapshots,
       const IngestExternalFileOptions& ingestion_options,
       Directories* directories, EventLogger* event_logger,
       const std::shared_ptr<IOTracer>& io_tracer)
-      : clock_(clock),
+      : env_(env),
         fs_(db_options.fs, io_tracer),
         versions_(versions),
         cfd_(cfd),
@@ -90,7 +89,7 @@ class ExternalSstFileIngestionJob {
         ingestion_options_(ingestion_options),
         directories_(directories),
         event_logger_(event_logger),
-        job_start_time_(clock_->NowMicros()),
+        job_start_time_(env_->NowMicros()),
         consumed_seqno_count_(0),
         io_tracer_(io_tracer) {
     assert(directories != nullptr);
@@ -170,7 +169,7 @@ class ExternalSstFileIngestionJob {
   template <typename TWritableFile>
   Status SyncIngestedFile(TWritableFile* file);
 
-  std::shared_ptr<SystemClock> clock_;
+  Env* env_;
   FileSystemPtr fs_;
   VersionSet* versions_;
   ColumnFamilyData* cfd_;

db/flush_job.cc

@@ -127,7 +127,6 @@ FlushJob::FlushJob(const std::string& dbname, ColumnFamilyData* cfd,
       pick_memtable_called(false),
       thread_pri_(thread_pri),
       io_tracer_(io_tracer),
-      clock_(db_options_.env->GetSystemClock()),
       full_history_ts_low_(std::move(full_history_ts_low)) {
   // Update the thread status to indicate flush.
   ReportStartedFlush();
@@ -310,8 +309,8 @@ Status FlushJob::WriteLevel0Table() {
   AutoThreadOperationStageUpdater stage_updater(
       ThreadStatus::STAGE_FLUSH_WRITE_L0);
   db_mutex_->AssertHeld();
-  const uint64_t start_micros = clock_->NowMicros();
-  const uint64_t start_cpu_micros = clock_->CPUNanos() / 1000;
+  const uint64_t start_micros = db_options_.env->NowMicros();
+  const uint64_t start_cpu_micros = db_options_.env->NowCPUNanos() / 1000;
   Status s;
 
   std::vector<BlobFileAddition> blob_file_additions;
@@ -372,7 +371,7 @@ Status FlushJob::WriteLevel0Table() {
       TEST_SYNC_POINT_CALLBACK("FlushJob::WriteLevel0Table:output_compression",
                                &output_compression_);
       int64_t _current_time = 0;
-      auto status = clock_->GetCurrentTime(&_current_time);
+      auto status = db_options_.env->GetCurrentTime(&_current_time);
       // Safe to proceed even if GetCurrentTime fails. So, log and proceed.
       if (!status.ok()) {
         ROCKS_LOG_WARN(
@@ -467,8 +466,8 @@ Status FlushJob::WriteLevel0Table() {
 
   // Note that here we treat flush as level 0 compaction in internal stats
   InternalStats::CompactionStats stats(CompactionReason::kFlush, 1);
-  stats.micros = clock_->NowMicros() - start_micros;
-  stats.cpu_micros = clock_->CPUNanos() / 1000 - start_cpu_micros;
+  stats.micros = db_options_.env->NowMicros() - start_micros;
+  stats.cpu_micros = db_options_.env->NowCPUNanos() / 1000 - start_cpu_micros;
 
   if (has_output) {
     stats.bytes_written = meta_.fd.GetFileSize();

db/flush_job.h

@@ -162,7 +162,6 @@ class FlushJob {
   IOStatus io_status_;
 
   const std::shared_ptr<IOTracer> io_tracer_;
-  const std::shared_ptr<SystemClock> clock_;
 
   const std::string full_history_ts_low_;
 };

db/flush_job_test.cc

@@ -16,7 +16,6 @@
 #include "db/version_set.h"
 #include "file/writable_file_writer.h"
 #include "rocksdb/cache.h"
-#include "rocksdb/file_system.h"
 #include "rocksdb/write_buffer_manager.h"
 #include "table/mock_table.h"
 #include "test_util/testharness.h"
@@ -75,13 +74,12 @@ class FlushJobTestBase : public testing::Test {
     }
 
     const std::string manifest = DescriptorFileName(dbname_, 1);
-    const auto& fs = env_->GetFileSystem();
-    std::unique_ptr<WritableFileWriter> file_writer;
-    Status s = WritableFileWriter::Create(
-        fs, manifest, fs->OptimizeForManifestWrite(env_options_), &file_writer,
-        nullptr);
+    std::unique_ptr<WritableFile> file;
+    Status s = env_->NewWritableFile(
+        manifest, &file, env_->OptimizeForManifestWrite(env_options_));
     ASSERT_OK(s);
-
+    std::unique_ptr<WritableFileWriter> file_writer(new WritableFileWriter(
+        NewLegacyWritableFileWrapper(std::move(file)), manifest, EnvOptions()));
     {
       log::Writer log(std::move(file_writer), 0, false);
       std::string record;

db/import_column_family_job.cc

@@ -140,7 +140,7 @@ Status ImportColumnFamilyJob::Run() {
   int64_t temp_current_time = 0;
   uint64_t oldest_ancester_time = kUnknownOldestAncesterTime;
   uint64_t current_time = kUnknownOldestAncesterTime;
-  if (clock_->GetCurrentTime(&temp_current_time).ok()) {
+  if (env_->GetCurrentTime(&temp_current_time).ok()) {
     current_time = oldest_ancester_time =
         static_cast<uint64_t>(temp_current_time);
   }

db/import_column_family_job.h

@@ -9,26 +9,24 @@
 #include "db/snapshot_impl.h"
 #include "options/db_options.h"
 #include "rocksdb/db.h"
+#include "rocksdb/env.h"
 #include "rocksdb/metadata.h"
 #include "rocksdb/sst_file_writer.h"
 #include "util/autovector.h"
 
 namespace ROCKSDB_NAMESPACE {
-struct EnvOptions;
-class SystemClock;
 
 // Imports a set of sst files as is into a new column family. Logic is similar
 // to ExternalSstFileIngestionJob.
 class ImportColumnFamilyJob {
  public:
-  ImportColumnFamilyJob(const std::shared_ptr<SystemClock>& clock,
-                        VersionSet* versions, ColumnFamilyData* cfd,
+  ImportColumnFamilyJob(Env* env, VersionSet* versions, ColumnFamilyData* cfd,
                         const ImmutableDBOptions& db_options,
                         const EnvOptions& env_options,
                         const ImportColumnFamilyOptions& import_options,
                         const std::vector<LiveFileMetaData>& metadata,
                         const std::shared_ptr<IOTracer>& io_tracer)
-      : clock_(clock),
+      : env_(env),
         versions_(versions),
         cfd_(cfd),
         db_options_(db_options),
@@ -61,7 +59,7 @@ class ImportColumnFamilyJob {
                              IngestedFileInfo* file_to_import,
                              SuperVersion* sv);
 
-  std::shared_ptr<SystemClock> clock_;
+  Env* env_;
   VersionSet* versions_;
   ColumnFamilyData* cfd_;
   const ImmutableDBOptions& db_options_;

db/internal_stats.cc

@@ -990,7 +990,7 @@ bool InternalStats::HandleBlockCachePinnedUsage(uint64_t* value, DBImpl* /*db*/,
 void InternalStats::DumpDBStats(std::string* value) {
   char buf[1000];
   // DB-level stats, only available from default column family
-  double seconds_up = (clock_->NowMicros() - started_at_ + 1) / kMicrosInSec;
+  double seconds_up = (env_->NowMicros() - started_at_ + 1) / kMicrosInSec;
   double interval_seconds_up = seconds_up - db_stats_snapshot_.seconds_up;
   snprintf(buf, sizeof(buf),
            "\n** DB Stats **\nUptime(secs): %.1f total, %.1f interval\n",
@@ -1313,7 +1313,7 @@ void InternalStats::DumpCFStatsNoFileHistogram(std::string* value) {
     }
   }
 
-  double seconds_up = (clock_->NowMicros() - started_at_ + 1) / kMicrosInSec;
+  double seconds_up = (env_->NowMicros() - started_at_ + 1) / kMicrosInSec;
   double interval_seconds_up = seconds_up - cf_stats_snapshot_.seconds_up;
   snprintf(buf, sizeof(buf), "Uptime(secs): %.1f total, %.1f interval\n",
            seconds_up, interval_seconds_up);

db/internal_stats.h

@@ -14,7 +14,6 @@
 #include <vector>
 
 #include "db/version_set.h"
-#include "rocksdb/system_clock.h"
 
 class ColumnFamilyData;
 
@@ -123,8 +122,7 @@ class InternalStats {
     kIntStatsNumMax,
   };
 
-  InternalStats(int num_levels, const std::shared_ptr<SystemClock>& clock,
-                ColumnFamilyData* cfd)
+  InternalStats(int num_levels, Env* env, ColumnFamilyData* cfd)
       : db_stats_{},
         cf_stats_value_{},
         cf_stats_count_{},
@@ -133,9 +131,9 @@ class InternalStats {
         file_read_latency_(num_levels),
         bg_error_count_(0),
         number_levels_(num_levels),
-        clock_(clock),
+        env_(env),
         cfd_(cfd),
-        started_at_(clock->NowMicros()) {}
+        started_at_(env->NowMicros()) {}
 
   // Per level compaction stats.  comp_stats_[level] stores the stats for
   // compactions that produced data for the specified "level".
@@ -343,7 +341,7 @@ class InternalStats {
     cf_stats_snapshot_.Clear();
     db_stats_snapshot_.Clear();
     bg_error_count_ = 0;
-    started_at_ = clock_->NowMicros();
+    started_at_ = env_->NowMicros();
   }
 
   void AddCompactionStats(int level, Env::Priority thread_pri,
@@ -604,7 +602,7 @@ class InternalStats {
   uint64_t bg_error_count_;
 
   const int number_levels_;
-  const std::shared_ptr<SystemClock> clock_;
+  Env* env_;
   ColumnFamilyData* cfd_;
   uint64_t started_at_;
 };
@@ -643,9 +641,7 @@ class InternalStats {
     kIntStatsNumMax,
   };
 
-  InternalStats(int /*num_levels*/,
-                const std::shared_ptr<SystemClock>& /*clock*/,
-                ColumnFamilyData* /*cfd*/) {}
+  InternalStats(int /*num_levels*/, Env* /*env*/, ColumnFamilyData* /*cfd*/) {}
 
   struct CompactionStats {
     uint64_t micros;

db/memtable.cc

@@ -104,7 +104,7 @@ MemTable::MemTable(const InternalKeyComparator& cmp,
                  : 0),
       prefix_extractor_(mutable_cf_options.prefix_extractor.get()),
       flush_state_(FLUSH_NOT_REQUESTED),
-      clock_(ioptions.env->GetSystemClock()),
+      env_(ioptions.env),
       insert_with_hint_prefix_extractor_(
           ioptions.memtable_insert_with_hint_prefix_extractor),
       oldest_key_time_(std::numeric_limits<uint64_t>::max()),
@@ -223,7 +223,7 @@ void MemTable::UpdateOldestKeyTime() {
   uint64_t oldest_key_time = oldest_key_time_.load(std::memory_order_relaxed);
   if (oldest_key_time == std::numeric_limits<uint64_t>::max()) {
     int64_t current_time = 0;
-    auto s = clock_->GetCurrentTime(&current_time);
+    auto s = env_->GetCurrentTime(&current_time);
     if (s.ok()) {
       assert(current_time >= 0);
       // If fail, the timestamp is already set.
@@ -684,8 +684,7 @@ struct Saver {
   Statistics* statistics;
   bool inplace_update_support;
   bool do_merge;
-  std::shared_ptr<SystemClock> clock;
-
+  Env* env_;
   ReadCallback* callback_;
   bool* is_blob_index;
   bool allow_data_in_errors;
@@ -769,7 +768,7 @@ static bool SaveValue(void* arg, const char* entry) {
               *(s->status) = MergeHelper::TimedFullMerge(
                   merge_operator, s->key->user_key(), &v,
                   merge_context->GetOperands(), s->value, s->logger,
-                  s->statistics, s->clock, nullptr /* result_operand */, true);
+                  s->statistics, s->env_, nullptr /* result_operand */, true);
             }
           } else {
             // Preserve the value with the goal of returning it as part of
@@ -808,7 +807,7 @@ static bool SaveValue(void* arg, const char* entry) {
             *(s->status) = MergeHelper::TimedFullMerge(
                 merge_operator, s->key->user_key(), nullptr,
                 merge_context->GetOperands(), s->value, s->logger,
-                s->statistics, s->clock, nullptr /* result_operand */, true);
+                s->statistics, s->env_, nullptr /* result_operand */, true);
           }
         } else {
           *(s->status) = Status::NotFound();
@@ -836,7 +835,7 @@ static bool SaveValue(void* arg, const char* entry) {
           *(s->status) = MergeHelper::TimedFullMerge(
               merge_operator, s->key->user_key(), nullptr,
               merge_context->GetOperands(), s->value, s->logger, s->statistics,
-              s->clock, nullptr /* result_operand */, true);
+              s->env_, nullptr /* result_operand */, true);
           *(s->found_final_value) = true;
           return false;
         }
@@ -944,7 +943,7 @@ void MemTable::GetFromTable(const LookupKey& key,
   saver.logger = moptions_.info_log;
   saver.inplace_update_support = moptions_.inplace_update_support;
   saver.statistics = moptions_.statistics;
-  saver.clock = clock_;
+  saver.env_ = env_;
   saver.callback_ = callback;
   saver.is_blob_index = is_blob_index;
   saver.do_merge = do_merge;

db/memtable.h

@@ -26,6 +26,7 @@
 #include "monitoring/instrumented_mutex.h"
 #include "options/cf_options.h"
 #include "rocksdb/db.h"
+#include "rocksdb/env.h"
 #include "rocksdb/memtablerep.h"
 #include "table/multiget_context.h"
 #include "util/dynamic_bloom.h"
@@ -37,7 +38,6 @@ struct FlushJobInfo;
 class Mutex;
 class MemTableIterator;
 class MergeContext;
-class SystemClock;
 
 struct ImmutableMemTableOptions {
   explicit ImmutableMemTableOptions(const ImmutableCFOptions& ioptions,
@@ -512,7 +512,7 @@ class MemTable {
 
   std::atomic<FlushStateEnum> flush_state_;
 
-  std::shared_ptr<SystemClock> clock_;
+  Env* env_;
 
   // Extract sequential insert prefixes.
   const SliceTransform* insert_with_hint_prefix_extractor_;

db/merge_helper.cc

@@ -14,7 +14,6 @@
 #include "rocksdb/comparator.h"
 #include "rocksdb/db.h"
 #include "rocksdb/merge_operator.h"
-#include "rocksdb/system_clock.h"
 #include "table/format.h"
 #include "table/internal_iterator.h"
 
@@ -29,7 +28,6 @@ MergeHelper::MergeHelper(Env* env, const Comparator* user_comparator,
                          Statistics* stats,
                          const std::atomic<bool>* shutting_down)
     : env_(env),
-      clock_(env->GetSystemClock()),
       user_comparator_(user_comparator),
       user_merge_operator_(user_merge_operator),
       compaction_filter_(compaction_filter),
@@ -41,7 +39,7 @@ MergeHelper::MergeHelper(Env* env, const Comparator* user_comparator,
       snapshot_checker_(snapshot_checker),
       level_(level),
       keys_(),
-      filter_timer_(clock_),
+      filter_timer_(env_),
       total_filter_time_(0U),
       stats_(stats) {
   assert(user_comparator_ != nullptr);
@@ -50,11 +48,13 @@ MergeHelper::MergeHelper(Env* env, const Comparator* user_comparator,
   }
 }
 
-Status MergeHelper::TimedFullMerge(
-    const MergeOperator* merge_operator, const Slice& key, const Slice* value,
-    const std::vector<Slice>& operands, std::string* result, Logger* logger,
-    Statistics* statistics, const std::shared_ptr<SystemClock>& clock,
-    Slice* result_operand, bool update_num_ops_stats) {
+Status MergeHelper::TimedFullMerge(const MergeOperator* merge_operator,
+                                   const Slice& key, const Slice* value,
+                                   const std::vector<Slice>& operands,
+                                   std::string* result, Logger* logger,
+                                   Statistics* statistics, Env* env,
+                                   Slice* result_operand,
+                                   bool update_num_ops_stats) {
   assert(merge_operator != nullptr);
 
   if (operands.size() == 0) {
@@ -75,7 +75,7 @@ Status MergeHelper::TimedFullMerge(
   MergeOperator::MergeOperationOutput merge_out(*result, tmp_result_operand);
   {
     // Setup to time the merge
-    StopWatchNano timer(clock, statistics != nullptr);
+    StopWatchNano timer(env, statistics != nullptr);
     PERF_TIMER_GUARD(merge_operator_time_nanos);
 
     // Do the merge
@@ -213,7 +213,7 @@ Status MergeHelper::MergeUntil(InternalIterator* iter,
       std::string merge_result;
       s = TimedFullMerge(user_merge_operator_, ikey.user_key, val_ptr,
                          merge_context_.GetOperands(), &merge_result, logger_,
-                         stats_, clock_);
+                         stats_, env_);
 
       // We store the result in keys_.back() and operands_.back()
       // if nothing went wrong (i.e.: no operand corruption on disk)
@@ -324,7 +324,7 @@ Status MergeHelper::MergeUntil(InternalIterator* iter,
     std::string merge_result;
     s = TimedFullMerge(user_merge_operator_, orig_ikey.user_key, nullptr,
                        merge_context_.GetOperands(), &merge_result, logger_,
-                       stats_, clock_);
+                       stats_, env_);
     if (s.ok()) {
       // The original key encountered
       // We are certain that keys_ is not empty here (see assertions couple of
@@ -347,7 +347,7 @@ Status MergeHelper::MergeUntil(InternalIterator* iter,
       bool merge_success = false;
       std::string merge_result;
       {
-        StopWatchNano timer(clock_, stats_ != nullptr);
+        StopWatchNano timer(env_, stats_ != nullptr);
         PERF_TIMER_GUARD(merge_operator_time_nanos);
         merge_success = user_merge_operator_->PartialMergeMulti(
             orig_ikey.user_key,

db/merge_helper.h

@@ -25,7 +25,6 @@ class Iterator;
 class Logger;
 class MergeOperator;
 class Statistics;
-class SystemClock;
 
 class MergeHelper {
  public:
@@ -45,11 +44,13 @@ class MergeHelper {
   // Returns one of the following statuses:
   // - OK: Entries were successfully merged.
   // - Corruption: Merge operator reported unsuccessful merge.
-  static Status TimedFullMerge(
-      const MergeOperator* merge_operator, const Slice& key, const Slice* value,
-      const std::vector<Slice>& operands, std::string* result, Logger* logger,
-      Statistics* statistics, const std::shared_ptr<SystemClock>& clock,
-      Slice* result_operand = nullptr, bool update_num_ops_stats = false);
+  static Status TimedFullMerge(const MergeOperator* merge_operator,
+                               const Slice& key, const Slice* value,
+                               const std::vector<Slice>& operands,
+                               std::string* result, Logger* logger,
+                               Statistics* statistics, Env* env,
+                               Slice* result_operand = nullptr,
+                               bool update_num_ops_stats = false);
 
   // Merge entries until we hit
   //     - a corrupted key
@@ -139,7 +140,6 @@ class MergeHelper {
 
  private:
   Env* env_;
-  std::shared_ptr<SystemClock> clock_;
   const Comparator* user_comparator_;
   const MergeOperator* user_merge_operator_;
   const CompactionFilter* compaction_filter_;

db/perf_context_test.cc

@@ -3,8 +3,6 @@
 //  COPYING file in the root directory) and Apache 2.0 License
 //  (found in the LICENSE.Apache file in the root directory).
 //
-#include "rocksdb/perf_context.h"
-
 #include <algorithm>
 #include <iostream>
 #include <thread>
@@ -17,8 +15,8 @@
 #include "port/port.h"
 #include "rocksdb/db.h"
 #include "rocksdb/memtablerep.h"
+#include "rocksdb/perf_context.h"
 #include "rocksdb/slice_transform.h"
-#include "rocksdb/system_clock.h"
 #include "test_util/testharness.h"
 #include "util/stop_watch.h"
 #include "util/string_util.h"
@@ -93,7 +91,7 @@ TEST_F(PerfContextTest, SeekIntoDeletion) {
     std::string value;
 
     get_perf_context()->Reset();
-    StopWatchNano timer(SystemClock::Default());
+    StopWatchNano timer(Env::Default());
     timer.Start();
     auto status = db->Get(read_options, key, &value);
     auto elapsed_nanos = timer.ElapsedNanos();
@@ -112,7 +110,7 @@ TEST_F(PerfContextTest, SeekIntoDeletion) {
     std::unique_ptr<Iterator> iter(db->NewIterator(read_options));
 
     get_perf_context()->Reset();
-    StopWatchNano timer(SystemClock::Default(), true);
+    StopWatchNano timer(Env::Default(), true);
     iter->SeekToFirst();
     hist_seek_to_first.Add(get_perf_context()->user_key_comparison_count);
     auto elapsed_nanos = timer.ElapsedNanos();
@@ -133,7 +131,7 @@ TEST_F(PerfContextTest, SeekIntoDeletion) {
     std::string key = "k" + ToString(i);
 
     get_perf_context()->Reset();
-    StopWatchNano timer(SystemClock::Default(), true);
+    StopWatchNano timer(Env::Default(), true);
     iter->Seek(key);
     auto elapsed_nanos = timer.ElapsedNanos();
     hist_seek.Add(get_perf_context()->user_key_comparison_count);
@@ -147,7 +145,7 @@ TEST_F(PerfContextTest, SeekIntoDeletion) {
 
     get_perf_context()->Reset();
     ASSERT_TRUE(iter->Valid());
-    StopWatchNano timer2(SystemClock::Default(), true);
+    StopWatchNano timer2(Env::Default(), true);
     iter->Next();
     auto elapsed_nanos2 = timer2.ElapsedNanos();
     if (FLAGS_verbose) {
@@ -166,7 +164,7 @@ TEST_F(PerfContextTest, StopWatchNanoOverhead) {
   const int kTotalIterations = 1000000;
   std::vector<uint64_t> timings(kTotalIterations);
 
-  StopWatchNano timer(SystemClock::Default(), true);
+  StopWatchNano timer(Env::Default(), true);
   for (auto& timing : timings) {
     timing = timer.ElapsedNanos(true /* reset */);
   }
@@ -187,7 +185,7 @@ TEST_F(PerfContextTest, StopWatchOverhead) {
   uint64_t elapsed = 0;
   std::vector<uint64_t> timings(kTotalIterations);
 
-  StopWatch timer(SystemClock::Default(), nullptr, 0, &elapsed);
+  StopWatch timer(Env::Default(), nullptr, 0, &elapsed);
   for (auto& timing : timings) {
     timing = elapsed;
   }
@@ -541,7 +539,7 @@ TEST_F(PerfContextTest, SeekKeyComparison) {
   HistogramImpl hist_time_diff;
 
   SetPerfLevel(kEnableTime);
-  StopWatchNano timer(SystemClock::Default());
+  StopWatchNano timer(Env::Default());
   for (const int i : keys) {
     std::string key = "k" + ToString(i);
     std::string value = "v" + ToString(i);
@@ -594,25 +592,25 @@ TEST_F(PerfContextTest, DBMutexLockCounter) {
   for (PerfLevel perf_level_test :
        {PerfLevel::kEnableTimeExceptForMutex, PerfLevel::kEnableTime}) {
     for (int c = 0; c < 2; ++c) {
-      InstrumentedMutex mutex(nullptr, SystemClock::Default(), stats_code[c]);
+    InstrumentedMutex mutex(nullptr, Env::Default(), stats_code[c]);
+    mutex.Lock();
+    ROCKSDB_NAMESPACE::port::Thread child_thread([&] {
+      SetPerfLevel(perf_level_test);
+      get_perf_context()->Reset();
+      ASSERT_EQ(get_perf_context()->db_mutex_lock_nanos, 0);
       mutex.Lock();
-      ROCKSDB_NAMESPACE::port::Thread child_thread([&] {
-        SetPerfLevel(perf_level_test);
-        get_perf_context()->Reset();
-        ASSERT_EQ(get_perf_context()->db_mutex_lock_nanos, 0);
-        mutex.Lock();
-        mutex.Unlock();
-        if (perf_level_test == PerfLevel::kEnableTimeExceptForMutex ||
-            stats_code[c] != DB_MUTEX_WAIT_MICROS) {
-          ASSERT_EQ(get_perf_context()->db_mutex_lock_nanos, 0);
-        } else {
-          // increment the counter only when it's a DB Mutex
-          ASSERT_GT(get_perf_context()->db_mutex_lock_nanos, 0);
-        }
-      });
-      SystemClock::Default()->SleepForMicroseconds(100);
       mutex.Unlock();
-      child_thread.join();
+      if (perf_level_test == PerfLevel::kEnableTimeExceptForMutex ||
+          stats_code[c] != DB_MUTEX_WAIT_MICROS) {
+        ASSERT_EQ(get_perf_context()->db_mutex_lock_nanos, 0);
+      } else {
+        // increment the counter only when it's a DB Mutex
+        ASSERT_GT(get_perf_context()->db_mutex_lock_nanos, 0);
+      }
+    });
+    Env::Default()->SleepForMicroseconds(100);
+    mutex.Unlock();
+    child_thread.join();
   }
   }
 }
@@ -621,7 +619,7 @@ TEST_F(PerfContextTest, FalseDBMutexWait) {
   SetPerfLevel(kEnableTime);
   int stats_code[] = {0, static_cast<int>(DB_MUTEX_WAIT_MICROS)};
   for (int c = 0; c < 2; ++c) {
-    InstrumentedMutex mutex(nullptr, SystemClock::Default(), stats_code[c]);
+    InstrumentedMutex mutex(nullptr, Env::Default(), stats_code[c]);
     InstrumentedCondVar lock(&mutex);
     get_perf_context()->Reset();
     mutex.Lock();
@@ -826,8 +824,8 @@ TEST_F(PerfContextTest, PerfContextByLevelGetSet) {
 }
 
 TEST_F(PerfContextTest, CPUTimer) {
-  if (SystemClock::Default()->CPUNanos() == 0) {
-    ROCKSDB_GTEST_SKIP("Target without CPUNanos support");
+  if (Env::Default()->NowCPUNanos() == 0) {
+    ROCKSDB_GTEST_SKIP("Target without NowCPUNanos support");
     return;
   }
 

db/periodic_work_scheduler.cc

@@ -6,14 +6,12 @@
 #include "db/periodic_work_scheduler.h"
 
 #include "db/db_impl/db_impl.h"
-#include "rocksdb/system_clock.h"
 
 #ifndef ROCKSDB_LITE
 namespace ROCKSDB_NAMESPACE {
 
-PeriodicWorkScheduler::PeriodicWorkScheduler(
-    const std::shared_ptr<SystemClock>& clock) {
-  timer = std::unique_ptr<Timer>(new Timer(clock));
+PeriodicWorkScheduler::PeriodicWorkScheduler(Env* env) : timer_mu_(env) {
+  timer = std::unique_ptr<Timer>(new Timer(env));
 }
 
 void PeriodicWorkScheduler::Register(DBImpl* dbi,
@@ -54,10 +52,10 @@ void PeriodicWorkScheduler::Unregister(DBImpl* dbi) {
 }
 
 PeriodicWorkScheduler* PeriodicWorkScheduler::Default() {
-  // Always use the default SystemClock for the scheduler, as we only use the
-  // NowMicros which is the same for all clocks. The Env could only be
-  // overridden in test.
-  static PeriodicWorkScheduler scheduler(SystemClock::Default());
+  // Always use the default Env for the scheduler, as we only use the NowMicros
+  // which is the same for all env.
+  // The Env could only be overridden in test.
+  static PeriodicWorkScheduler scheduler(Env::Default());
   return &scheduler;
 }
 
@@ -71,13 +69,12 @@ std::string PeriodicWorkScheduler::GetTaskName(DBImpl* dbi,
 
 #ifndef NDEBUG
 
-// Get the static scheduler. For a new SystemClock, it needs to re-create the
-// internal timer, so only re-create it when there's no running task. Otherwise,
-// return the existing scheduler. Which means if the unittest needs to update
-// MockClock, Close all db instances and then re-open them.
-PeriodicWorkTestScheduler* PeriodicWorkTestScheduler::Default(
-    const std::shared_ptr<SystemClock>& clock) {
-  static PeriodicWorkTestScheduler scheduler(clock);
+// Get the static scheduler. For a new env, it needs to re-create the internal
+// timer, so only re-create it when there's no running task. Otherwise, return
+// the existing scheduler. Which means if the unittest needs to update MockEnv,
+// Close all db instances and then re-open them.
+PeriodicWorkTestScheduler* PeriodicWorkTestScheduler::Default(Env* env) {
+  static PeriodicWorkTestScheduler scheduler(env);
   static port::Mutex mutex;
   {
     MutexLock l(&mutex);
@@ -87,7 +84,7 @@ PeriodicWorkTestScheduler* PeriodicWorkTestScheduler::Default(
         MutexLock timer_mu_guard(&scheduler.timer_mu_);
         scheduler.timer->Shutdown();
       }
-      scheduler.timer.reset(new Timer(clock));
+      scheduler.timer.reset(new Timer(env));
     }
   }
   return &scheduler;
@@ -107,9 +104,8 @@ size_t PeriodicWorkTestScheduler::TEST_GetValidTaskNum() const {
   return 0;
 }
 
-PeriodicWorkTestScheduler::PeriodicWorkTestScheduler(
-    const std::shared_ptr<SystemClock>& clock)
-    : PeriodicWorkScheduler(clock) {}
+PeriodicWorkTestScheduler::PeriodicWorkTestScheduler(Env* env)
+    : PeriodicWorkScheduler(env) {}
 
 #endif  // !NDEBUG
 }  // namespace ROCKSDB_NAMESPACE

db/periodic_work_scheduler.h

@@ -11,7 +11,6 @@
 #include "util/timer.h"
 
 namespace ROCKSDB_NAMESPACE {
-class SystemClock;
 
 // PeriodicWorkScheduler is a singleton object, which is scheduling/running
 // DumpStats(), PersistStats(), and FlushInfoLog() for all DB instances. All DB
@@ -50,26 +49,25 @@ class PeriodicWorkScheduler {
   //     the `Timer::Cancel()`s and `Timer::Shutdown()` run atomically.
   port::Mutex timer_mu_;
 
-  explicit PeriodicWorkScheduler(const std::shared_ptr<SystemClock>& clock);
+  explicit PeriodicWorkScheduler(Env* env);
 
  private:
   std::string GetTaskName(DBImpl* dbi, const std::string& func_name);
 };
 
 #ifndef NDEBUG
-// PeriodicWorkTestScheduler is for unittest, which can specify the SystemClock
-// It also contains functions for unittest.
+// PeriodicWorkTestScheduler is for unittest, which can specify the Env like
+// SafeMockTimeEnv. It also contains functions for unittest.
 class PeriodicWorkTestScheduler : public PeriodicWorkScheduler {
  public:
-  static PeriodicWorkTestScheduler* Default(
-      const std::shared_ptr<SystemClock>& clock);
+  static PeriodicWorkTestScheduler* Default(Env* env);
 
   void TEST_WaitForRun(std::function<void()> callback) const;
 
   size_t TEST_GetValidTaskNum() const;
 
  private:
-  explicit PeriodicWorkTestScheduler(const std::shared_ptr<SystemClock>& clock);
+  explicit PeriodicWorkTestScheduler(Env* env);
 };
 #endif  // !NDEBUG
 

db/periodic_work_scheduler_test.cc

@@ -6,8 +6,6 @@
 #include "db/periodic_work_scheduler.h"
 
 #include "db/db_test_util.h"
-#include "env/composite_env_wrapper.h"
-#include "test_util/mock_time_env.h"
 
 namespace ROCKSDB_NAMESPACE {
 
@@ -16,22 +14,20 @@ class PeriodicWorkSchedulerTest : public DBTestBase {
  public:
   PeriodicWorkSchedulerTest()
       : DBTestBase("/periodic_work_scheduler_test", /*env_do_fsync=*/true) {
-    mock_clock_ = std::make_shared<MockSystemClock>(env_->GetSystemClock());
-    mock_env_.reset(new CompositeEnvWrapper(env_, mock_clock_));
+    mock_env_.reset(new MockTimeEnv(env_));
   }
 
  protected:
-  std::unique_ptr<Env> mock_env_;
-  std::shared_ptr<MockSystemClock> mock_clock_;
+  std::unique_ptr<MockTimeEnv> mock_env_;
 
   void SetUp() override {
-    mock_clock_->InstallTimedWaitFixCallback();
+    mock_env_->InstallTimedWaitFixCallback();
     SyncPoint::GetInstance()->SetCallBack(
         "DBImpl::StartPeriodicWorkScheduler:Init", [&](void* arg) {
           auto* periodic_work_scheduler_ptr =
               reinterpret_cast<PeriodicWorkScheduler**>(arg);
           *periodic_work_scheduler_ptr =
-              PeriodicWorkTestScheduler::Default(mock_clock_);
+              PeriodicWorkTestScheduler::Default(mock_env_.get());
         });
   }
 };
@@ -67,7 +63,7 @@ TEST_F(PeriodicWorkSchedulerTest, Basic) {
 
   ASSERT_GT(kPeriodSec, 1u);
   dbfull()->TEST_WaitForStatsDumpRun([&] {
-    mock_clock_->MockSleepForSeconds(static_cast<int>(kPeriodSec) - 1);
+    mock_env_->MockSleepForSeconds(static_cast<int>(kPeriodSec) - 1);
   });
 
   auto scheduler = dbfull()->TEST_GetPeriodicWorkScheduler();
@@ -79,14 +75,14 @@ TEST_F(PeriodicWorkSchedulerTest, Basic) {
   ASSERT_EQ(1, flush_info_log_counter);
 
   dbfull()->TEST_WaitForStatsDumpRun(
-      [&] { mock_clock_->MockSleepForSeconds(static_cast<int>(kPeriodSec)); });
+      [&] { mock_env_->MockSleepForSeconds(static_cast<int>(kPeriodSec)); });
 
   ASSERT_EQ(2, dump_st_counter);
   ASSERT_EQ(2, pst_st_counter);
   ASSERT_EQ(2, flush_info_log_counter);
 
   dbfull()->TEST_WaitForStatsDumpRun(
-      [&] { mock_clock_->MockSleepForSeconds(static_cast<int>(kPeriodSec)); });
+      [&] { mock_env_->MockSleepForSeconds(static_cast<int>(kPeriodSec)); });
 
   ASSERT_EQ(3, dump_st_counter);
   ASSERT_EQ(3, pst_st_counter);
@@ -100,7 +96,7 @@ TEST_F(PeriodicWorkSchedulerTest, Basic) {
 
   // Info log flush should still run.
   dbfull()->TEST_WaitForStatsDumpRun(
-      [&] { mock_clock_->MockSleepForSeconds(static_cast<int>(kPeriodSec)); });
+      [&] { mock_env_->MockSleepForSeconds(static_cast<int>(kPeriodSec)); });
   ASSERT_EQ(3, dump_st_counter);
   ASSERT_EQ(3, pst_st_counter);
   ASSERT_EQ(4, flush_info_log_counter);
@@ -118,7 +114,7 @@ TEST_F(PeriodicWorkSchedulerTest, Basic) {
   ASSERT_EQ(2, scheduler->TEST_GetValidTaskNum());
 
   dbfull()->TEST_WaitForStatsDumpRun(
-      [&] { mock_clock_->MockSleepForSeconds(static_cast<int>(kPeriodSec)); });
+      [&] { mock_env_->MockSleepForSeconds(static_cast<int>(kPeriodSec)); });
   ASSERT_EQ(4, dump_st_counter);
   ASSERT_EQ(3, pst_st_counter);
   ASSERT_EQ(5, flush_info_log_counter);
@@ -158,19 +154,19 @@ TEST_F(PeriodicWorkSchedulerTest, MultiInstances) {
 
   int expected_run = kInstanceNum;
   dbi->TEST_WaitForStatsDumpRun(
-      [&] { mock_clock_->MockSleepForSeconds(kPeriodSec - 1); });
+      [&] { mock_env_->MockSleepForSeconds(kPeriodSec - 1); });
   ASSERT_EQ(expected_run, dump_st_counter);
   ASSERT_EQ(expected_run, pst_st_counter);
 
   expected_run += kInstanceNum;
   dbi->TEST_WaitForStatsDumpRun(
-      [&] { mock_clock_->MockSleepForSeconds(kPeriodSec); });
+      [&] { mock_env_->MockSleepForSeconds(kPeriodSec); });
   ASSERT_EQ(expected_run, dump_st_counter);
   ASSERT_EQ(expected_run, pst_st_counter);
 
   expected_run += kInstanceNum;
   dbi->TEST_WaitForStatsDumpRun(
-      [&] { mock_clock_->MockSleepForSeconds(kPeriodSec); });
+      [&] { mock_env_->MockSleepForSeconds(kPeriodSec); });
   ASSERT_EQ(expected_run, dump_st_counter);
   ASSERT_EQ(expected_run, pst_st_counter);
 
@@ -182,9 +178,9 @@ TEST_F(PeriodicWorkSchedulerTest, MultiInstances) {
   expected_run += (kInstanceNum - half) * 2;
 
   dbi->TEST_WaitForStatsDumpRun(
-      [&] { mock_clock_->MockSleepForSeconds(kPeriodSec); });
+      [&] { mock_env_->MockSleepForSeconds(kPeriodSec); });
   dbi->TEST_WaitForStatsDumpRun(
-      [&] { mock_clock_->MockSleepForSeconds(kPeriodSec); });
+      [&] { mock_env_->MockSleepForSeconds(kPeriodSec); });
   ASSERT_EQ(expected_run, dump_st_counter);
   ASSERT_EQ(expected_run, pst_st_counter);
 
@@ -206,8 +202,7 @@ TEST_F(PeriodicWorkSchedulerTest, MultiEnv) {
 
   Reopen(options1);
 
-  std::unique_ptr<Env> mock_env2(
-      new CompositeEnvWrapper(Env::Default(), mock_clock_));
+  std::unique_ptr<MockTimeEnv> mock_env2(new MockTimeEnv(Env::Default()));
   Options options2;
   options2.stats_dump_period_sec = kDumpPeriodSec;
   options2.stats_persist_period_sec = kPersistPeriodSec;

db/prefix_test.cc

@@ -25,7 +25,6 @@ int main() {
 #include "rocksdb/memtablerep.h"
 #include "rocksdb/perf_context.h"
 #include "rocksdb/slice_transform.h"
-#include "rocksdb/system_clock.h"
 #include "rocksdb/table.h"
 #include "test_util/testharness.h"
 #include "util/cast_util.h"
@@ -609,7 +608,7 @@ TEST_F(PrefixTest, DynamicPrefixIterator) {
         std::string value(FLAGS_value_size, 0);
 
         get_perf_context()->Reset();
-        StopWatchNano timer(SystemClock::Default(), true);
+        StopWatchNano timer(Env::Default(), true);
         ASSERT_OK(db->Put(write_options, key, value));
         hist_put_time.Add(timer.ElapsedNanos());
         hist_put_comparison.Add(get_perf_context()->user_key_comparison_count);
@@ -632,7 +631,7 @@ TEST_F(PrefixTest, DynamicPrefixIterator) {
       std::string value = "v" + ToString(0);
 
       get_perf_context()->Reset();
-      StopWatchNano timer(SystemClock::Default(), true);
+      StopWatchNano timer(Env::Default(), true);
       auto key_prefix = options.prefix_extractor->Transform(key);
       uint64_t total_keys = 0;
       for (iter->Seek(key);
@@ -666,7 +665,7 @@ TEST_F(PrefixTest, DynamicPrefixIterator) {
       Slice key = TestKeyToSlice(s, test_key);
 
       get_perf_context()->Reset();
-      StopWatchNano timer(SystemClock::Default(), true);
+      StopWatchNano timer(Env::Default(), true);
       iter->Seek(key);
       hist_no_seek_time.Add(timer.ElapsedNanos());
       hist_no_seek_comparison.Add(get_perf_context()->user_key_comparison_count);

db/range_del_aggregator_bench.cc

@@ -11,8 +11,8 @@ int main() {
 }
 #else
 
-#include <iomanip>
 #include <iostream>
+#include <iomanip>
 #include <memory>
 #include <random>
 #include <set>
@@ -22,13 +22,14 @@ int main() {
 #include "db/range_del_aggregator.h"
 #include "db/range_tombstone_fragmenter.h"
 #include "rocksdb/comparator.h"
-#include "rocksdb/system_clock.h"
+#include "rocksdb/env.h"
 #include "test_util/testutil.h"
 #include "util/coding.h"
-#include "util/gflags_compat.h"
 #include "util/random.h"
 #include "util/stop_watch.h"
 
+#include "util/gflags_compat.h"
+
 using GFLAGS_NAMESPACE::ParseCommandLineFlags;
 
 DEFINE_int32(num_range_tombstones, 1000, "number of range tombstones created");
@@ -219,7 +220,7 @@ int main(int argc, char** argv) {
                   ROCKSDB_NAMESPACE::kMaxSequenceNumber));
 
       ROCKSDB_NAMESPACE::StopWatchNano stop_watch_add_tombstones(
-          ROCKSDB_NAMESPACE::SystemClock::Default(), true /* auto_start */);
+          ROCKSDB_NAMESPACE::Env::Default(), true /* auto_start */);
       range_del_agg.AddTombstones(std::move(fragmented_range_del_iter));
       stats.time_add_tombstones += stop_watch_add_tombstones.ElapsedNanos();
     }
@@ -236,7 +237,7 @@ int main(int argc, char** argv) {
       parsed_key.user_key = key_string;
 
       ROCKSDB_NAMESPACE::StopWatchNano stop_watch_should_delete(
-          ROCKSDB_NAMESPACE::SystemClock::Default(), true /* auto_start */);
+          ROCKSDB_NAMESPACE::Env::Default(), true /* auto_start */);
       range_del_agg.ShouldDelete(parsed_key, mode);
       uint64_t call_time = stop_watch_should_delete.ElapsedNanos();
 

db/repair.cc

@@ -71,6 +71,7 @@
 #include "db/table_cache.h"
 #include "db/version_edit.h"
 #include "db/write_batch_internal.h"
+#include "env/composite_env_wrapper.h"
 #include "file/filename.h"
 #include "file/writable_file_writer.h"
 #include "options/cf_options.h"
@@ -357,14 +358,14 @@ class Repairer {
 
     // Open the log file
     std::string logname = LogFileName(db_options_.wal_dir, log);
-    const auto& fs = env_->GetFileSystem();
-    std::unique_ptr<SequentialFileReader> lfile_reader;
-    Status status = SequentialFileReader::Create(
-        fs, logname, fs->OptimizeForLogRead(env_options_), &lfile_reader,
-        nullptr);
+    std::unique_ptr<SequentialFile> lfile;
+    Status status = env_->NewSequentialFile(
+        logname, &lfile, env_->OptimizeForLogRead(env_options_));
     if (!status.ok()) {
       return status;
     }
+    std::unique_ptr<SequentialFileReader> lfile_reader(new SequentialFileReader(
+        NewLegacySequentialFileWrapper(lfile), logname));
 
     // Create the log reader.
     LogReporter reporter;

db/table_cache.cc

@@ -106,15 +106,14 @@ Status TableCache::GetTableReader(
       TableFileName(ioptions_.cf_paths, fd.GetNumber(), fd.GetPathId());
   std::unique_ptr<FSRandomAccessFile> file;
   FileOptions fopts = file_options;
-  const auto& clock = ioptions_.env->GetSystemClock();
-  Status s = PrepareIOFromReadOptions(ro, clock, fopts.io_options);
+  Status s = PrepareIOFromReadOptions(ro, ioptions_.env, fopts.io_options);
   if (s.ok()) {
     s = ioptions_.fs->NewRandomAccessFile(fname, fopts, &file, nullptr);
   }
   RecordTick(ioptions_.statistics, NO_FILE_OPENS);
   if (s.IsPathNotFound()) {
     fname = Rocks2LevelTableFileName(fname);
-    s = PrepareIOFromReadOptions(ro, clock, fopts.io_options);
+    s = PrepareIOFromReadOptions(ro, ioptions_.env, fopts.io_options);
     if (s.ok()) {
       s = ioptions_.fs->NewRandomAccessFile(fname, file_options, &file,
                                             nullptr);
@@ -126,10 +125,10 @@ Status TableCache::GetTableReader(
     if (!sequential_mode && ioptions_.advise_random_on_open) {
       file->Hint(FSRandomAccessFile::kRandom);
     }
-    StopWatch sw(clock, ioptions_.statistics, TABLE_OPEN_IO_MICROS);
+    StopWatch sw(ioptions_.env, ioptions_.statistics, TABLE_OPEN_IO_MICROS);
     std::unique_ptr<RandomAccessFileReader> file_reader(
         new RandomAccessFileReader(
-            std::move(file), fname, clock, io_tracer_,
+            std::move(file), fname, ioptions_.env, io_tracer_,
             record_read_stats ? ioptions_.statistics : nullptr, SST_READ_MICROS,
             file_read_hist, ioptions_.rate_limiter, ioptions_.listeners));
     s = ioptions_.table_factory->NewTableReader(
@@ -162,8 +161,7 @@ Status TableCache::FindTable(const ReadOptions& ro,
                              HistogramImpl* file_read_hist, bool skip_filters,
                              int level, bool prefetch_index_and_filter_in_cache,
                              size_t max_file_size_for_l0_meta_pin) {
-  PERF_TIMER_GUARD_WITH_CLOCK(find_table_nanos,
-                              ioptions_.env->GetSystemClock());
+  PERF_TIMER_GUARD_WITH_ENV(find_table_nanos, ioptions_.env);
   uint64_t number = fd.GetNumber();
   Slice key = GetSliceForFileNumber(&number);
   *handle = cache_->Lookup(key);

db/version_set.cc

@@ -1762,7 +1762,6 @@ Version::Version(ColumnFamilyData* column_family_data, VersionSet* vset,
                  const std::shared_ptr<IOTracer>& io_tracer,
                  uint64_t version_number)
     : env_(vset->env_),
-      clock_(env_->GetSystemClock()),
       cfd_(column_family_data),
       info_log_((cfd_ == nullptr) ? nullptr : cfd_->ioptions()->info_log),
       db_statistics_((cfd_ == nullptr) ? nullptr
@@ -1881,7 +1880,7 @@ void Version::Get(const ReadOptions& read_options, const LookupKey& k,
       user_comparator(), merge_operator_, info_log_, db_statistics_,
       status->ok() ? GetContext::kNotFound : GetContext::kMerge, user_key,
       do_merge ? value : nullptr, do_merge ? timestamp : nullptr, value_found,
-      merge_context, do_merge, max_covering_tombstone_seq, clock_, seq,
+      merge_context, do_merge, max_covering_tombstone_seq, this->env_, seq,
       merge_operator_ ? &pinned_iters_mgr : nullptr, callback, is_blob_to_use,
       tracing_get_id);
 
@@ -1909,7 +1908,7 @@ void Version::Get(const ReadOptions& read_options, const LookupKey& k,
     bool timer_enabled =
         GetPerfLevel() >= PerfLevel::kEnableTimeExceptForMutex &&
         get_perf_context()->per_level_perf_context_enabled;
-    StopWatchNano timer(clock_, timer_enabled /* auto_start */);
+    StopWatchNano timer(env_, timer_enabled /* auto_start */);
     *status = table_cache_->Get(
         read_options, *internal_comparator(), *f->file_metadata, ikey,
         &get_context, mutable_cf_options_.prefix_extractor.get(),
@@ -1998,7 +1997,7 @@ void Version::Get(const ReadOptions& read_options, const LookupKey& k,
     std::string* str_value = value != nullptr ? value->GetSelf() : nullptr;
     *status = MergeHelper::TimedFullMerge(
         merge_operator_, user_key, nullptr, merge_context->GetOperands(),
-        str_value, info_log_, db_statistics_, clock_,
+        str_value, info_log_, db_statistics_, env_,
         nullptr /* result_operand */, true);
     if (LIKELY(value != nullptr)) {
       value->PinSelf();
@@ -2035,9 +2034,9 @@ void Version::MultiGet(const ReadOptions& read_options, MultiGetRange* range,
         user_comparator(), merge_operator_, info_log_, db_statistics_,
         iter->s->ok() ? GetContext::kNotFound : GetContext::kMerge,
         iter->ukey_with_ts, iter->value, iter->timestamp, nullptr,
-        &(iter->merge_context), true, &iter->max_covering_tombstone_seq, clock_,
-        nullptr, merge_operator_ ? &pinned_iters_mgr : nullptr, callback,
-        &iter->is_blob_index, tracing_mget_id);
+        &(iter->merge_context), true, &iter->max_covering_tombstone_seq,
+        this->env_, nullptr, merge_operator_ ? &pinned_iters_mgr : nullptr,
+        callback, &iter->is_blob_index, tracing_mget_id);
     // MergeInProgress status, if set, has been transferred to the get_context
     // state, so we set status to ok here. From now on, the iter status will
     // be used for IO errors, and get_context state will be used for any
@@ -2067,7 +2066,7 @@ void Version::MultiGet(const ReadOptions& read_options, MultiGetRange* range,
     bool timer_enabled =
         GetPerfLevel() >= PerfLevel::kEnableTimeExceptForMutex &&
         get_perf_context()->per_level_perf_context_enabled;
-    StopWatchNano timer(clock_, timer_enabled /* auto_start */);
+    StopWatchNano timer(env_, timer_enabled /* auto_start */);
     s = table_cache_->MultiGet(
         read_options, *internal_comparator(), *f->file_metadata, &file_range,
         mutable_cf_options_.prefix_extractor.get(),
@@ -2230,7 +2229,7 @@ void Version::MultiGet(const ReadOptions& read_options, MultiGetRange* range,
           iter->value != nullptr ? iter->value->GetSelf() : nullptr;
       *status = MergeHelper::TimedFullMerge(
           merge_operator_, user_key, nullptr, iter->merge_context.GetOperands(),
-          str_value, info_log_, db_statistics_, clock_,
+          str_value, info_log_, db_statistics_, env_,
           nullptr /* result_operand */, true);
       if (LIKELY(iter->value != nullptr)) {
         iter->value->PinSelf();
@@ -3784,7 +3783,6 @@ VersionSet::VersionSet(const std::string& dbname,
       table_cache_(table_cache),
       env_(_db_options->env),
       fs_(_db_options->fs, io_tracer),
-      clock_(env_->GetSystemClock()),
       dbname_(dbname),
       db_options_(_db_options),
       next_file_number_(2),
@@ -4122,7 +4120,7 @@ Status VersionSet::ProcessManifestWrites(
             db_options_->manifest_preallocation_size);
         FileTypeSet tmp_set = db_options_->checksum_handoff_file_types;
         std::unique_ptr<WritableFileWriter> file_writer(new WritableFileWriter(
-            std::move(descriptor_file), descriptor_fname, opt_file_opts, clock_,
+            std::move(descriptor_file), descriptor_fname, opt_file_opts, env_,
             io_tracer_, nullptr, db_options_->listeners, nullptr,
             tmp_set.Contains(FileType::kDescriptorFile)));
         descriptor_log_.reset(
@@ -4171,7 +4169,7 @@ Status VersionSet::ProcessManifestWrites(
         }
       }
       if (s.ok()) {
-        io_s = SyncManifest(clock_, db_options_, descriptor_log_->file());
+        io_s = SyncManifest(env_, db_options_, descriptor_log_->file());
         TEST_SYNC_POINT_CALLBACK(
             "VersionSet::ProcessManifestWrites:AfterSyncManifest", &io_s);
       }
@@ -6306,7 +6304,7 @@ Status ReactiveVersionSet::MaybeSwitchManifest(
             "ReactiveVersionSet::MaybeSwitchManifest:"
             "AfterGetCurrentManifestPath:1");
         s = fs_->NewSequentialFile(manifest_path,
-                                   fs_->OptimizeForManifestRead(file_options_),
+                                   env_->OptimizeForManifestRead(file_options_),
                                    &manifest_file, nullptr);
       } else {
         // No need to switch manifest.

db/version_set.h

@@ -71,7 +71,6 @@ class WriteBufferManager;
 class MergeContext;
 class ColumnFamilySet;
 class MergeIteratorBuilder;
-class SystemClock;
 
 // VersionEdit is always supposed to be valid and it is used to point at
 // entries in Manifest. Ideally it should not be used as a container to
@@ -780,8 +779,6 @@ class Version {
 
  private:
   Env* env_;
-  std::shared_ptr<SystemClock> clock_;
-
   friend class ReactiveVersionSet;
   friend class VersionSet;
   friend class VersionEditHandler;
@@ -1349,7 +1346,6 @@ class VersionSet {
   Cache* table_cache_;
   Env* const env_;
   FileSystemPtr const fs_;
-  const std::shared_ptr<SystemClock> clock_;
   const std::string dbname_;
   std::string db_id_;
   const ImmutableDBOptions* const db_options_;

db/version_set_test.cc

@@ -11,7 +11,6 @@
 
 #include "db/db_impl/db_impl.h"
 #include "db/log_writer.h"
-#include "rocksdb/file_system.h"
 #include "table/block_based/block_based_table_factory.h"
 #include "table/mock_table.h"
 #include "test_util/testharness.h"
@@ -784,13 +783,13 @@ class VersionSetTestBase {
     }
     *last_seqno = last_seq;
     num_initial_edits_ = static_cast<int>(new_cfs.size() + 1);
-    std::unique_ptr<WritableFileWriter> file_writer;
     const std::string manifest = DescriptorFileName(dbname_, 1);
-    const auto& fs = env_->GetFileSystem();
-    Status s = WritableFileWriter::Create(
-        fs, manifest, fs->OptimizeForManifestWrite(env_options_), &file_writer,
-        nullptr);
+    std::unique_ptr<WritableFile> file;
+    Status s = env_->NewWritableFile(
+        manifest, &file, env_->OptimizeForManifestWrite(env_options_));
     ASSERT_OK(s);
+    std::unique_ptr<WritableFileWriter> file_writer(new WritableFileWriter(
+        NewLegacyWritableFileWrapper(std::move(file)), manifest, env_options_));
     {
       log_writer->reset(new log::Writer(std::move(file_writer), 0, false));
       std::string record;
@@ -2313,13 +2312,14 @@ class EmptyDefaultCfNewManifest : public VersionSetTestBase,
     assert(log_writer != nullptr);
     VersionEdit new_db;
     new_db.SetLogNumber(0);
+    std::unique_ptr<WritableFile> file;
     const std::string manifest_path = DescriptorFileName(dbname_, 1);
-    const auto& fs = env_->GetFileSystem();
-    std::unique_ptr<WritableFileWriter> file_writer;
-    Status s = WritableFileWriter::Create(
-        fs, manifest_path, fs->OptimizeForManifestWrite(env_options_),
-        &file_writer, nullptr);
+    Status s = env_->NewWritableFile(
+        manifest_path, &file, env_->OptimizeForManifestWrite(env_options_));
     ASSERT_OK(s);
+    std::unique_ptr<WritableFileWriter> file_writer(
+        new WritableFileWriter(NewLegacyWritableFileWrapper(std::move(file)),
+                               manifest_path, env_options_));
     log_writer->reset(new log::Writer(std::move(file_writer), 0, true));
     std::string record;
     ASSERT_TRUE(new_db.EncodeTo(&record));
@@ -2387,12 +2387,13 @@ class VersionSetTestEmptyDb
       new_db.SetDBId(db_id);
     }
     const std::string manifest_path = DescriptorFileName(dbname_, 1);
-    const auto& fs = env_->GetFileSystem();
-    std::unique_ptr<WritableFileWriter> file_writer;
-    Status s = WritableFileWriter::Create(
-        fs, manifest_path, fs->OptimizeForManifestWrite(env_options_),
-        &file_writer, nullptr);
+    std::unique_ptr<WritableFile> file;
+    Status s = env_->NewWritableFile(
+        manifest_path, &file, env_->OptimizeForManifestWrite(env_options_));
     ASSERT_OK(s);
+    std::unique_ptr<WritableFileWriter> file_writer(
+        new WritableFileWriter(NewLegacyWritableFileWrapper(std::move(file)),
+                               manifest_path, env_options_));
     {
       log_writer->reset(new log::Writer(std::move(file_writer), 0, false));
       std::string record;
@@ -2696,12 +2697,12 @@ class VersionSetTestMissingFiles : public VersionSetTestBase,
     assert(last_seqno != nullptr);
     assert(log_writer != nullptr);
     const std::string manifest = DescriptorFileName(dbname_, 1);
-    const auto& fs = env_->GetFileSystem();
-    std::unique_ptr<WritableFileWriter> file_writer;
-    Status s = WritableFileWriter::Create(
-        fs, manifest, fs->OptimizeForManifestWrite(env_options_), &file_writer,
-        nullptr);
+    std::unique_ptr<WritableFile> file;
+    Status s = env_->NewWritableFile(
+        manifest, &file, env_->OptimizeForManifestWrite(env_options_));
     ASSERT_OK(s);
+    std::unique_ptr<WritableFileWriter> file_writer(new WritableFileWriter(
+        NewLegacyWritableFileWrapper(std::move(file)), manifest, env_options_));
     log_writer->reset(new log::Writer(std::move(file_writer), 0, false));
     VersionEdit new_db;
     if (db_options_.write_dbid_to_manifest) {
@@ -2785,8 +2786,8 @@ class VersionSetTestMissingFiles : public VersionSetTestBase,
       std::unique_ptr<FSWritableFile> file;
       Status s = fs_->NewWritableFile(fname, FileOptions(), &file, nullptr);
       ASSERT_OK(s);
-      std::unique_ptr<WritableFileWriter> fwriter(new WritableFileWriter(
-          std::move(file), fname, FileOptions(), env_->GetSystemClock()));
+      std::unique_ptr<WritableFileWriter> fwriter(
+          new WritableFileWriter(std::move(file), fname, FileOptions(), env_));
       std::vector<std::unique_ptr<IntTblPropCollectorFactory>>
           int_tbl_prop_collector_factories;
 

db/wal_manager_test.cc

@@ -5,21 +5,20 @@
 
 #ifndef ROCKSDB_LITE
 
-#include "db/wal_manager.h"
-
 #include <map>
 #include <string>
 
+#include "rocksdb/cache.h"
+#include "rocksdb/write_batch.h"
+#include "rocksdb/write_buffer_manager.h"
+
 #include "db/column_family.h"
 #include "db/db_impl/db_impl.h"
 #include "db/log_writer.h"
 #include "db/version_set.h"
+#include "db/wal_manager.h"
 #include "env/mock_env.h"
 #include "file/writable_file_writer.h"
-#include "rocksdb/cache.h"
-#include "rocksdb/file_system.h"
-#include "rocksdb/write_batch.h"
-#include "rocksdb/write_buffer_manager.h"
 #include "table/mock_table.h"
 #include "test_util/testharness.h"
 #include "test_util/testutil.h"
@@ -82,10 +81,10 @@ class WalManagerTest : public testing::Test {
   void RollTheLog(bool /*archived*/) {
     current_log_number_++;
     std::string fname = ArchivedLogFileName(dbname_, current_log_number_);
-    const auto& fs = env_->GetFileSystem();
-    std::unique_ptr<WritableFileWriter> file_writer;
-    ASSERT_OK(WritableFileWriter::Create(fs, fname, env_options_, &file_writer,
-                                         nullptr));
+    std::unique_ptr<WritableFile> file;
+    ASSERT_OK(env_->NewWritableFile(fname, &file, env_options_));
+    std::unique_ptr<WritableFileWriter> file_writer(new WritableFileWriter(
+        NewLegacyWritableFileWrapper(std::move(file)), fname, env_options_));
     current_log_writer_.reset(new log::Writer(std::move(file_writer), 0, false));
   }
 
@@ -124,9 +123,8 @@ class WalManagerTest : public testing::Test {
 TEST_F(WalManagerTest, ReadFirstRecordCache) {
   Init();
   std::string path = dbname_ + "/000001.log";
-  std::unique_ptr<FSWritableFile> file;
-  ASSERT_OK(env_->GetFileSystem()->NewWritableFile(path, FileOptions(), &file,
-                                                   nullptr));
+  std::unique_ptr<WritableFile> file;
+  ASSERT_OK(env_->NewWritableFile(path, &file, EnvOptions()));
 
   SequenceNumber s;
   ASSERT_OK(wal_manager_->TEST_ReadFirstLine(path, 1 /* number */, &s));
@@ -136,8 +134,8 @@ TEST_F(WalManagerTest, ReadFirstRecordCache) {
       wal_manager_->TEST_ReadFirstRecord(kAliveLogFile, 1 /* number */, &s));
   ASSERT_EQ(s, 0U);
 
-  std::unique_ptr<WritableFileWriter> file_writer(
-      new WritableFileWriter(std::move(file), path, FileOptions()));
+  std::unique_ptr<WritableFileWriter> file_writer(new WritableFileWriter(
+      NewLegacyWritableFileWrapper(std::move(file)), path, EnvOptions()));
   log::Writer writer(std::move(file_writer), 1,
                      db_options_.recycle_log_file_num > 0);
   WriteBatch batch;

db/write_batch.cc

@@ -56,7 +56,6 @@
 #include "monitoring/statistics.h"
 #include "port/lang.h"
 #include "rocksdb/merge_operator.h"
-#include "rocksdb/system_clock.h"
 #include "util/autovector.h"
 #include "util/cast_util.h"
 #include "util/coding.h"
@@ -2041,7 +2040,7 @@ class MemTableInserter : public WriteBatch::Handler {
         std::string new_value;
         Status merge_status = MergeHelper::TimedFullMerge(
             merge_operator, key, &get_value_slice, {value}, &new_value,
-            moptions->info_log, moptions->statistics, SystemClock::Default());
+            moptions->info_log, moptions->statistics, Env::Default());
 
         if (!merge_status.ok()) {
           // Failed to merge!

db/write_controller.cc

@@ -8,8 +8,7 @@
 #include <atomic>
 #include <cassert>
 #include <ratio>
-
-#include "rocksdb/system_clock.h"
+#include "rocksdb/env.h"
 
 namespace ROCKSDB_NAMESPACE {
 
@@ -43,8 +42,7 @@ bool WriteController::IsStopped() const {
 // If it turns out to be a performance issue, we can redesign the thread
 // synchronization model here.
 // The function trust caller will sleep micros returned.
-uint64_t WriteController::GetDelay(const std::shared_ptr<SystemClock>& clock,
-                                   uint64_t num_bytes) {
+uint64_t WriteController::GetDelay(Env* env, uint64_t num_bytes) {
   if (total_stopped_.load(std::memory_order_relaxed) > 0) {
     return 0;
   }
@@ -61,7 +59,7 @@ uint64_t WriteController::GetDelay(const std::shared_ptr<SystemClock>& clock,
   }
   // The frequency to get time inside DB mutex is less than one per refill
   // interval.
-  auto time_now = NowMicrosMonotonic(clock);
+  auto time_now = NowMicrosMonotonic(env);
 
   uint64_t sleep_debt = 0;
   uint64_t time_since_last_refill = 0;
@@ -108,9 +106,8 @@ uint64_t WriteController::GetDelay(const std::shared_ptr<SystemClock>& clock,
   return sleep_amount;
 }
 
-uint64_t WriteController::NowMicrosMonotonic(
-    const std::shared_ptr<SystemClock>& clock) {
-  return clock->NowNanos() / std::milli::den;
+uint64_t WriteController::NowMicrosMonotonic(Env* env) {
+  return env->NowNanos() / std::milli::den;
 }
 
 StopWriteToken::~StopWriteToken() {

db/write_controller.h

@@ -13,7 +13,7 @@
 
 namespace ROCKSDB_NAMESPACE {
 
-class SystemClock;
+class Env;
 class WriteControllerToken;
 
 // WriteController is controlling write stalls in our write code-path. Write
@@ -57,8 +57,7 @@ class WriteController {
   // return how many microseconds the caller needs to sleep after the call
   // num_bytes: how many number of bytes to put into the DB.
   // Prerequisite: DB mutex held.
-  uint64_t GetDelay(const std::shared_ptr<SystemClock>& clock,
-                    uint64_t num_bytes);
+  uint64_t GetDelay(Env* env, uint64_t num_bytes);
   void set_delayed_write_rate(uint64_t write_rate) {
     // avoid divide 0
     if (write_rate == 0) {
@@ -86,7 +85,7 @@ class WriteController {
   RateLimiter* low_pri_rate_limiter() { return low_pri_rate_limiter_.get(); }
 
  private:
-  uint64_t NowMicrosMonotonic(const std::shared_ptr<SystemClock>& clock);
+  uint64_t NowMicrosMonotonic(Env* env);
 
   friend class WriteControllerToken;
   friend class StopWriteToken;

db/write_controller_test.cc

@@ -3,50 +3,46 @@
 //  COPYING file in the root directory) and Apache 2.0 License
 //  (found in the LICENSE.Apache file in the root directory).
 //
-#include "db/write_controller.h"
-
 #include <ratio>
 
-#include "rocksdb/system_clock.h"
+#include "db/write_controller.h"
+
+#include "rocksdb/env.h"
 #include "test_util/testharness.h"
 
 namespace ROCKSDB_NAMESPACE {
-namespace {
-class TimeSetClock : public SystemClockWrapper {
+
+class WriteControllerTest : public testing::Test {};
+
+class TimeSetEnv : public EnvWrapper {
  public:
-  explicit TimeSetClock() : SystemClockWrapper(nullptr) {}
-  const char* Name() const override { return "TimeSetClock"; }
+  explicit TimeSetEnv() : EnvWrapper(nullptr) {}
   uint64_t now_micros_ = 6666;
   uint64_t NowNanos() override { return now_micros_ * std::milli::den; }
 };
-}  // namespace
-class WriteControllerTest : public testing::Test {
- public:
-  WriteControllerTest() { clock_ = std::make_shared<TimeSetClock>(); }
-  std::shared_ptr<TimeSetClock> clock_;
-};
 
 TEST_F(WriteControllerTest, ChangeDelayRateTest) {
+  TimeSetEnv env;
   WriteController controller(40000000u);  // also set max delayed rate
   controller.set_delayed_write_rate(10000000u);
   auto delay_token_0 =
       controller.GetDelayToken(controller.delayed_write_rate());
   ASSERT_EQ(static_cast<uint64_t>(2000000),
-            controller.GetDelay(clock_, 20000000u));
+            controller.GetDelay(&env, 20000000u));
   auto delay_token_1 = controller.GetDelayToken(2000000u);
   ASSERT_EQ(static_cast<uint64_t>(10000000),
-            controller.GetDelay(clock_, 20000000u));
+            controller.GetDelay(&env, 20000000u));
   auto delay_token_2 = controller.GetDelayToken(1000000u);
   ASSERT_EQ(static_cast<uint64_t>(20000000),
-            controller.GetDelay(clock_, 20000000u));
+            controller.GetDelay(&env, 20000000u));
   auto delay_token_3 = controller.GetDelayToken(20000000u);
   ASSERT_EQ(static_cast<uint64_t>(1000000),
-            controller.GetDelay(clock_, 20000000u));
+            controller.GetDelay(&env, 20000000u));
   // This is more than max rate. Max delayed rate will be used.
   auto delay_token_4 =
       controller.GetDelayToken(controller.delayed_write_rate() * 3);
   ASSERT_EQ(static_cast<uint64_t>(500000),
-            controller.GetDelay(clock_, 20000000u));
+            controller.GetDelay(&env, 20000000u));
 }
 
 TEST_F(WriteControllerTest, SanityTest) {
@@ -60,71 +56,73 @@ TEST_F(WriteControllerTest, SanityTest) {
   stop_token_2.reset();
   ASSERT_FALSE(controller.IsStopped());
 
+  TimeSetEnv env;
+
   auto delay_token_1 = controller.GetDelayToken(10000000u);
   ASSERT_EQ(static_cast<uint64_t>(2000000),
-            controller.GetDelay(clock_, 20000000u));
+            controller.GetDelay(&env, 20000000u));
 
-  clock_->now_micros_ += 1999900u;  // sleep debt 1000
+  env.now_micros_ += 1999900u;  // sleep debt 1000
 
   auto delay_token_2 = controller.GetDelayToken(10000000u);
   // Rate reset after changing the token.
   ASSERT_EQ(static_cast<uint64_t>(2000000),
-            controller.GetDelay(clock_, 20000000u));
+            controller.GetDelay(&env, 20000000u));
 
-  clock_->now_micros_ += 1999900u;  // sleep debt 1000
+  env.now_micros_ += 1999900u;  // sleep debt 1000
 
   // One refill: 10240 bytes allowed, 1000 used, 9240 left
-  ASSERT_EQ(static_cast<uint64_t>(1124), controller.GetDelay(clock_, 1000u));
-  clock_->now_micros_ += 1124u;  // sleep debt 0
+  ASSERT_EQ(static_cast<uint64_t>(1124), controller.GetDelay(&env, 1000u));
+  env.now_micros_ += 1124u;  // sleep debt 0
 
   delay_token_2.reset();
   // 1000 used, 8240 left
-  ASSERT_EQ(static_cast<uint64_t>(0), controller.GetDelay(clock_, 1000u));
+  ASSERT_EQ(static_cast<uint64_t>(0), controller.GetDelay(&env, 1000u));
 
-  clock_->now_micros_ += 100u;  // sleep credit 100
+  env.now_micros_ += 100u;  // sleep credit 100
   // 1000 used, 7240 left
-  ASSERT_EQ(static_cast<uint64_t>(0), controller.GetDelay(clock_, 1000u));
+  ASSERT_EQ(static_cast<uint64_t>(0), controller.GetDelay(&env, 1000u));
 
-  clock_->now_micros_ += 100u;  // sleep credit 200
+  env.now_micros_ += 100u;  // sleep credit 200
   // One refill: 10240 fileed, sleep credit generates 2000. 8000 used
   //             7240 + 10240 + 2000 - 8000 = 11480 left
-  ASSERT_EQ(static_cast<uint64_t>(1024u), controller.GetDelay(clock_, 8000u));
+  ASSERT_EQ(static_cast<uint64_t>(1024u), controller.GetDelay(&env, 8000u));
 
-  clock_->now_micros_ += 200u;  // sleep debt 824
+  env.now_micros_ += 200u;  // sleep debt 824
   // 1000 used, 10480 left.
-  ASSERT_EQ(static_cast<uint64_t>(0), controller.GetDelay(clock_, 1000u));
+  ASSERT_EQ(static_cast<uint64_t>(0), controller.GetDelay(&env, 1000u));
 
-  clock_->now_micros_ += 200u;  // sleep debt 624
+  env.now_micros_ += 200u;  // sleep debt 624
   // Out of bound sleep, still 10480 left
   ASSERT_EQ(static_cast<uint64_t>(3000624u),
-            controller.GetDelay(clock_, 30000000u));
+            controller.GetDelay(&env, 30000000u));
 
-  clock_->now_micros_ += 3000724u;  // sleep credit 100
+  env.now_micros_ += 3000724u;  // sleep credit 100
   // 6000 used, 4480 left.
-  ASSERT_EQ(static_cast<uint64_t>(0), controller.GetDelay(clock_, 6000u));
+  ASSERT_EQ(static_cast<uint64_t>(0), controller.GetDelay(&env, 6000u));
 
-  clock_->now_micros_ += 200u;  // sleep credit 300
+  env.now_micros_ += 200u;  // sleep credit 300
   // One refill, credit 4480 balance + 3000 credit + 10240 refill
   // Use 8000, 9720 left
-  ASSERT_EQ(static_cast<uint64_t>(1024u), controller.GetDelay(clock_, 8000u));
+  ASSERT_EQ(static_cast<uint64_t>(1024u), controller.GetDelay(&env, 8000u));
 
-  clock_->now_micros_ += 3024u;  // sleep credit 2000
+  env.now_micros_ += 3024u;  // sleep credit 2000
 
   // 1720 left
-  ASSERT_EQ(static_cast<uint64_t>(0u), controller.GetDelay(clock_, 8000u));
+  ASSERT_EQ(static_cast<uint64_t>(0u), controller.GetDelay(&env, 8000u));
 
   // 1720 balance + 20000 credit = 20170 left
   // Use 8000, 12170 left
-  ASSERT_EQ(static_cast<uint64_t>(0u), controller.GetDelay(clock_, 8000u));
+  ASSERT_EQ(static_cast<uint64_t>(0u), controller.GetDelay(&env, 8000u));
 
   // 4170 left
-  ASSERT_EQ(static_cast<uint64_t>(0u), controller.GetDelay(clock_, 8000u));
+  ASSERT_EQ(static_cast<uint64_t>(0u), controller.GetDelay(&env, 8000u));
 
   // Need a refill
-  ASSERT_EQ(static_cast<uint64_t>(1024u), controller.GetDelay(clock_, 9000u));
+  ASSERT_EQ(static_cast<uint64_t>(1024u), controller.GetDelay(&env, 9000u));
 
   delay_token_1.reset();
-  ASSERT_EQ(static_cast<uint64_t>(0), controller.GetDelay(clock_, 30000000u));
+  ASSERT_EQ(static_cast<uint64_t>(0), controller.GetDelay(&env, 30000000u));
   delay_token_1.reset();
   ASSERT_FALSE(controller.IsStopped());
 }

env/composite_env.cc

@@ -1,369 +0,0 @@
-// Copyright (c) 2019-present, Facebook, Inc.  All rights reserved.
-//  This source code is licensed under both the GPLv2 (found in the
-//  COPYING file in the root directory) and Apache 2.0 License
-//  (found in the LICENSE.Apache file in the root directory).
-//
-#include "env/composite_env_wrapper.h"
-
-namespace ROCKSDB_NAMESPACE {
-namespace {
-// The CompositeEnvWrapper class provides an interface that is compatible
-// with the old monolithic Env API, and an implementation that wraps around
-// the new Env that provides threading and other OS related functionality, and
-// the new FileSystem API that provides storage functionality. By
-// providing the old Env interface, it allows the rest of RocksDB code to
-// be agnostic of whether the underlying Env implementation is a monolithic
-// Env or an Env + FileSystem. In the former case, the user will specify
-// Options::env only, whereas in the latter case, the user will specify
-// Options::env and Options::file_system.
-
-class CompositeSequentialFileWrapper : public SequentialFile {
- public:
-  explicit CompositeSequentialFileWrapper(
-      std::unique_ptr<FSSequentialFile>& target)
-      : target_(std::move(target)) {}
-
-  Status Read(size_t n, Slice* result, char* scratch) override {
-    IOOptions io_opts;
-    IODebugContext dbg;
-    return target_->Read(n, io_opts, result, scratch, &dbg);
-  }
-  Status Skip(uint64_t n) override { return target_->Skip(n); }
-  bool use_direct_io() const override { return target_->use_direct_io(); }
-  size_t GetRequiredBufferAlignment() const override {
-    return target_->GetRequiredBufferAlignment();
-  }
-  Status InvalidateCache(size_t offset, size_t length) override {
-    return target_->InvalidateCache(offset, length);
-  }
-  Status PositionedRead(uint64_t offset, size_t n, Slice* result,
-                        char* scratch) override {
-    IOOptions io_opts;
-    IODebugContext dbg;
-    return target_->PositionedRead(offset, n, io_opts, result, scratch, &dbg);
-  }
-
- private:
-  std::unique_ptr<FSSequentialFile> target_;
-};
-
-class CompositeRandomAccessFileWrapper : public RandomAccessFile {
- public:
-  explicit CompositeRandomAccessFileWrapper(
-      std::unique_ptr<FSRandomAccessFile>& target)
-      : target_(std::move(target)) {}
-
-  Status Read(uint64_t offset, size_t n, Slice* result,
-              char* scratch) const override {
-    IOOptions io_opts;
-    IODebugContext dbg;
-    return target_->Read(offset, n, io_opts, result, scratch, &dbg);
-  }
-  Status MultiRead(ReadRequest* reqs, size_t num_reqs) override {
-    IOOptions io_opts;
-    IODebugContext dbg;
-    std::vector<FSReadRequest> fs_reqs;
-    Status status;
-
-    fs_reqs.resize(num_reqs);
-    for (size_t i = 0; i < num_reqs; ++i) {
-      fs_reqs[i].offset = reqs[i].offset;
-      fs_reqs[i].len = reqs[i].len;
-      fs_reqs[i].scratch = reqs[i].scratch;
-      fs_reqs[i].status = IOStatus::OK();
-    }
-    status = target_->MultiRead(fs_reqs.data(), num_reqs, io_opts, &dbg);
-    for (size_t i = 0; i < num_reqs; ++i) {
-      reqs[i].result = fs_reqs[i].result;
-      reqs[i].status = fs_reqs[i].status;
-    }
-    return status;
-  }
-  Status Prefetch(uint64_t offset, size_t n) override {
-    IOOptions io_opts;
-    IODebugContext dbg;
-    return target_->Prefetch(offset, n, io_opts, &dbg);
-  }
-  size_t GetUniqueId(char* id, size_t max_size) const override {
-    return target_->GetUniqueId(id, max_size);
-  }
-  void Hint(AccessPattern pattern) override {
-    target_->Hint((FSRandomAccessFile::AccessPattern)pattern);
-  }
-  bool use_direct_io() const override { return target_->use_direct_io(); }
-  size_t GetRequiredBufferAlignment() const override {
-    return target_->GetRequiredBufferAlignment();
-  }
-  Status InvalidateCache(size_t offset, size_t length) override {
-    return target_->InvalidateCache(offset, length);
-  }
-
- private:
-  std::unique_ptr<FSRandomAccessFile> target_;
-};
-
-class CompositeWritableFileWrapper : public WritableFile {
- public:
-  explicit CompositeWritableFileWrapper(std::unique_ptr<FSWritableFile>& t)
-      : target_(std::move(t)) {}
-
-  Status Append(const Slice& data) override {
-    IOOptions io_opts;
-    IODebugContext dbg;
-    return target_->Append(data, io_opts, &dbg);
-  }
-  Status PositionedAppend(const Slice& data, uint64_t offset) override {
-    IOOptions io_opts;
-    IODebugContext dbg;
-    return target_->PositionedAppend(data, offset, io_opts, &dbg);
-  }
-  Status Truncate(uint64_t size) override {
-    IOOptions io_opts;
-    IODebugContext dbg;
-    return target_->Truncate(size, io_opts, &dbg);
-  }
-  Status Close() override {
-    IOOptions io_opts;
-    IODebugContext dbg;
-    return target_->Close(io_opts, &dbg);
-  }
-  Status Flush() override {
-    IOOptions io_opts;
-    IODebugContext dbg;
-    return target_->Flush(io_opts, &dbg);
-  }
-  Status Sync() override {
-    IOOptions io_opts;
-    IODebugContext dbg;
-    return target_->Sync(io_opts, &dbg);
-  }
-  Status Fsync() override {
-    IOOptions io_opts;
-    IODebugContext dbg;
-    return target_->Fsync(io_opts, &dbg);
-  }
-  bool IsSyncThreadSafe() const override { return target_->IsSyncThreadSafe(); }
-
-  bool use_direct_io() const override { return target_->use_direct_io(); }
-
-  size_t GetRequiredBufferAlignment() const override {
-    return target_->GetRequiredBufferAlignment();
-  }
-
-  void SetWriteLifeTimeHint(Env::WriteLifeTimeHint hint) override {
-    target_->SetWriteLifeTimeHint(hint);
-  }
-
-  Env::WriteLifeTimeHint GetWriteLifeTimeHint() override {
-    return target_->GetWriteLifeTimeHint();
-  }
-
-  uint64_t GetFileSize() override {
-    IOOptions io_opts;
-    IODebugContext dbg;
-    return target_->GetFileSize(io_opts, &dbg);
-  }
-
-  void SetPreallocationBlockSize(size_t size) override {
-    target_->SetPreallocationBlockSize(size);
-  }
-
-  void GetPreallocationStatus(size_t* block_size,
-                              size_t* last_allocated_block) override {
-    target_->GetPreallocationStatus(block_size, last_allocated_block);
-  }
-
-  size_t GetUniqueId(char* id, size_t max_size) const override {
-    return target_->GetUniqueId(id, max_size);
-  }
-
-  Status InvalidateCache(size_t offset, size_t length) override {
-    return target_->InvalidateCache(offset, length);
-  }
-
-  Status RangeSync(uint64_t offset, uint64_t nbytes) override {
-    IOOptions io_opts;
-    IODebugContext dbg;
-    return target_->RangeSync(offset, nbytes, io_opts, &dbg);
-  }
-
-  void PrepareWrite(size_t offset, size_t len) override {
-    IOOptions io_opts;
-    IODebugContext dbg;
-    target_->PrepareWrite(offset, len, io_opts, &dbg);
-  }
-
-  Status Allocate(uint64_t offset, uint64_t len) override {
-    IOOptions io_opts;
-    IODebugContext dbg;
-    return target_->Allocate(offset, len, io_opts, &dbg);
-  }
-
-  std::unique_ptr<FSWritableFile>* target() { return &target_; }
-
- private:
-  std::unique_ptr<FSWritableFile> target_;
-};
-
-class CompositeRandomRWFileWrapper : public RandomRWFile {
- public:
-  explicit CompositeRandomRWFileWrapper(std::unique_ptr<FSRandomRWFile>& target)
-      : target_(std::move(target)) {}
-
-  bool use_direct_io() const override { return target_->use_direct_io(); }
-  size_t GetRequiredBufferAlignment() const override {
-    return target_->GetRequiredBufferAlignment();
-  }
-  Status Write(uint64_t offset, const Slice& data) override {
-    IOOptions io_opts;
-    IODebugContext dbg;
-    return target_->Write(offset, data, io_opts, &dbg);
-  }
-  Status Read(uint64_t offset, size_t n, Slice* result,
-              char* scratch) const override {
-    IOOptions io_opts;
-    IODebugContext dbg;
-    return target_->Read(offset, n, io_opts, result, scratch, &dbg);
-  }
-  Status Flush() override {
-    IOOptions io_opts;
-    IODebugContext dbg;
-    return target_->Flush(io_opts, &dbg);
-  }
-  Status Sync() override {
-    IOOptions io_opts;
-    IODebugContext dbg;
-    return target_->Sync(io_opts, &dbg);
-  }
-  Status Fsync() override {
-    IOOptions io_opts;
-    IODebugContext dbg;
-    return target_->Fsync(io_opts, &dbg);
-  }
-  Status Close() override {
-    IOOptions io_opts;
-    IODebugContext dbg;
-    return target_->Close(io_opts, &dbg);
-  }
-
- private:
-  std::unique_ptr<FSRandomRWFile> target_;
-};
-
-class CompositeDirectoryWrapper : public Directory {
- public:
-  explicit CompositeDirectoryWrapper(std::unique_ptr<FSDirectory>& target)
-      : target_(std::move(target)) {}
-
-  Status Fsync() override {
-    IOOptions io_opts;
-    IODebugContext dbg;
-    return target_->Fsync(io_opts, &dbg);
-  }
-  size_t GetUniqueId(char* id, size_t max_size) const override {
-    return target_->GetUniqueId(id, max_size);
-  }
-
- private:
-  std::unique_ptr<FSDirectory> target_;
-};
-}  // namespace
-
-Status CompositeEnv::NewSequentialFile(const std::string& f,
-                                       std::unique_ptr<SequentialFile>* r,
-                                       const EnvOptions& options) {
-  IODebugContext dbg;
-  std::unique_ptr<FSSequentialFile> file;
-  Status status;
-  status =
-      file_system_->NewSequentialFile(f, FileOptions(options), &file, &dbg);
-  if (status.ok()) {
-    r->reset(new CompositeSequentialFileWrapper(file));
-  }
-  return status;
-}
-
-Status CompositeEnv::NewRandomAccessFile(const std::string& f,
-                                         std::unique_ptr<RandomAccessFile>* r,
-                                         const EnvOptions& options) {
-  IODebugContext dbg;
-  std::unique_ptr<FSRandomAccessFile> file;
-  Status status;
-  status =
-      file_system_->NewRandomAccessFile(f, FileOptions(options), &file, &dbg);
-  if (status.ok()) {
-    r->reset(new CompositeRandomAccessFileWrapper(file));
-  }
-  return status;
-}
-
-Status CompositeEnv::NewWritableFile(const std::string& f,
-                                     std::unique_ptr<WritableFile>* r,
-                                     const EnvOptions& options) {
-  IODebugContext dbg;
-  std::unique_ptr<FSWritableFile> file;
-  Status status;
-  status = file_system_->NewWritableFile(f, FileOptions(options), &file, &dbg);
-  if (status.ok()) {
-    r->reset(new CompositeWritableFileWrapper(file));
-  }
-  return status;
-}
-
-Status CompositeEnv::ReopenWritableFile(const std::string& fname,
-                                        std::unique_ptr<WritableFile>* result,
-                                        const EnvOptions& options) {
-  IODebugContext dbg;
-  Status status;
-  std::unique_ptr<FSWritableFile> file;
-  status = file_system_->ReopenWritableFile(fname, FileOptions(options), &file,
-                                            &dbg);
-  if (status.ok()) {
-    result->reset(new CompositeWritableFileWrapper(file));
-  }
-  return status;
-}
-
-Status CompositeEnv::ReuseWritableFile(const std::string& fname,
-                                       const std::string& old_fname,
-                                       std::unique_ptr<WritableFile>* r,
-                                       const EnvOptions& options) {
-  IODebugContext dbg;
-  Status status;
-  std::unique_ptr<FSWritableFile> file;
-  status = file_system_->ReuseWritableFile(fname, old_fname,
-                                           FileOptions(options), &file, &dbg);
-  if (status.ok()) {
-    r->reset(new CompositeWritableFileWrapper(file));
-  }
-  return status;
-}
-
-Status CompositeEnv::NewRandomRWFile(const std::string& fname,
-                                     std::unique_ptr<RandomRWFile>* result,
-                                     const EnvOptions& options) {
-  IODebugContext dbg;
-  std::unique_ptr<FSRandomRWFile> file;
-  Status status;
-  status =
-      file_system_->NewRandomRWFile(fname, FileOptions(options), &file, &dbg);
-  if (status.ok()) {
-    result->reset(new CompositeRandomRWFileWrapper(file));
-  }
-  return status;
-}
-
-Status CompositeEnv::NewDirectory(const std::string& name,
-                                  std::unique_ptr<Directory>* result) {
-  IOOptions io_opts;
-  IODebugContext dbg;
-  std::unique_ptr<FSDirectory> dir;
-  Status status;
-  status = file_system_->NewDirectory(name, io_opts, &dir, &dbg);
-  if (status.ok()) {
-    result->reset(new CompositeDirectoryWrapper(dir));
-  }
-  return status;
-}
-
-}  // namespace ROCKSDB_NAMESPACE

env/composite_env_wrapper.h

@@ -7,7 +7,6 @@
 
 #include "rocksdb/env.h"
 #include "rocksdb/file_system.h"
-#include "rocksdb/system_clock.h"
 
 #ifdef _WIN32
 // Windows API macro interference
@@ -18,13 +17,272 @@
 
 namespace ROCKSDB_NAMESPACE {
 
+// The CompositeEnvWrapper class provides an interface that is compatible
+// with the old monolithic Env API, and an implementation that wraps around
+// the new Env that provides threading and other OS related functionality, and
+// the new FileSystem API that provides storage functionality. By
+// providing the old Env interface, it allows the rest of RocksDB code to
+// be agnostic of whether the underlying Env implementation is a monolithic
+// Env or an Env + FileSystem. In the former case, the user will specify
+// Options::env only, whereas in the latter case, the user will specify
+// Options::env and Options::file_system.
+
+class CompositeSequentialFileWrapper : public SequentialFile {
+ public:
+  explicit CompositeSequentialFileWrapper(
+      std::unique_ptr<FSSequentialFile>& target)
+      : target_(std::move(target)) {}
+
+  Status Read(size_t n, Slice* result, char* scratch) override {
+    IOOptions io_opts;
+    IODebugContext dbg;
+    return target_->Read(n, io_opts, result, scratch, &dbg);
+  }
+  Status Skip(uint64_t n) override { return target_->Skip(n); }
+  bool use_direct_io() const override { return target_->use_direct_io(); }
+  size_t GetRequiredBufferAlignment() const override {
+    return target_->GetRequiredBufferAlignment();
+  }
+  Status InvalidateCache(size_t offset, size_t length) override {
+    return target_->InvalidateCache(offset, length);
+  }
+  Status PositionedRead(uint64_t offset, size_t n, Slice* result,
+                        char* scratch) override {
+    IOOptions io_opts;
+    IODebugContext dbg;
+    return target_->PositionedRead(offset, n, io_opts, result, scratch, &dbg);
+  }
+
+ private:
+  std::unique_ptr<FSSequentialFile> target_;
+};
+
+class CompositeRandomAccessFileWrapper : public RandomAccessFile {
+ public:
+  explicit CompositeRandomAccessFileWrapper(
+      std::unique_ptr<FSRandomAccessFile>& target)
+      : target_(std::move(target)) {}
+
+  Status Read(uint64_t offset, size_t n, Slice* result,
+              char* scratch) const override {
+    IOOptions io_opts;
+    IODebugContext dbg;
+    return target_->Read(offset, n, io_opts, result, scratch, &dbg);
+  }
+  Status MultiRead(ReadRequest* reqs, size_t num_reqs) override {
+    IOOptions io_opts;
+    IODebugContext dbg;
+    std::vector<FSReadRequest> fs_reqs;
+    Status status;
+
+    fs_reqs.resize(num_reqs);
+    for (size_t i = 0; i < num_reqs; ++i) {
+      fs_reqs[i].offset = reqs[i].offset;
+      fs_reqs[i].len = reqs[i].len;
+      fs_reqs[i].scratch = reqs[i].scratch;
+      fs_reqs[i].status = IOStatus::OK();
+    }
+    status = target_->MultiRead(fs_reqs.data(), num_reqs, io_opts, &dbg);
+    for (size_t i = 0; i < num_reqs; ++i) {
+      reqs[i].result = fs_reqs[i].result;
+      reqs[i].status = fs_reqs[i].status;
+    }
+    return status;
+  }
+  Status Prefetch(uint64_t offset, size_t n) override {
+    IOOptions io_opts;
+    IODebugContext dbg;
+    return target_->Prefetch(offset, n, io_opts, &dbg);
+  }
+  size_t GetUniqueId(char* id, size_t max_size) const override {
+    return target_->GetUniqueId(id, max_size);
+  };
+  void Hint(AccessPattern pattern) override {
+    target_->Hint((FSRandomAccessFile::AccessPattern)pattern);
+  }
+  bool use_direct_io() const override { return target_->use_direct_io(); }
+  size_t GetRequiredBufferAlignment() const override {
+    return target_->GetRequiredBufferAlignment();
+  }
+  Status InvalidateCache(size_t offset, size_t length) override {
+    return target_->InvalidateCache(offset, length);
+  }
+
+ private:
+  std::unique_ptr<FSRandomAccessFile> target_;
+};
+
+class CompositeWritableFileWrapper : public WritableFile {
+ public:
+  explicit CompositeWritableFileWrapper(std::unique_ptr<FSWritableFile>& t)
+      : target_(std::move(t)) {}
+
+  Status Append(const Slice& data) override {
+    IOOptions io_opts;
+    IODebugContext dbg;
+    return target_->Append(data, io_opts, &dbg);
+  }
+  Status PositionedAppend(const Slice& data, uint64_t offset) override {
+    IOOptions io_opts;
+    IODebugContext dbg;
+    return target_->PositionedAppend(data, offset, io_opts, &dbg);
+  }
+  Status Truncate(uint64_t size) override {
+    IOOptions io_opts;
+    IODebugContext dbg;
+    return target_->Truncate(size, io_opts, &dbg);
+  }
+  Status Close() override {
+    IOOptions io_opts;
+    IODebugContext dbg;
+    return target_->Close(io_opts, &dbg);
+  }
+  Status Flush() override {
+    IOOptions io_opts;
+    IODebugContext dbg;
+    return target_->Flush(io_opts, &dbg);
+  }
+  Status Sync() override {
+    IOOptions io_opts;
+    IODebugContext dbg;
+    return target_->Sync(io_opts, &dbg);
+  }
+  Status Fsync() override {
+    IOOptions io_opts;
+    IODebugContext dbg;
+    return target_->Fsync(io_opts, &dbg);
+  }
+  bool IsSyncThreadSafe() const override { return target_->IsSyncThreadSafe(); }
+
+  bool use_direct_io() const override { return target_->use_direct_io(); }
+
+  size_t GetRequiredBufferAlignment() const override {
+    return target_->GetRequiredBufferAlignment();
+  }
+
+  void SetWriteLifeTimeHint(Env::WriteLifeTimeHint hint) override {
+    target_->SetWriteLifeTimeHint(hint);
+  }
+
+  Env::WriteLifeTimeHint GetWriteLifeTimeHint() override {
+    return target_->GetWriteLifeTimeHint();
+  }
+
+  uint64_t GetFileSize() override {
+    IOOptions io_opts;
+    IODebugContext dbg;
+    return target_->GetFileSize(io_opts, &dbg);
+  }
+
+  void SetPreallocationBlockSize(size_t size) override {
+    target_->SetPreallocationBlockSize(size);
+  }
+
+  void GetPreallocationStatus(size_t* block_size,
+                              size_t* last_allocated_block) override {
+    target_->GetPreallocationStatus(block_size, last_allocated_block);
+  }
+
+  size_t GetUniqueId(char* id, size_t max_size) const override {
+    return target_->GetUniqueId(id, max_size);
+  }
+
+  Status InvalidateCache(size_t offset, size_t length) override {
+    return target_->InvalidateCache(offset, length);
+  }
+
+  Status RangeSync(uint64_t offset, uint64_t nbytes) override {
+    IOOptions io_opts;
+    IODebugContext dbg;
+    return target_->RangeSync(offset, nbytes, io_opts, &dbg);
+  }
+
+  void PrepareWrite(size_t offset, size_t len) override {
+    IOOptions io_opts;
+    IODebugContext dbg;
+    target_->PrepareWrite(offset, len, io_opts, &dbg);
+  }
+
+  Status Allocate(uint64_t offset, uint64_t len) override {
+    IOOptions io_opts;
+    IODebugContext dbg;
+    return target_->Allocate(offset, len, io_opts, &dbg);
+  }
+
+  std::unique_ptr<FSWritableFile>* target() { return &target_; }
+
+ private:
+  std::unique_ptr<FSWritableFile> target_;
+};
+
+class CompositeRandomRWFileWrapper : public RandomRWFile {
+ public:
+  explicit CompositeRandomRWFileWrapper(std::unique_ptr<FSRandomRWFile>& target)
+      : target_(std::move(target)) {}
+
+  bool use_direct_io() const override { return target_->use_direct_io(); }
+  size_t GetRequiredBufferAlignment() const override {
+    return target_->GetRequiredBufferAlignment();
+  }
+  Status Write(uint64_t offset, const Slice& data) override {
+    IOOptions io_opts;
+    IODebugContext dbg;
+    return target_->Write(offset, data, io_opts, &dbg);
+  }
+  Status Read(uint64_t offset, size_t n, Slice* result,
+              char* scratch) const override {
+    IOOptions io_opts;
+    IODebugContext dbg;
+    return target_->Read(offset, n, io_opts, result, scratch, &dbg);
+  }
+  Status Flush() override {
+    IOOptions io_opts;
+    IODebugContext dbg;
+    return target_->Flush(io_opts, &dbg);
+  }
+  Status Sync() override {
+    IOOptions io_opts;
+    IODebugContext dbg;
+    return target_->Sync(io_opts, &dbg);
+  }
+  Status Fsync() override {
+    IOOptions io_opts;
+    IODebugContext dbg;
+    return target_->Fsync(io_opts, &dbg);
+  }
+  Status Close() override {
+    IOOptions io_opts;
+    IODebugContext dbg;
+    return target_->Close(io_opts, &dbg);
+  }
+
+ private:
+  std::unique_ptr<FSRandomRWFile> target_;
+};
+
+class CompositeDirectoryWrapper : public Directory {
+ public:
+  explicit CompositeDirectoryWrapper(std::unique_ptr<FSDirectory>& target)
+      : target_(std::move(target)) {}
+
+  Status Fsync() override {
+    IOOptions io_opts;
+    IODebugContext dbg;
+    return target_->Fsync(io_opts, &dbg);
+  }
+  size_t GetUniqueId(char* id, size_t max_size) const override {
+    return target_->GetUniqueId(id, max_size);
+  }
+
+ private:
+  std::unique_ptr<FSDirectory> target_;
+};
+
 class CompositeEnv : public Env {
  public:
   // Initialize a CompositeEnvWrapper that delegates all thread/time related
   // calls to env, and all file operations to fs
-  explicit CompositeEnv(const std::shared_ptr<FileSystem>& fs,
-                        const std::shared_ptr<SystemClock>& clock)
-      : Env(fs, clock) {}
+  explicit CompositeEnv(const std::shared_ptr<FileSystem>& fs) : Env(fs) {}
 
   Status RegisterDbPaths(const std::vector<std::string>& paths) override {
     return file_system_->RegisterDbPaths(paths);
@@ -36,37 +294,99 @@ class CompositeEnv : public Env {
   // The following text is boilerplate that forwards all methods to target()
   Status NewSequentialFile(const std::string& f,
                            std::unique_ptr<SequentialFile>* r,
-                           const EnvOptions& options) override;
-
+                           const EnvOptions& options) override {
+    IODebugContext dbg;
+    std::unique_ptr<FSSequentialFile> file;
+    Status status;
+    status =
+        file_system_->NewSequentialFile(f, FileOptions(options), &file, &dbg);
+    if (status.ok()) {
+      r->reset(new CompositeSequentialFileWrapper(file));
+    }
+    return status;
+  }
   Status NewRandomAccessFile(const std::string& f,
                              std::unique_ptr<RandomAccessFile>* r,
-                             const EnvOptions& options) override;
-
+                             const EnvOptions& options) override {
+    IODebugContext dbg;
+    std::unique_ptr<FSRandomAccessFile> file;
+    Status status;
+    status =
+        file_system_->NewRandomAccessFile(f, FileOptions(options), &file, &dbg);
+    if (status.ok()) {
+      r->reset(new CompositeRandomAccessFileWrapper(file));
+    }
+    return status;
+  }
   Status NewWritableFile(const std::string& f, std::unique_ptr<WritableFile>* r,
-                         const EnvOptions& options) override;
-
+                         const EnvOptions& options) override {
+    IODebugContext dbg;
+    std::unique_ptr<FSWritableFile> file;
+    Status status;
+    status =
+        file_system_->NewWritableFile(f, FileOptions(options), &file, &dbg);
+    if (status.ok()) {
+      r->reset(new CompositeWritableFileWrapper(file));
+    }
+    return status;
+  }
   Status ReopenWritableFile(const std::string& fname,
                             std::unique_ptr<WritableFile>* result,
-                            const EnvOptions& options) override;
-
+                            const EnvOptions& options) override {
+    IODebugContext dbg;
+    Status status;
+    std::unique_ptr<FSWritableFile> file;
+    status = file_system_->ReopenWritableFile(fname, FileOptions(options),
+                                              &file, &dbg);
+    if (status.ok()) {
+      result->reset(new CompositeWritableFileWrapper(file));
+    }
+    return status;
+  }
   Status ReuseWritableFile(const std::string& fname,
                            const std::string& old_fname,
                            std::unique_ptr<WritableFile>* r,
-                           const EnvOptions& options) override;
-
+                           const EnvOptions& options) override {
+    IODebugContext dbg;
+    Status status;
+    std::unique_ptr<FSWritableFile> file;
+    status = file_system_->ReuseWritableFile(fname, old_fname,
+                                             FileOptions(options), &file, &dbg);
+    if (status.ok()) {
+      r->reset(new CompositeWritableFileWrapper(file));
+    }
+    return status;
+  }
   Status NewRandomRWFile(const std::string& fname,
                          std::unique_ptr<RandomRWFile>* result,
-                         const EnvOptions& options) override;
-
+                         const EnvOptions& options) override {
+    IODebugContext dbg;
+    std::unique_ptr<FSRandomRWFile> file;
+    Status status;
+    status =
+        file_system_->NewRandomRWFile(fname, FileOptions(options), &file, &dbg);
+    if (status.ok()) {
+      result->reset(new CompositeRandomRWFileWrapper(file));
+    }
+    return status;
+  }
   Status NewMemoryMappedFileBuffer(
       const std::string& fname,
       std::unique_ptr<MemoryMappedFileBuffer>* result) override {
     return file_system_->NewMemoryMappedFileBuffer(fname, result);
   }
-
   Status NewDirectory(const std::string& name,
-                      std::unique_ptr<Directory>* result) override;
-
+                      std::unique_ptr<Directory>* result) override {
+    IOOptions io_opts;
+    IODebugContext dbg;
+    std::unique_ptr<FSDirectory> dir;
+    Status status;
+    status = file_system_->NewDirectory(name, io_opts, &dir, &dbg);
+    if (status.ok()) {
+      result->reset(new CompositeDirectoryWrapper(dir));
+    }
+    return status;
+  }
   Status FileExists(const std::string& f) override {
     IOOptions io_opts;
     IODebugContext dbg;
@@ -228,21 +548,6 @@ class CompositeEnv : public Env {
     IODebugContext dbg;
     return file_system_->GetFreeSpace(path, io_opts, diskfree, &dbg);
   }
-  uint64_t NowMicros() override { return system_clock_->NowMicros(); }
-  uint64_t NowNanos() override { return system_clock_->NowNanos(); }
-
-  uint64_t NowCPUNanos() override { return system_clock_->CPUNanos(); }
-
-  void SleepForMicroseconds(int micros) override {
-    system_clock_->SleepForMicroseconds(micros);
-  }
-
-  Status GetCurrentTime(int64_t* unix_time) override {
-    return system_clock_->GetCurrentTime(unix_time);
-  }
-  std::string TimeToString(uint64_t time) override {
-    return system_clock_->TimeToString(time);
-  }
 };
 
 class CompositeEnvWrapper : public CompositeEnv {
@@ -250,14 +555,7 @@ class CompositeEnvWrapper : public CompositeEnv {
   // Initialize a CompositeEnvWrapper that delegates all thread/time related
   // calls to env, and all file operations to fs
   explicit CompositeEnvWrapper(Env* env, const std::shared_ptr<FileSystem>& fs)
-      : CompositeEnvWrapper(env, fs, env->GetSystemClock()) {}
-
-  explicit CompositeEnvWrapper(Env* env, const std::shared_ptr<SystemClock>& sc)
-      : CompositeEnvWrapper(env, env->GetFileSystem(), sc) {}
-
-  explicit CompositeEnvWrapper(Env* env, const std::shared_ptr<FileSystem>& fs,
-                               const std::shared_ptr<SystemClock>& sc)
-      : CompositeEnv(fs, sc), env_target_(env) {}
+      : CompositeEnv(fs), env_target_(env) {}
 
   // Return the target to which this Env forwards all calls
   Env* env_target() const { return env_target_; }
@@ -287,9 +585,19 @@ class CompositeEnvWrapper : public CompositeEnv {
     return env_target_->GetThreadPoolQueueLen(pri);
   }
 
+  uint64_t NowMicros() override { return env_target_->NowMicros(); }
+  uint64_t NowNanos() override { return env_target_->NowNanos(); }
+  uint64_t NowCPUNanos() override { return env_target_->NowCPUNanos(); }
+
+  void SleepForMicroseconds(int micros) override {
+    env_target_->SleepForMicroseconds(micros);
+  }
   Status GetHostName(char* name, uint64_t len) override {
     return env_target_->GetHostName(name, len);
   }
+  Status GetCurrentTime(int64_t* unix_time) override {
+    return env_target_->GetCurrentTime(unix_time);
+  }
   void SetBackgroundThreads(int num, Priority pri) override {
     return env_target_->SetBackgroundThreads(num, pri);
   }
@@ -317,6 +625,10 @@ class CompositeEnvWrapper : public CompositeEnv {
     return env_target_->LowerThreadPoolCPUPriority(pool, pri);
   }
 
+  std::string TimeToString(uint64_t time) override {
+    return env_target_->TimeToString(time);
+  }
+
   Status GetThreadList(std::vector<ThreadStatus>* thread_list) override {
     return env_target_->GetThreadList(thread_list);
   }
@@ -334,4 +646,275 @@ class CompositeEnvWrapper : public CompositeEnv {
  private:
   Env* env_target_;
 };
+
+class LegacySequentialFileWrapper : public FSSequentialFile {
+ public:
+  explicit LegacySequentialFileWrapper(
+      std::unique_ptr<SequentialFile>&& _target)
+      : target_(std::move(_target)) {}
+
+  IOStatus Read(size_t n, const IOOptions& /*options*/, Slice* result,
+                char* scratch, IODebugContext* /*dbg*/) override {
+    return status_to_io_status(target_->Read(n, result, scratch));
+  }
+  IOStatus Skip(uint64_t n) override {
+    return status_to_io_status(target_->Skip(n));
+  }
+  bool use_direct_io() const override { return target_->use_direct_io(); }
+  size_t GetRequiredBufferAlignment() const override {
+    return target_->GetRequiredBufferAlignment();
+  }
+  IOStatus InvalidateCache(size_t offset, size_t length) override {
+    return status_to_io_status(target_->InvalidateCache(offset, length));
+  }
+  IOStatus PositionedRead(uint64_t offset, size_t n,
+                          const IOOptions& /*options*/, Slice* result,
+                          char* scratch, IODebugContext* /*dbg*/) override {
+    return status_to_io_status(
+        target_->PositionedRead(offset, n, result, scratch));
+  }
+  SequentialFile* target() { return target_.get(); }
+
+ private:
+  std::unique_ptr<SequentialFile> target_;
+};
+
+class LegacyRandomAccessFileWrapper : public FSRandomAccessFile {
+ public:
+  explicit LegacyRandomAccessFileWrapper(
+      std::unique_ptr<RandomAccessFile>&& target)
+      : target_(std::move(target)) {}
+
+  IOStatus Read(uint64_t offset, size_t n, const IOOptions& /*options*/,
+                Slice* result, char* scratch,
+                IODebugContext* /*dbg*/) const override {
+    return status_to_io_status(target_->Read(offset, n, result, scratch));
+  }
+  IOStatus MultiRead(FSReadRequest* fs_reqs, size_t num_reqs,
+                     const IOOptions& /*options*/,
+                     IODebugContext* /*dbg*/) override {
+    std::vector<ReadRequest> reqs;
+    Status status;
+
+    reqs.reserve(num_reqs);
+    for (size_t i = 0; i < num_reqs; ++i) {
+      ReadRequest req;
+
+      req.offset = fs_reqs[i].offset;
+      req.len = fs_reqs[i].len;
+      req.scratch = fs_reqs[i].scratch;
+      req.status = Status::OK();
+
+      reqs.emplace_back(req);
+    }
+    status = target_->MultiRead(reqs.data(), num_reqs);
+    for (size_t i = 0; i < num_reqs; ++i) {
+      fs_reqs[i].result = reqs[i].result;
+      fs_reqs[i].status = status_to_io_status(std::move(reqs[i].status));
+    }
+    return status_to_io_status(std::move(status));
+    ;
+  }
+  IOStatus Prefetch(uint64_t offset, size_t n, const IOOptions& /*options*/,
+                    IODebugContext* /*dbg*/) override {
+    return status_to_io_status(target_->Prefetch(offset, n));
+  }
+  size_t GetUniqueId(char* id, size_t max_size) const override {
+    return target_->GetUniqueId(id, max_size);
+  };
+  void Hint(AccessPattern pattern) override {
+    target_->Hint((RandomAccessFile::AccessPattern)pattern);
+  }
+  bool use_direct_io() const override { return target_->use_direct_io(); }
+  size_t GetRequiredBufferAlignment() const override {
+    return target_->GetRequiredBufferAlignment();
+  }
+  IOStatus InvalidateCache(size_t offset, size_t length) override {
+    return status_to_io_status(target_->InvalidateCache(offset, length));
+  }
+
+ private:
+  std::unique_ptr<RandomAccessFile> target_;
+};
+
+class LegacyWritableFileWrapper : public FSWritableFile {
+ public:
+  explicit LegacyWritableFileWrapper(std::unique_ptr<WritableFile>&& _target)
+      : target_(std::move(_target)) {}
+
+  IOStatus Append(const Slice& data, const IOOptions& /*options*/,
+                  IODebugContext* /*dbg*/) override {
+    return status_to_io_status(target_->Append(data));
+  }
+  IOStatus Append(const Slice& data, const IOOptions& /*options*/,
+                  const DataVerificationInfo& /*verification_info*/,
+                  IODebugContext* /*dbg*/) override {
+    return status_to_io_status(target_->Append(data));
+  }
+  IOStatus PositionedAppend(const Slice& data, uint64_t offset,
+                            const IOOptions& /*options*/,
+                            IODebugContext* /*dbg*/) override {
+    return status_to_io_status(target_->PositionedAppend(data, offset));
+  }
+  IOStatus PositionedAppend(const Slice& data, uint64_t offset,
+                            const IOOptions& /*options*/,
+                            const DataVerificationInfo& /*verification_info*/,
+                            IODebugContext* /*dbg*/) override {
+    return status_to_io_status(target_->PositionedAppend(data, offset));
+  }
+  IOStatus Truncate(uint64_t size, const IOOptions& /*options*/,
+                    IODebugContext* /*dbg*/) override {
+    return status_to_io_status(target_->Truncate(size));
+  }
+  IOStatus Close(const IOOptions& /*options*/,
+                 IODebugContext* /*dbg*/) override {
+    return status_to_io_status(target_->Close());
+  }
+  IOStatus Flush(const IOOptions& /*options*/,
+                 IODebugContext* /*dbg*/) override {
+    return status_to_io_status(target_->Flush());
+  }
+  IOStatus Sync(const IOOptions& /*options*/,
+                IODebugContext* /*dbg*/) override {
+    return status_to_io_status(target_->Sync());
+  }
+  IOStatus Fsync(const IOOptions& /*options*/,
+                 IODebugContext* /*dbg*/) override {
+    return status_to_io_status(target_->Fsync());
+  }
+  bool IsSyncThreadSafe() const override { return target_->IsSyncThreadSafe(); }
+
+  bool use_direct_io() const override { return target_->use_direct_io(); }
+
+  size_t GetRequiredBufferAlignment() const override {
+    return target_->GetRequiredBufferAlignment();
+  }
+
+  void SetWriteLifeTimeHint(Env::WriteLifeTimeHint hint) override {
+    target_->SetWriteLifeTimeHint(hint);
+  }
+
+  Env::WriteLifeTimeHint GetWriteLifeTimeHint() override {
+    return target_->GetWriteLifeTimeHint();
+  }
+
+  uint64_t GetFileSize(const IOOptions& /*options*/,
+                       IODebugContext* /*dbg*/) override {
+    return target_->GetFileSize();
+  }
+
+  void SetPreallocationBlockSize(size_t size) override {
+    target_->SetPreallocationBlockSize(size);
+  }
+
+  void GetPreallocationStatus(size_t* block_size,
+                              size_t* last_allocated_block) override {
+    target_->GetPreallocationStatus(block_size, last_allocated_block);
+  }
+
+  size_t GetUniqueId(char* id, size_t max_size) const override {
+    return target_->GetUniqueId(id, max_size);
+  }
+
+  IOStatus InvalidateCache(size_t offset, size_t length) override {
+    return status_to_io_status(target_->InvalidateCache(offset, length));
+  }
+
+  IOStatus RangeSync(uint64_t offset, uint64_t nbytes,
+                     const IOOptions& /*options*/,
+                     IODebugContext* /*dbg*/) override {
+    return status_to_io_status(target_->RangeSync(offset, nbytes));
+  }
+
+  void PrepareWrite(size_t offset, size_t len, const IOOptions& /*options*/,
+                    IODebugContext* /*dbg*/) override {
+    target_->PrepareWrite(offset, len);
+  }
+
+  IOStatus Allocate(uint64_t offset, uint64_t len, const IOOptions& /*options*/,
+                    IODebugContext* /*dbg*/) override {
+    return status_to_io_status(target_->Allocate(offset, len));
+  }
+
+  WritableFile* target() { return target_.get(); }
+
+ private:
+  std::unique_ptr<WritableFile> target_;
+};
+
+class LegacyRandomRWFileWrapper : public FSRandomRWFile {
+ public:
+  explicit LegacyRandomRWFileWrapper(std::unique_ptr<RandomRWFile>&& target)
+      : target_(std::move(target)) {}
+
+  bool use_direct_io() const override { return target_->use_direct_io(); }
+  size_t GetRequiredBufferAlignment() const override {
+    return target_->GetRequiredBufferAlignment();
+  }
+  IOStatus Write(uint64_t offset, const Slice& data,
+                 const IOOptions& /*options*/,
+                 IODebugContext* /*dbg*/) override {
+    return status_to_io_status(target_->Write(offset, data));
+  }
+  IOStatus Read(uint64_t offset, size_t n, const IOOptions& /*options*/,
+                Slice* result, char* scratch,
+                IODebugContext* /*dbg*/) const override {
+    return status_to_io_status(target_->Read(offset, n, result, scratch));
+  }
+  IOStatus Flush(const IOOptions& /*options*/,
+                 IODebugContext* /*dbg*/) override {
+    return status_to_io_status(target_->Flush());
+  }
+  IOStatus Sync(const IOOptions& /*options*/,
+                IODebugContext* /*dbg*/) override {
+    return status_to_io_status(target_->Sync());
+  }
+  IOStatus Fsync(const IOOptions& /*options*/,
+                 IODebugContext* /*dbg*/) override {
+    return status_to_io_status(target_->Fsync());
+  }
+  IOStatus Close(const IOOptions& /*options*/,
+                 IODebugContext* /*dbg*/) override {
+    return status_to_io_status(target_->Close());
+  }
+
+ private:
+  std::unique_ptr<RandomRWFile> target_;
+};
+
+class LegacyDirectoryWrapper : public FSDirectory {
+ public:
+  explicit LegacyDirectoryWrapper(std::unique_ptr<Directory>&& target)
+      : target_(std::move(target)) {}
+
+  IOStatus Fsync(const IOOptions& /*options*/,
+                 IODebugContext* /*dbg*/) override {
+    return status_to_io_status(target_->Fsync());
+  }
+  size_t GetUniqueId(char* id, size_t max_size) const override {
+    return target_->GetUniqueId(id, max_size);
+  }
+
+ private:
+  std::unique_ptr<Directory> target_;
+};
+
+inline std::unique_ptr<FSSequentialFile> NewLegacySequentialFileWrapper(
+    std::unique_ptr<SequentialFile>& file) {
+  return std::unique_ptr<FSSequentialFile>(
+      new LegacySequentialFileWrapper(std::move(file)));
+}
+
+inline std::unique_ptr<FSRandomAccessFile> NewLegacyRandomAccessFileWrapper(
+    std::unique_ptr<RandomAccessFile>& file) {
+  return std::unique_ptr<FSRandomAccessFile>(
+      new LegacyRandomAccessFileWrapper(std::move(file)));
+}
+
+inline std::unique_ptr<FSWritableFile> NewLegacyWritableFileWrapper(
+    std::unique_ptr<WritableFile>&& file) {
+  return std::unique_ptr<FSWritableFile>(
+      new LegacyWritableFileWrapper(std::move(file)));
+}
+
 }  // namespace ROCKSDB_NAMESPACE

env/env.cc

@@ -10,308 +10,17 @@
 #include "rocksdb/env.h"
 
 #include <thread>
-
 #include "env/composite_env_wrapper.h"
 #include "logging/env_logger.h"
 #include "memory/arena.h"
 #include "options/db_options.h"
 #include "port/port.h"
 #include "rocksdb/options.h"
-#include "rocksdb/system_clock.h"
 #include "rocksdb/utilities/object_registry.h"
 #include "util/autovector.h"
 
 namespace ROCKSDB_NAMESPACE {
 namespace {
-class LegacySystemClock : public SystemClock {
- private:
-  Env* env_;
-
- public:
-  explicit LegacySystemClock(Env* env) : env_(env) {}
-  const char* Name() const override { return "Legacy System Clock"; }
-
-  // Returns the number of micro-seconds since some fixed point in time.
-  // It is often used as system time such as in GenericRateLimiter
-  // and other places so a port needs to return system time in order to work.
-  uint64_t NowMicros() override { return env_->NowMicros(); }
-
-  // Returns the number of nano-seconds since some fixed point in time. Only
-  // useful for computing deltas of time in one run.
-  // Default implementation simply relies on NowMicros.
-  // In platform-specific implementations, NowNanos() should return time points
-  // that are MONOTONIC.
-  uint64_t NowNanos() override { return env_->NowNanos(); }
-
-  uint64_t CPUMicros() override { return CPUNanos() / 1000; }
-  uint64_t CPUNanos() override { return env_->NowCPUNanos(); }
-
-  // Sleep/delay the thread for the prescribed number of micro-seconds.
-  void SleepForMicroseconds(int micros) override {
-    env_->SleepForMicroseconds(micros);
-  }
-
-  // Get the number of seconds since the Epoch, 1970-01-01 00:00:00 (UTC).
-  // Only overwrites *unix_time on success.
-  Status GetCurrentTime(int64_t* unix_time) override {
-    return env_->GetCurrentTime(unix_time);
-  }
-  // Converts seconds-since-Jan-01-1970 to a printable string
-  std::string TimeToString(uint64_t time) override {
-    return env_->TimeToString(time);
-  }
-};
-
-class LegacySequentialFileWrapper : public FSSequentialFile {
- public:
-  explicit LegacySequentialFileWrapper(
-      std::unique_ptr<SequentialFile>&& _target)
-      : target_(std::move(_target)) {}
-
-  IOStatus Read(size_t n, const IOOptions& /*options*/, Slice* result,
-                char* scratch, IODebugContext* /*dbg*/) override {
-    return status_to_io_status(target_->Read(n, result, scratch));
-  }
-  IOStatus Skip(uint64_t n) override {
-    return status_to_io_status(target_->Skip(n));
-  }
-  bool use_direct_io() const override { return target_->use_direct_io(); }
-  size_t GetRequiredBufferAlignment() const override {
-    return target_->GetRequiredBufferAlignment();
-  }
-  IOStatus InvalidateCache(size_t offset, size_t length) override {
-    return status_to_io_status(target_->InvalidateCache(offset, length));
-  }
-  IOStatus PositionedRead(uint64_t offset, size_t n,
-                          const IOOptions& /*options*/, Slice* result,
-                          char* scratch, IODebugContext* /*dbg*/) override {
-    return status_to_io_status(
-        target_->PositionedRead(offset, n, result, scratch));
-  }
-
- private:
-  std::unique_ptr<SequentialFile> target_;
-};
-
-class LegacyRandomAccessFileWrapper : public FSRandomAccessFile {
- public:
-  explicit LegacyRandomAccessFileWrapper(
-      std::unique_ptr<RandomAccessFile>&& target)
-      : target_(std::move(target)) {}
-
-  IOStatus Read(uint64_t offset, size_t n, const IOOptions& /*options*/,
-                Slice* result, char* scratch,
-                IODebugContext* /*dbg*/) const override {
-    return status_to_io_status(target_->Read(offset, n, result, scratch));
-  }
-
-  IOStatus MultiRead(FSReadRequest* fs_reqs, size_t num_reqs,
-                     const IOOptions& /*options*/,
-                     IODebugContext* /*dbg*/) override {
-    std::vector<ReadRequest> reqs;
-    Status status;
-
-    reqs.reserve(num_reqs);
-    for (size_t i = 0; i < num_reqs; ++i) {
-      ReadRequest req;
-
-      req.offset = fs_reqs[i].offset;
-      req.len = fs_reqs[i].len;
-      req.scratch = fs_reqs[i].scratch;
-      req.status = Status::OK();
-
-      reqs.emplace_back(req);
-    }
-    status = target_->MultiRead(reqs.data(), num_reqs);
-    for (size_t i = 0; i < num_reqs; ++i) {
-      fs_reqs[i].result = reqs[i].result;
-      fs_reqs[i].status = status_to_io_status(std::move(reqs[i].status));
-    }
-    return status_to_io_status(std::move(status));
-  }
-
-  IOStatus Prefetch(uint64_t offset, size_t n, const IOOptions& /*options*/,
-                    IODebugContext* /*dbg*/) override {
-    return status_to_io_status(target_->Prefetch(offset, n));
-  }
-  size_t GetUniqueId(char* id, size_t max_size) const override {
-    return target_->GetUniqueId(id, max_size);
-  }
-  void Hint(AccessPattern pattern) override {
-    target_->Hint((RandomAccessFile::AccessPattern)pattern);
-  }
-  bool use_direct_io() const override { return target_->use_direct_io(); }
-  size_t GetRequiredBufferAlignment() const override {
-    return target_->GetRequiredBufferAlignment();
-  }
-  IOStatus InvalidateCache(size_t offset, size_t length) override {
-    return status_to_io_status(target_->InvalidateCache(offset, length));
-  }
-
- private:
-  std::unique_ptr<RandomAccessFile> target_;
-};
-
-class LegacyRandomRWFileWrapper : public FSRandomRWFile {
- public:
-  explicit LegacyRandomRWFileWrapper(std::unique_ptr<RandomRWFile>&& target)
-      : target_(std::move(target)) {}
-
-  bool use_direct_io() const override { return target_->use_direct_io(); }
-  size_t GetRequiredBufferAlignment() const override {
-    return target_->GetRequiredBufferAlignment();
-  }
-  IOStatus Write(uint64_t offset, const Slice& data,
-                 const IOOptions& /*options*/,
-                 IODebugContext* /*dbg*/) override {
-    return status_to_io_status(target_->Write(offset, data));
-  }
-  IOStatus Read(uint64_t offset, size_t n, const IOOptions& /*options*/,
-                Slice* result, char* scratch,
-                IODebugContext* /*dbg*/) const override {
-    return status_to_io_status(target_->Read(offset, n, result, scratch));
-  }
-  IOStatus Flush(const IOOptions& /*options*/,
-                 IODebugContext* /*dbg*/) override {
-    return status_to_io_status(target_->Flush());
-  }
-  IOStatus Sync(const IOOptions& /*options*/,
-                IODebugContext* /*dbg*/) override {
-    return status_to_io_status(target_->Sync());
-  }
-  IOStatus Fsync(const IOOptions& /*options*/,
-                 IODebugContext* /*dbg*/) override {
-    return status_to_io_status(target_->Fsync());
-  }
-  IOStatus Close(const IOOptions& /*options*/,
-                 IODebugContext* /*dbg*/) override {
-    return status_to_io_status(target_->Close());
-  }
-
- private:
-  std::unique_ptr<RandomRWFile> target_;
-};
-
-class LegacyWritableFileWrapper : public FSWritableFile {
- public:
-  explicit LegacyWritableFileWrapper(std::unique_ptr<WritableFile>&& _target)
-      : target_(std::move(_target)) {}
-
-  IOStatus Append(const Slice& data, const IOOptions& /*options*/,
-                  IODebugContext* /*dbg*/) override {
-    return status_to_io_status(target_->Append(data));
-  }
-  IOStatus Append(const Slice& data, const IOOptions& /*options*/,
-                  const DataVerificationInfo& /*verification_info*/,
-                  IODebugContext* /*dbg*/) override {
-    return status_to_io_status(target_->Append(data));
-  }
-  IOStatus PositionedAppend(const Slice& data, uint64_t offset,
-                            const IOOptions& /*options*/,
-                            IODebugContext* /*dbg*/) override {
-    return status_to_io_status(target_->PositionedAppend(data, offset));
-  }
-  IOStatus PositionedAppend(const Slice& data, uint64_t offset,
-                            const IOOptions& /*options*/,
-                            const DataVerificationInfo& /*verification_info*/,
-                            IODebugContext* /*dbg*/) override {
-    return status_to_io_status(target_->PositionedAppend(data, offset));
-  }
-  IOStatus Truncate(uint64_t size, const IOOptions& /*options*/,
-                    IODebugContext* /*dbg*/) override {
-    return status_to_io_status(target_->Truncate(size));
-  }
-  IOStatus Close(const IOOptions& /*options*/,
-                 IODebugContext* /*dbg*/) override {
-    return status_to_io_status(target_->Close());
-  }
-  IOStatus Flush(const IOOptions& /*options*/,
-                 IODebugContext* /*dbg*/) override {
-    return status_to_io_status(target_->Flush());
-  }
-  IOStatus Sync(const IOOptions& /*options*/,
-                IODebugContext* /*dbg*/) override {
-    return status_to_io_status(target_->Sync());
-  }
-  IOStatus Fsync(const IOOptions& /*options*/,
-                 IODebugContext* /*dbg*/) override {
-    return status_to_io_status(target_->Fsync());
-  }
-  bool IsSyncThreadSafe() const override { return target_->IsSyncThreadSafe(); }
-
-  bool use_direct_io() const override { return target_->use_direct_io(); }
-
-  size_t GetRequiredBufferAlignment() const override {
-    return target_->GetRequiredBufferAlignment();
-  }
-
-  void SetWriteLifeTimeHint(Env::WriteLifeTimeHint hint) override {
-    target_->SetWriteLifeTimeHint(hint);
-  }
-
-  Env::WriteLifeTimeHint GetWriteLifeTimeHint() override {
-    return target_->GetWriteLifeTimeHint();
-  }
-
-  uint64_t GetFileSize(const IOOptions& /*options*/,
-                       IODebugContext* /*dbg*/) override {
-    return target_->GetFileSize();
-  }
-
-  void SetPreallocationBlockSize(size_t size) override {
-    target_->SetPreallocationBlockSize(size);
-  }
-
-  void GetPreallocationStatus(size_t* block_size,
-                              size_t* last_allocated_block) override {
-    target_->GetPreallocationStatus(block_size, last_allocated_block);
-  }
-
-  size_t GetUniqueId(char* id, size_t max_size) const override {
-    return target_->GetUniqueId(id, max_size);
-  }
-
-  IOStatus InvalidateCache(size_t offset, size_t length) override {
-    return status_to_io_status(target_->InvalidateCache(offset, length));
-  }
-
-  IOStatus RangeSync(uint64_t offset, uint64_t nbytes,
-                     const IOOptions& /*options*/,
-                     IODebugContext* /*dbg*/) override {
-    return status_to_io_status(target_->RangeSync(offset, nbytes));
-  }
-
-  void PrepareWrite(size_t offset, size_t len, const IOOptions& /*options*/,
-                    IODebugContext* /*dbg*/) override {
-    target_->PrepareWrite(offset, len);
-  }
-
-  IOStatus Allocate(uint64_t offset, uint64_t len, const IOOptions& /*options*/,
-                    IODebugContext* /*dbg*/) override {
-    return status_to_io_status(target_->Allocate(offset, len));
-  }
-
- private:
-  std::unique_ptr<WritableFile> target_;
-};
-
-class LegacyDirectoryWrapper : public FSDirectory {
- public:
-  explicit LegacyDirectoryWrapper(std::unique_ptr<Directory>&& target)
-      : target_(std::move(target)) {}
-
-  IOStatus Fsync(const IOOptions& /*options*/,
-                 IODebugContext* /*dbg*/) override {
-    return status_to_io_status(target_->Fsync());
-  }
-  size_t GetUniqueId(char* id, size_t max_size) const override {
-    return target_->GetUniqueId(id, max_size);
-  }
-
- private:
-  std::unique_ptr<Directory> target_;
-};
-
 class LegacyFileSystemWrapper : public FileSystem {
  public:
   // Initialize an EnvWrapper that delegates all calls to *t
@@ -556,17 +265,11 @@ class LegacyFileSystemWrapper : public FileSystem {
 
 Env::Env() : thread_status_updater_(nullptr) {
   file_system_ = std::make_shared<LegacyFileSystemWrapper>(this);
-  system_clock_ = std::make_shared<LegacySystemClock>(this);
 }
 
-Env::Env(const std::shared_ptr<FileSystem>& fs)
-    : thread_status_updater_(nullptr), file_system_(fs) {
-  system_clock_ = std::make_shared<LegacySystemClock>(this);
-}
-
-Env::Env(const std::shared_ptr<FileSystem>& fs,
-         const std::shared_ptr<SystemClock>& clock)
-    : thread_status_updater_(nullptr), file_system_(fs), system_clock_(clock) {}
+Env::Env(std::shared_ptr<FileSystem> fs)
+  : thread_status_updater_(nullptr),
+    file_system_(fs) {}
 
 Env::~Env() {
 }
@@ -1009,26 +712,22 @@ EnvOptions::EnvOptions() {
 
 Status NewEnvLogger(const std::string& fname, Env* env,
                     std::shared_ptr<Logger>* result) {
-  FileOptions options;
+  EnvOptions options;
   // TODO: Tune the buffer size.
   options.writable_file_max_buffer_size = 1024 * 1024;
-  std::unique_ptr<FSWritableFile> writable_file;
-  const auto status = env->GetFileSystem()->NewWritableFile(
-      fname, options, &writable_file, nullptr);
+  std::unique_ptr<WritableFile> writable_file;
+  const auto status = env->NewWritableFile(fname, &writable_file, options);
   if (!status.ok()) {
     return status;
   }
 
-  *result = std::make_shared<EnvLogger>(std::move(writable_file), fname,
-                                        options, env);
+  *result = std::make_shared<EnvLogger>(
+      NewLegacyWritableFileWrapper(std::move(writable_file)), fname, options,
+      env);
   return Status::OK();
 }
 
 const std::shared_ptr<FileSystem>& Env::GetFileSystem() const {
   return file_system_;
 }
-
-const std::shared_ptr<SystemClock>& Env::GetSystemClock() const {
-  return system_clock_;
-}
 }  // namespace ROCKSDB_NAMESPACE

env/env_posix.cc

@@ -56,10 +56,8 @@
 #include "monitoring/iostats_context_imp.h"
 #include "monitoring/thread_status_updater.h"
 #include "port/port.h"
-#include "rocksdb/env.h"
 #include "rocksdb/options.h"
 #include "rocksdb/slice.h"
-#include "rocksdb/system_clock.h"
 #include "test_util/sync_point.h"
 #include "util/coding.h"
 #include "util/compression_context_cache.h"
@@ -124,83 +122,6 @@ class PosixDynamicLibrary : public DynamicLibrary {
 };
 #endif  // !ROCKSDB_NO_DYNAMIC_EXTENSION
 
-class PosixClock : public SystemClock {
- public:
-  const char* Name() const override { return "PosixClock"; }
-  uint64_t NowMicros() override {
-    struct timeval tv;
-    gettimeofday(&tv, nullptr);
-    return static_cast<uint64_t>(tv.tv_sec) * 1000000 + tv.tv_usec;
-  }
-
-  uint64_t NowNanos() override {
-#if defined(OS_LINUX) || defined(OS_FREEBSD) || defined(OS_GNU_KFREEBSD) || \
-    defined(OS_AIX)
-    struct timespec ts;
-    clock_gettime(CLOCK_MONOTONIC, &ts);
-    return static_cast<uint64_t>(ts.tv_sec) * 1000000000 + ts.tv_nsec;
-#elif defined(OS_SOLARIS)
-    return gethrtime();
-#elif defined(__MACH__)
-    clock_serv_t cclock;
-    mach_timespec_t ts;
-    host_get_clock_service(mach_host_self(), CALENDAR_CLOCK, &cclock);
-    clock_get_time(cclock, &ts);
-    mach_port_deallocate(mach_task_self(), cclock);
-    return static_cast<uint64_t>(ts.tv_sec) * 1000000000 + ts.tv_nsec;
-#else
-    return std::chrono::duration_cast<std::chrono::nanoseconds>(
-               std::chrono::steady_clock::now().time_since_epoch())
-        .count();
-#endif
-  }
-
-  uint64_t CPUMicros() override {
-#if defined(OS_LINUX) || defined(OS_FREEBSD) || defined(OS_GNU_KFREEBSD) || \
-    defined(OS_AIX) || (defined(__MACH__) && defined(__MAC_10_12))
-    struct timespec ts;
-    clock_gettime(CLOCK_THREAD_CPUTIME_ID, &ts);
-    return static_cast<uint64_t>(ts.tv_sec) * 1000000000;
-#endif
-    return 0;
-  }
-
-  uint64_t CPUNanos() override {
-#if defined(OS_LINUX) || defined(OS_FREEBSD) || defined(OS_GNU_KFREEBSD) || \
-    defined(OS_AIX) || (defined(__MACH__) && defined(__MAC_10_12))
-    struct timespec ts;
-    clock_gettime(CLOCK_THREAD_CPUTIME_ID, &ts);
-    return static_cast<uint64_t>(ts.tv_sec) * 1000000000 + ts.tv_nsec;
-#endif
-    return 0;
-  }
-
-  void SleepForMicroseconds(int micros) override { usleep(micros); }
-
-  Status GetCurrentTime(int64_t* unix_time) override {
-    time_t ret = time(nullptr);
-    if (ret == (time_t)-1) {
-      return IOError("GetCurrentTime", "", errno);
-    }
-    *unix_time = (int64_t)ret;
-    return Status::OK();
-  }
-
-  std::string TimeToString(uint64_t secondsSince1970) override {
-    const time_t seconds = (time_t)secondsSince1970;
-    struct tm t;
-    int maxsize = 64;
-    std::string dummy;
-    dummy.reserve(maxsize);
-    dummy.resize(maxsize);
-    char* p = &dummy[0];
-    localtime_r(&seconds, &t);
-    snprintf(p, maxsize, "%04d/%02d/%02d-%02d:%02d:%02d ", t.tm_year + 1900,
-             t.tm_mon + 1, t.tm_mday, t.tm_hour, t.tm_min, t.tm_sec);
-    return dummy;
-  }
-};
-
 class PosixEnv : public CompositeEnv {
  public:
   PosixEnv(const PosixEnv* default_env, const std::shared_ptr<FileSystem>& fs);
@@ -311,6 +232,45 @@ class PosixEnv : public CompositeEnv {
 
   uint64_t GetThreadID() const override { return gettid(pthread_self()); }
 
+  uint64_t NowMicros() override {
+    struct timeval tv;
+    gettimeofday(&tv, nullptr);
+    return static_cast<uint64_t>(tv.tv_sec) * 1000000 + tv.tv_usec;
+  }
+
+  uint64_t NowNanos() override {
+#if defined(OS_LINUX) || defined(OS_FREEBSD) || defined(OS_GNU_KFREEBSD) || \
+    defined(OS_AIX)
+    struct timespec ts;
+    clock_gettime(CLOCK_MONOTONIC, &ts);
+    return static_cast<uint64_t>(ts.tv_sec) * 1000000000 + ts.tv_nsec;
+#elif defined(OS_SOLARIS)
+    return gethrtime();
+#elif defined(__MACH__)
+    clock_serv_t cclock;
+    mach_timespec_t ts;
+    host_get_clock_service(mach_host_self(), CALENDAR_CLOCK, &cclock);
+    clock_get_time(cclock, &ts);
+    mach_port_deallocate(mach_task_self(), cclock);
+    return static_cast<uint64_t>(ts.tv_sec) * 1000000000 + ts.tv_nsec;
+#else
+    return std::chrono::duration_cast<std::chrono::nanoseconds>(
+       std::chrono::steady_clock::now().time_since_epoch()).count();
+#endif
+  }
+
+  uint64_t NowCPUNanos() override {
+#if defined(OS_LINUX) || defined(OS_FREEBSD) || defined(OS_GNU_KFREEBSD) || \
+    defined(OS_AIX) || (defined(__MACH__) && defined(__MAC_10_12))
+    struct timespec ts;
+    clock_gettime(CLOCK_THREAD_CPUTIME_ID, &ts);
+    return static_cast<uint64_t>(ts.tv_sec) * 1000000000 + ts.tv_nsec;
+#endif
+    return 0;
+  }
+
+  void SleepForMicroseconds(int micros) override { usleep(micros); }
+
   Status GetHostName(char* name, uint64_t len) override {
     int ret = gethostname(name, static_cast<size_t>(len));
     if (ret < 0) {
@@ -323,6 +283,15 @@ class PosixEnv : public CompositeEnv {
     return Status::OK();
   }
 
+  Status GetCurrentTime(int64_t* unix_time) override {
+    time_t ret = time(nullptr);
+    if (ret == (time_t) -1) {
+      return IOError("GetCurrentTime", "", errno);
+    }
+    *unix_time = (int64_t) ret;
+    return Status::OK();
+  }
+
   ThreadStatusUpdater* GetThreadStatusUpdater() const override {
     return Env::GetThreadStatusUpdater();
   }
@@ -371,6 +340,26 @@ class PosixEnv : public CompositeEnv {
     return Status::OK();
   }
 
+  std::string TimeToString(uint64_t secondsSince1970) override {
+    const time_t seconds = (time_t)secondsSince1970;
+    struct tm t;
+    int maxsize = 64;
+    std::string dummy;
+    dummy.reserve(maxsize);
+    dummy.resize(maxsize);
+    char* p = &dummy[0];
+    localtime_r(&seconds, &t);
+    snprintf(p, maxsize,
+             "%04d/%02d/%02d-%02d:%02d:%02d ",
+             t.tm_year + 1900,
+             t.tm_mon + 1,
+             t.tm_mday,
+             t.tm_hour,
+             t.tm_min,
+             t.tm_sec);
+    return dummy;
+  }
+
  private:
   friend Env* Env::Default();
   // Constructs the default Env, a singleton
@@ -393,7 +382,7 @@ class PosixEnv : public CompositeEnv {
 };
 
 PosixEnv::PosixEnv()
-    : CompositeEnv(FileSystem::Default(), SystemClock::Default()),
+    : CompositeEnv(FileSystem::Default()),
       thread_pools_storage_(Priority::TOTAL),
       allow_non_owner_access_storage_(true),
       thread_pools_(thread_pools_storage_),
@@ -412,7 +401,7 @@ PosixEnv::PosixEnv()
 
 PosixEnv::PosixEnv(const PosixEnv* default_env,
                    const std::shared_ptr<FileSystem>& fs)
-    : CompositeEnv(fs, default_env->GetSystemClock()),
+    : CompositeEnv(fs),
       thread_pools_(default_env->thread_pools_),
       mu_(default_env->mu_),
       threads_to_join_(default_env->threads_to_join_),
@@ -520,14 +509,6 @@ std::unique_ptr<Env> NewCompositeEnv(const std::shared_ptr<FileSystem>& fs) {
   return std::unique_ptr<Env>(new PosixEnv(default_env, fs));
 }
 
-//
-// Default Posix SystemClock
-//
-const std::shared_ptr<SystemClock>& SystemClock::Default() {
-  static std::shared_ptr<SystemClock> default_clock =
-      std::make_shared<PosixClock>();
-  return default_clock;
-}
 }  // namespace ROCKSDB_NAMESPACE
 
 #endif

env/env_test.cc

@@ -35,7 +35,6 @@
 #include "port/malloc.h"
 #include "port/port.h"
 #include "rocksdb/env.h"
-#include "rocksdb/system_clock.h"
 #include "test_util/sync_point.h"
 #include "test_util/testharness.h"
 #include "test_util/testutil.h"
@@ -2214,8 +2213,7 @@ TEST_F(EnvTest, IsDirectory) {
     ASSERT_OK(s);
     std::unique_ptr<WritableFileWriter> fwriter;
     fwriter.reset(new WritableFileWriter(std::move(wfile), test_file_path,
-                                         FileOptions(),
-                                         SystemClock::Default()));
+                                         FileOptions(), Env::Default()));
     constexpr char buf[] = "test";
     s = fwriter->Append(buf);
     ASSERT_OK(s);

env/file_system_tracer.cc

@@ -5,19 +5,18 @@
 
 #include "env/file_system_tracer.h"
 
-#include "rocksdb/file_system.h"
-#include "rocksdb/system_clock.h"
+#include "rocksdb/env.h"
 
 namespace ROCKSDB_NAMESPACE {
 
 IOStatus FileSystemTracingWrapper::NewSequentialFile(
     const std::string& fname, const FileOptions& file_opts,
     std::unique_ptr<FSSequentialFile>* result, IODebugContext* dbg) {
-  StopWatchNano timer(clock_);
+  StopWatchNano timer(env_);
   timer.Start();
   IOStatus s = target()->NewSequentialFile(fname, file_opts, result, dbg);
   uint64_t elapsed = timer.ElapsedNanos();
-  IOTraceRecord io_record(clock_->NowNanos(), TraceType::kIOTracer,
+  IOTraceRecord io_record(env_->NowNanos(), TraceType::kIOTracer,
                           0 /*io_op_data*/, __func__, elapsed, s.ToString(),
                           fname.substr(fname.find_last_of("/\\") + 1));
   io_tracer_->WriteIOOp(io_record);
@@ -27,11 +26,11 @@ IOStatus FileSystemTracingWrapper::NewSequentialFile(
 IOStatus FileSystemTracingWrapper::NewRandomAccessFile(
     const std::string& fname, const FileOptions& file_opts,
     std::unique_ptr<FSRandomAccessFile>* result, IODebugContext* dbg) {
-  StopWatchNano timer(clock_);
+  StopWatchNano timer(env_);
   timer.Start();
   IOStatus s = target()->NewRandomAccessFile(fname, file_opts, result, dbg);
   uint64_t elapsed = timer.ElapsedNanos();
-  IOTraceRecord io_record(clock_->NowNanos(), TraceType::kIOTracer,
+  IOTraceRecord io_record(env_->NowNanos(), TraceType::kIOTracer,
                           0 /*io_op_data*/, __func__, elapsed, s.ToString(),
                           fname.substr(fname.find_last_of("/\\") + 1));
   io_tracer_->WriteIOOp(io_record);
@@ -41,11 +40,11 @@ IOStatus FileSystemTracingWrapper::NewRandomAccessFile(
 IOStatus FileSystemTracingWrapper::NewWritableFile(
     const std::string& fname, const FileOptions& file_opts,
     std::unique_ptr<FSWritableFile>* result, IODebugContext* dbg) {
-  StopWatchNano timer(clock_);
+  StopWatchNano timer(env_);
   timer.Start();
   IOStatus s = target()->NewWritableFile(fname, file_opts, result, dbg);
   uint64_t elapsed = timer.ElapsedNanos();
-  IOTraceRecord io_record(clock_->NowNanos(), TraceType::kIOTracer,
+  IOTraceRecord io_record(env_->NowNanos(), TraceType::kIOTracer,
                           0 /*io_op_data*/, __func__, elapsed, s.ToString(),
                           fname.substr(fname.find_last_of("/\\") + 1));
   io_tracer_->WriteIOOp(io_record);
@@ -55,11 +54,11 @@ IOStatus FileSystemTracingWrapper::NewWritableFile(
 IOStatus FileSystemTracingWrapper::ReopenWritableFile(
     const std::string& fname, const FileOptions& file_opts,
     std::unique_ptr<FSWritableFile>* result, IODebugContext* dbg) {
-  StopWatchNano timer(clock_);
+  StopWatchNano timer(env_);
   timer.Start();
   IOStatus s = target()->ReopenWritableFile(fname, file_opts, result, dbg);
   uint64_t elapsed = timer.ElapsedNanos();
-  IOTraceRecord io_record(clock_->NowNanos(), TraceType::kIOTracer,
+  IOTraceRecord io_record(env_->NowNanos(), TraceType::kIOTracer,
                           0 /*io_op_data*/, __func__, elapsed, s.ToString(),
                           fname.substr(fname.find_last_of("/\\") + 1));
   io_tracer_->WriteIOOp(io_record);
@@ -70,12 +69,12 @@ IOStatus FileSystemTracingWrapper::ReuseWritableFile(
     const std::string& fname, const std::string& old_fname,
     const FileOptions& file_opts, std::unique_ptr<FSWritableFile>* result,
     IODebugContext* dbg) {
-  StopWatchNano timer(clock_);
+  StopWatchNano timer(env_);
   timer.Start();
   IOStatus s =
       target()->ReuseWritableFile(fname, old_fname, file_opts, result, dbg);
   uint64_t elapsed = timer.ElapsedNanos();
-  IOTraceRecord io_record(clock_->NowNanos(), TraceType::kIOTracer,
+  IOTraceRecord io_record(env_->NowNanos(), TraceType::kIOTracer,
                           0 /*io_op_data*/, __func__, elapsed, s.ToString(),
                           fname.substr(fname.find_last_of("/\\") + 1));
   io_tracer_->WriteIOOp(io_record);
@@ -85,11 +84,11 @@ IOStatus FileSystemTracingWrapper::ReuseWritableFile(
 IOStatus FileSystemTracingWrapper::NewRandomRWFile(
     const std::string& fname, const FileOptions& file_opts,
     std::unique_ptr<FSRandomRWFile>* result, IODebugContext* dbg) {
-  StopWatchNano timer(clock_);
+  StopWatchNano timer(env_);
   timer.Start();
   IOStatus s = target()->NewRandomRWFile(fname, file_opts, result, dbg);
   uint64_t elapsed = timer.ElapsedNanos();
-  IOTraceRecord io_record(clock_->NowNanos(), TraceType::kIOTracer,
+  IOTraceRecord io_record(env_->NowNanos(), TraceType::kIOTracer,
                           0 /*io_op_data*/, __func__, elapsed, s.ToString(),
                           fname.substr(fname.find_last_of("/\\") + 1));
   io_tracer_->WriteIOOp(io_record);
@@ -99,11 +98,11 @@ IOStatus FileSystemTracingWrapper::NewRandomRWFile(
 IOStatus FileSystemTracingWrapper::NewDirectory(
     const std::string& name, const IOOptions& io_opts,
     std::unique_ptr<FSDirectory>* result, IODebugContext* dbg) {
-  StopWatchNano timer(clock_);
+  StopWatchNano timer(env_);
   timer.Start();
   IOStatus s = target()->NewDirectory(name, io_opts, result, dbg);
   uint64_t elapsed = timer.ElapsedNanos();
-  IOTraceRecord io_record(clock_->NowNanos(), TraceType::kIOTracer,
+  IOTraceRecord io_record(env_->NowNanos(), TraceType::kIOTracer,
                           0 /*io_op_data*/, __func__, elapsed, s.ToString(),
                           name.substr(name.find_last_of("/\\") + 1));
   io_tracer_->WriteIOOp(io_record);
@@ -114,11 +113,11 @@ IOStatus FileSystemTracingWrapper::GetChildren(const std::string& dir,
                                                const IOOptions& io_opts,
                                                std::vector<std::string>* r,
                                                IODebugContext* dbg) {
-  StopWatchNano timer(clock_);
+  StopWatchNano timer(env_);
   timer.Start();
   IOStatus s = target()->GetChildren(dir, io_opts, r, dbg);
   uint64_t elapsed = timer.ElapsedNanos();
-  IOTraceRecord io_record(clock_->NowNanos(), TraceType::kIOTracer,
+  IOTraceRecord io_record(env_->NowNanos(), TraceType::kIOTracer,
                           0 /*io_op_data*/, __func__, elapsed, s.ToString(),
                           dir.substr(dir.find_last_of("/\\") + 1));
   io_tracer_->WriteIOOp(io_record);
@@ -128,11 +127,11 @@ IOStatus FileSystemTracingWrapper::GetChildren(const std::string& dir,
 IOStatus FileSystemTracingWrapper::DeleteFile(const std::string& fname,
                                               const IOOptions& options,
                                               IODebugContext* dbg) {
-  StopWatchNano timer(clock_);
+  StopWatchNano timer(env_);
   timer.Start();
   IOStatus s = target()->DeleteFile(fname, options, dbg);
   uint64_t elapsed = timer.ElapsedNanos();
-  IOTraceRecord io_record(clock_->NowNanos(), TraceType::kIOTracer,
+  IOTraceRecord io_record(env_->NowNanos(), TraceType::kIOTracer,
                           0 /*io_op_data*/, __func__, elapsed, s.ToString(),
                           fname.substr(fname.find_last_of("/\\") + 1));
   io_tracer_->WriteIOOp(io_record);
@@ -142,11 +141,11 @@ IOStatus FileSystemTracingWrapper::DeleteFile(const std::string& fname,
 IOStatus FileSystemTracingWrapper::CreateDir(const std::string& dirname,
                                              const IOOptions& options,
                                              IODebugContext* dbg) {
-  StopWatchNano timer(clock_);
+  StopWatchNano timer(env_);
   timer.Start();
   IOStatus s = target()->CreateDir(dirname, options, dbg);
   uint64_t elapsed = timer.ElapsedNanos();
-  IOTraceRecord io_record(clock_->NowNanos(), TraceType::kIOTracer,
+  IOTraceRecord io_record(env_->NowNanos(), TraceType::kIOTracer,
                           0 /*io_op_data*/, __func__, elapsed, s.ToString(),
                           dirname.substr(dirname.find_last_of("/\\") + 1));
   io_tracer_->WriteIOOp(io_record);
@@ -155,11 +154,11 @@ IOStatus FileSystemTracingWrapper::CreateDir(const std::string& dirname,
 
 IOStatus FileSystemTracingWrapper::CreateDirIfMissing(
     const std::string& dirname, const IOOptions& options, IODebugContext* dbg) {
-  StopWatchNano timer(clock_);
+  StopWatchNano timer(env_);
   timer.Start();
   IOStatus s = target()->CreateDirIfMissing(dirname, options, dbg);
   uint64_t elapsed = timer.ElapsedNanos();
-  IOTraceRecord io_record(clock_->NowNanos(), TraceType::kIOTracer,
+  IOTraceRecord io_record(env_->NowNanos(), TraceType::kIOTracer,
                           0 /*io_op_data*/, __func__, elapsed, s.ToString(),
                           dirname.substr(dirname.find_last_of("/\\") + 1));
   io_tracer_->WriteIOOp(io_record);
@@ -169,11 +168,11 @@ IOStatus FileSystemTracingWrapper::CreateDirIfMissing(
 IOStatus FileSystemTracingWrapper::DeleteDir(const std::string& dirname,
                                              const IOOptions& options,
                                              IODebugContext* dbg) {
-  StopWatchNano timer(clock_);
+  StopWatchNano timer(env_);
   timer.Start();
   IOStatus s = target()->DeleteDir(dirname, options, dbg);
   uint64_t elapsed = timer.ElapsedNanos();
-  IOTraceRecord io_record(clock_->NowNanos(), TraceType::kIOTracer,
+  IOTraceRecord io_record(env_->NowNanos(), TraceType::kIOTracer,
                           0 /*io_op_data*/, __func__, elapsed, s.ToString(),
                           dirname.substr(dirname.find_last_of("/\\") + 1));
   io_tracer_->WriteIOOp(io_record);
@@ -184,14 +183,14 @@ IOStatus FileSystemTracingWrapper::GetFileSize(const std::string& fname,
                                                const IOOptions& options,
                                                uint64_t* file_size,
                                                IODebugContext* dbg) {
-  StopWatchNano timer(clock_);
+  StopWatchNano timer(env_);
   timer.Start();
   IOStatus s = target()->GetFileSize(fname, options, file_size, dbg);
   uint64_t elapsed = timer.ElapsedNanos();
   uint64_t io_op_data = 0;
   io_op_data |= (1 << IOTraceOp::kIOFileSize);
   IOTraceRecord io_record(
-      clock_->NowNanos(), TraceType::kIOTracer, io_op_data, __func__, elapsed,
+      env_->NowNanos(), TraceType::kIOTracer, io_op_data, __func__, elapsed,
       s.ToString(), fname.substr(fname.find_last_of("/\\") + 1), *file_size);
   io_tracer_->WriteIOOp(io_record);
   return s;
@@ -201,13 +200,13 @@ IOStatus FileSystemTracingWrapper::Truncate(const std::string& fname,
                                             size_t size,
                                             const IOOptions& options,
                                             IODebugContext* dbg) {
-  StopWatchNano timer(clock_);
+  StopWatchNano timer(env_);
   timer.Start();
   IOStatus s = target()->Truncate(fname, size, options, dbg);
   uint64_t elapsed = timer.ElapsedNanos();
   uint64_t io_op_data = 0;
   io_op_data |= (1 << IOTraceOp::kIOFileSize);
-  IOTraceRecord io_record(clock_->NowNanos(), TraceType::kIOTracer, io_op_data,
+  IOTraceRecord io_record(env_->NowNanos(), TraceType::kIOTracer, io_op_data,
                           __func__, elapsed, s.ToString(),
                           fname.substr(fname.find_last_of("/\\") + 1), size);
   io_tracer_->WriteIOOp(io_record);
@@ -218,13 +217,13 @@ IOStatus FSSequentialFileTracingWrapper::Read(size_t n,
                                               const IOOptions& options,
                                               Slice* result, char* scratch,
                                               IODebugContext* dbg) {
-  StopWatchNano timer(clock_);
+  StopWatchNano timer(env_);
   timer.Start();
   IOStatus s = target()->Read(n, options, result, scratch, dbg);
   uint64_t elapsed = timer.ElapsedNanos();
   uint64_t io_op_data = 0;
   io_op_data |= (1 << IOTraceOp::kIOLen);
-  IOTraceRecord io_record(clock_->NowNanos(), TraceType::kIOTracer, io_op_data,
+  IOTraceRecord io_record(env_->NowNanos(), TraceType::kIOTracer, io_op_data,
                           __func__, elapsed, s.ToString(), file_name_,
                           result->size(), 0 /*Offset*/);
   io_tracer_->WriteIOOp(io_record);
@@ -233,14 +232,14 @@ IOStatus FSSequentialFileTracingWrapper::Read(size_t n,
 
 IOStatus FSSequentialFileTracingWrapper::InvalidateCache(size_t offset,
                                                          size_t length) {
-  StopWatchNano timer(clock_);
+  StopWatchNano timer(env_);
   timer.Start();
   IOStatus s = target()->InvalidateCache(offset, length);
   uint64_t elapsed = timer.ElapsedNanos();
   uint64_t io_op_data = 0;
   io_op_data |= (1 << IOTraceOp::kIOLen);
   io_op_data |= (1 << IOTraceOp::kIOOffset);
-  IOTraceRecord io_record(clock_->NowNanos(), TraceType::kIOTracer, io_op_data,
+  IOTraceRecord io_record(env_->NowNanos(), TraceType::kIOTracer, io_op_data,
                           __func__, elapsed, s.ToString(), file_name_, length,
                           offset);
   io_tracer_->WriteIOOp(io_record);
@@ -250,7 +249,7 @@ IOStatus FSSequentialFileTracingWrapper::InvalidateCache(size_t offset,
 IOStatus FSSequentialFileTracingWrapper::PositionedRead(
     uint64_t offset, size_t n, const IOOptions& options, Slice* result,
     char* scratch, IODebugContext* dbg) {
-  StopWatchNano timer(clock_);
+  StopWatchNano timer(env_);
   timer.Start();
   IOStatus s =
       target()->PositionedRead(offset, n, options, result, scratch, dbg);
@@ -258,7 +257,7 @@ IOStatus FSSequentialFileTracingWrapper::PositionedRead(
   uint64_t io_op_data = 0;
   io_op_data |= (1 << IOTraceOp::kIOLen);
   io_op_data |= (1 << IOTraceOp::kIOOffset);
-  IOTraceRecord io_record(clock_->NowNanos(), TraceType::kIOTracer, io_op_data,
+  IOTraceRecord io_record(env_->NowNanos(), TraceType::kIOTracer, io_op_data,
                           __func__, elapsed, s.ToString(), file_name_,
                           result->size(), offset);
   io_tracer_->WriteIOOp(io_record);
@@ -269,14 +268,14 @@ IOStatus FSRandomAccessFileTracingWrapper::Read(uint64_t offset, size_t n,
                                                 const IOOptions& options,
                                                 Slice* result, char* scratch,
                                                 IODebugContext* dbg) const {
-  StopWatchNano timer(clock_);
+  StopWatchNano timer(env_);
   timer.Start();
   IOStatus s = target()->Read(offset, n, options, result, scratch, dbg);
   uint64_t elapsed = timer.ElapsedNanos();
   uint64_t io_op_data = 0;
   io_op_data |= (1 << IOTraceOp::kIOLen);
   io_op_data |= (1 << IOTraceOp::kIOOffset);
-  IOTraceRecord io_record(clock_->NowNanos(), TraceType::kIOTracer, io_op_data,
+  IOTraceRecord io_record(env_->NowNanos(), TraceType::kIOTracer, io_op_data,
                           __func__, elapsed, s.ToString(), file_name_, n,
                           offset);
   io_tracer_->WriteIOOp(io_record);
@@ -287,7 +286,7 @@ IOStatus FSRandomAccessFileTracingWrapper::MultiRead(FSReadRequest* reqs,
                                                      size_t num_reqs,
                                                      const IOOptions& options,
                                                      IODebugContext* dbg) {
-  StopWatchNano timer(clock_);
+  StopWatchNano timer(env_);
   timer.Start();
   IOStatus s = target()->MultiRead(reqs, num_reqs, options, dbg);
   uint64_t elapsed = timer.ElapsedNanos();
@@ -296,9 +295,9 @@ IOStatus FSRandomAccessFileTracingWrapper::MultiRead(FSReadRequest* reqs,
   io_op_data |= (1 << IOTraceOp::kIOLen);
   io_op_data |= (1 << IOTraceOp::kIOOffset);
   for (size_t i = 0; i < num_reqs; i++) {
-    IOTraceRecord io_record(
-        clock_->NowNanos(), TraceType::kIOTracer, io_op_data, __func__, latency,
-        reqs[i].status.ToString(), file_name_, reqs[i].len, reqs[i].offset);
+    IOTraceRecord io_record(env_->NowNanos(), TraceType::kIOTracer, io_op_data,
+                            __func__, latency, reqs[i].status.ToString(),
+                            file_name_, reqs[i].len, reqs[i].offset);
     io_tracer_->WriteIOOp(io_record);
   }
   return s;
@@ -307,14 +306,14 @@ IOStatus FSRandomAccessFileTracingWrapper::MultiRead(FSReadRequest* reqs,
 IOStatus FSRandomAccessFileTracingWrapper::Prefetch(uint64_t offset, size_t n,
                                                     const IOOptions& options,
                                                     IODebugContext* dbg) {
-  StopWatchNano timer(clock_);
+  StopWatchNano timer(env_);
   timer.Start();
   IOStatus s = target()->Prefetch(offset, n, options, dbg);
   uint64_t elapsed = timer.ElapsedNanos();
   uint64_t io_op_data = 0;
   io_op_data |= (1 << IOTraceOp::kIOLen);
   io_op_data |= (1 << IOTraceOp::kIOOffset);
-  IOTraceRecord io_record(clock_->NowNanos(), TraceType::kIOTracer, io_op_data,
+  IOTraceRecord io_record(env_->NowNanos(), TraceType::kIOTracer, io_op_data,
                           __func__, elapsed, s.ToString(), file_name_, n,
                           offset);
   io_tracer_->WriteIOOp(io_record);
@@ -323,14 +322,14 @@ IOStatus FSRandomAccessFileTracingWrapper::Prefetch(uint64_t offset, size_t n,
 
 IOStatus FSRandomAccessFileTracingWrapper::InvalidateCache(size_t offset,
                                                            size_t length) {
-  StopWatchNano timer(clock_);
+  StopWatchNano timer(env_);
   timer.Start();
   IOStatus s = target()->InvalidateCache(offset, length);
   uint64_t elapsed = timer.ElapsedNanos();
   uint64_t io_op_data = 0;
   io_op_data |= (1 << IOTraceOp::kIOLen);
   io_op_data |= (1 << IOTraceOp::kIOOffset);
-  IOTraceRecord io_record(clock_->NowNanos(), TraceType::kIOTracer, io_op_data,
+  IOTraceRecord io_record(env_->NowNanos(), TraceType::kIOTracer, io_op_data,
                           __func__, elapsed, s.ToString(), file_name_, length,
                           static_cast<uint64_t>(offset));
   io_tracer_->WriteIOOp(io_record);
@@ -340,13 +339,13 @@ IOStatus FSRandomAccessFileTracingWrapper::InvalidateCache(size_t offset,
 IOStatus FSWritableFileTracingWrapper::Append(const Slice& data,
                                               const IOOptions& options,
                                               IODebugContext* dbg) {
-  StopWatchNano timer(clock_);
+  StopWatchNano timer(env_);
   timer.Start();
   IOStatus s = target()->Append(data, options, dbg);
   uint64_t elapsed = timer.ElapsedNanos();
   uint64_t io_op_data = 0;
   io_op_data |= (1 << IOTraceOp::kIOLen);
-  IOTraceRecord io_record(clock_->NowNanos(), TraceType::kIOTracer, io_op_data,
+  IOTraceRecord io_record(env_->NowNanos(), TraceType::kIOTracer, io_op_data,
                           __func__, elapsed, s.ToString(), file_name_,
                           data.size(), 0 /*Offset*/);
   io_tracer_->WriteIOOp(io_record);
@@ -356,14 +355,14 @@ IOStatus FSWritableFileTracingWrapper::Append(const Slice& data,
 IOStatus FSWritableFileTracingWrapper::PositionedAppend(
     const Slice& data, uint64_t offset, const IOOptions& options,
     IODebugContext* dbg) {
-  StopWatchNano timer(clock_);
+  StopWatchNano timer(env_);
   timer.Start();
   IOStatus s = target()->PositionedAppend(data, offset, options, dbg);
   uint64_t elapsed = timer.ElapsedNanos();
   uint64_t io_op_data = 0;
   io_op_data |= (1 << IOTraceOp::kIOLen);
   io_op_data |= (1 << IOTraceOp::kIOOffset);
-  IOTraceRecord io_record(clock_->NowNanos(), TraceType::kIOTracer, io_op_data,
+  IOTraceRecord io_record(env_->NowNanos(), TraceType::kIOTracer, io_op_data,
                           __func__, elapsed, s.ToString(), file_name_,
                           data.size(), offset);
   io_tracer_->WriteIOOp(io_record);
@@ -373,13 +372,13 @@ IOStatus FSWritableFileTracingWrapper::PositionedAppend(
 IOStatus FSWritableFileTracingWrapper::Truncate(uint64_t size,
                                                 const IOOptions& options,
                                                 IODebugContext* dbg) {
-  StopWatchNano timer(clock_);
+  StopWatchNano timer(env_);
   timer.Start();
   IOStatus s = target()->Truncate(size, options, dbg);
   uint64_t elapsed = timer.ElapsedNanos();
   uint64_t io_op_data = 0;
   io_op_data |= (1 << IOTraceOp::kIOLen);
-  IOTraceRecord io_record(clock_->NowNanos(), TraceType::kIOTracer, io_op_data,
+  IOTraceRecord io_record(env_->NowNanos(), TraceType::kIOTracer, io_op_data,
                           __func__, elapsed, s.ToString(), file_name_, size,
                           0 /*Offset*/);
   io_tracer_->WriteIOOp(io_record);
@@ -388,11 +387,11 @@ IOStatus FSWritableFileTracingWrapper::Truncate(uint64_t size,
 
 IOStatus FSWritableFileTracingWrapper::Close(const IOOptions& options,
                                              IODebugContext* dbg) {
-  StopWatchNano timer(clock_);
+  StopWatchNano timer(env_);
   timer.Start();
   IOStatus s = target()->Close(options, dbg);
   uint64_t elapsed = timer.ElapsedNanos();
-  IOTraceRecord io_record(clock_->NowNanos(), TraceType::kIOTracer,
+  IOTraceRecord io_record(env_->NowNanos(), TraceType::kIOTracer,
                           0 /*io_op_data*/, __func__, elapsed, s.ToString(),
                           file_name_);
   io_tracer_->WriteIOOp(io_record);
@@ -401,13 +400,13 @@ IOStatus FSWritableFileTracingWrapper::Close(const IOOptions& options,
 
 uint64_t FSWritableFileTracingWrapper::GetFileSize(const IOOptions& options,
                                                    IODebugContext* dbg) {
-  StopWatchNano timer(clock_);
+  StopWatchNano timer(env_);
   timer.Start();
   uint64_t file_size = target()->GetFileSize(options, dbg);
   uint64_t elapsed = timer.ElapsedNanos();
   uint64_t io_op_data = 0;
   io_op_data |= (1 << IOTraceOp::kIOFileSize);
-  IOTraceRecord io_record(clock_->NowNanos(), TraceType::kIOTracer, io_op_data,
+  IOTraceRecord io_record(env_->NowNanos(), TraceType::kIOTracer, io_op_data,
                           __func__, elapsed, "OK", file_name_, file_size);
   io_tracer_->WriteIOOp(io_record);
   return file_size;
@@ -415,14 +414,14 @@ uint64_t FSWritableFileTracingWrapper::GetFileSize(const IOOptions& options,
 
 IOStatus FSWritableFileTracingWrapper::InvalidateCache(size_t offset,
                                                        size_t length) {
-  StopWatchNano timer(clock_);
+  StopWatchNano timer(env_);
   timer.Start();
   IOStatus s = target()->InvalidateCache(offset, length);
   uint64_t elapsed = timer.ElapsedNanos();
   uint64_t io_op_data = 0;
   io_op_data |= (1 << IOTraceOp::kIOLen);
   io_op_data |= (1 << IOTraceOp::kIOOffset);
-  IOTraceRecord io_record(clock_->NowNanos(), TraceType::kIOTracer, io_op_data,
+  IOTraceRecord io_record(env_->NowNanos(), TraceType::kIOTracer, io_op_data,
                           __func__, elapsed, s.ToString(), file_name_, length,
                           static_cast<uint64_t>(offset));
   io_tracer_->WriteIOOp(io_record);
@@ -432,14 +431,14 @@ IOStatus FSWritableFileTracingWrapper::InvalidateCache(size_t offset,
 IOStatus FSRandomRWFileTracingWrapper::Write(uint64_t offset, const Slice& data,
                                              const IOOptions& options,
                                              IODebugContext* dbg) {
-  StopWatchNano timer(clock_);
+  StopWatchNano timer(env_);
   timer.Start();
   IOStatus s = target()->Write(offset, data, options, dbg);
   uint64_t elapsed = timer.ElapsedNanos();
   uint64_t io_op_data = 0;
   io_op_data |= (1 << IOTraceOp::kIOLen);
   io_op_data |= (1 << IOTraceOp::kIOOffset);
-  IOTraceRecord io_record(clock_->NowNanos(), TraceType::kIOTracer, io_op_data,
+  IOTraceRecord io_record(env_->NowNanos(), TraceType::kIOTracer, io_op_data,
                           __func__, elapsed, s.ToString(), file_name_,
                           data.size(), offset);
   io_tracer_->WriteIOOp(io_record);
@@ -450,14 +449,14 @@ IOStatus FSRandomRWFileTracingWrapper::Read(uint64_t offset, size_t n,
                                             const IOOptions& options,
                                             Slice* result, char* scratch,
                                             IODebugContext* dbg) const {
-  StopWatchNano timer(clock_);
+  StopWatchNano timer(env_);
   timer.Start();
   IOStatus s = target()->Read(offset, n, options, result, scratch, dbg);
   uint64_t elapsed = timer.ElapsedNanos();
   uint64_t io_op_data = 0;
   io_op_data |= (1 << IOTraceOp::kIOLen);
   io_op_data |= (1 << IOTraceOp::kIOOffset);
-  IOTraceRecord io_record(clock_->NowNanos(), TraceType::kIOTracer, io_op_data,
+  IOTraceRecord io_record(env_->NowNanos(), TraceType::kIOTracer, io_op_data,
                           __func__, elapsed, s.ToString(), file_name_, n,
                           offset);
   io_tracer_->WriteIOOp(io_record);
@@ -466,11 +465,11 @@ IOStatus FSRandomRWFileTracingWrapper::Read(uint64_t offset, size_t n,
 
 IOStatus FSRandomRWFileTracingWrapper::Flush(const IOOptions& options,
                                              IODebugContext* dbg) {
-  StopWatchNano timer(clock_);
+  StopWatchNano timer(env_);
   timer.Start();
   IOStatus s = target()->Flush(options, dbg);
   uint64_t elapsed = timer.ElapsedNanos();
-  IOTraceRecord io_record(clock_->NowNanos(), TraceType::kIOTracer,
+  IOTraceRecord io_record(env_->NowNanos(), TraceType::kIOTracer,
                           0 /*io_op_data*/, __func__, elapsed, s.ToString(),
                           file_name_);
   io_tracer_->WriteIOOp(io_record);
@@ -479,11 +478,11 @@ IOStatus FSRandomRWFileTracingWrapper::Flush(const IOOptions& options,
 
 IOStatus FSRandomRWFileTracingWrapper::Close(const IOOptions& options,
                                              IODebugContext* dbg) {
-  StopWatchNano timer(clock_);
+  StopWatchNano timer(env_);
   timer.Start();
   IOStatus s = target()->Close(options, dbg);
   uint64_t elapsed = timer.ElapsedNanos();
-  IOTraceRecord io_record(clock_->NowNanos(), TraceType::kIOTracer,
+  IOTraceRecord io_record(env_->NowNanos(), TraceType::kIOTracer,
                           0 /*io_op_data*/, __func__, elapsed, s.ToString(),
                           file_name_);
   io_tracer_->WriteIOOp(io_record);
@@ -492,11 +491,11 @@ IOStatus FSRandomRWFileTracingWrapper::Close(const IOOptions& options,
 
 IOStatus FSRandomRWFileTracingWrapper::Sync(const IOOptions& options,
                                             IODebugContext* dbg) {
-  StopWatchNano timer(clock_);
+  StopWatchNano timer(env_);
   timer.Start();
   IOStatus s = target()->Sync(options, dbg);
   uint64_t elapsed = timer.ElapsedNanos();
-  IOTraceRecord io_record(clock_->NowNanos(), TraceType::kIOTracer,
+  IOTraceRecord io_record(env_->NowNanos(), TraceType::kIOTracer,
                           0 /*io_op_data*/, __func__, elapsed, s.ToString(),
                           file_name_);
   io_tracer_->WriteIOOp(io_record);
@@ -505,11 +504,11 @@ IOStatus FSRandomRWFileTracingWrapper::Sync(const IOOptions& options,
 
 IOStatus FSRandomRWFileTracingWrapper::Fsync(const IOOptions& options,
                                              IODebugContext* dbg) {
-  StopWatchNano timer(clock_);
+  StopWatchNano timer(env_);
   timer.Start();
   IOStatus s = target()->Fsync(options, dbg);
   uint64_t elapsed = timer.ElapsedNanos();
-  IOTraceRecord io_record(clock_->NowNanos(), TraceType::kIOTracer,
+  IOTraceRecord io_record(env_->NowNanos(), TraceType::kIOTracer,
                           0 /*io_op_data*/, __func__, elapsed, s.ToString(),
                           file_name_);
   io_tracer_->WriteIOOp(io_record);

env/file_system_tracer.h

@@ -6,7 +6,6 @@
 #pragma once
 
 #include "rocksdb/file_system.h"
-#include "rocksdb/system_clock.h"
 #include "trace_replay/io_tracer.h"
 
 namespace ROCKSDB_NAMESPACE {
@@ -19,11 +18,9 @@ namespace ROCKSDB_NAMESPACE {
 // overridden.
 class FileSystemTracingWrapper : public FileSystemWrapper {
  public:
-  FileSystemTracingWrapper(const std::shared_ptr<FileSystem>& t,
-                           const std::shared_ptr<IOTracer>& io_tracer)
-      : FileSystemWrapper(t),
-        io_tracer_(io_tracer),
-        clock_(SystemClock::Default()) {}
+  FileSystemTracingWrapper(std::shared_ptr<FileSystem> t,
+                           std::shared_ptr<IOTracer> io_tracer)
+      : FileSystemWrapper(t), io_tracer_(io_tracer), env_(Env::Default()) {}
 
   ~FileSystemTracingWrapper() override {}
 
@@ -86,7 +83,7 @@ class FileSystemTracingWrapper : public FileSystemWrapper {
 
  private:
   std::shared_ptr<IOTracer> io_tracer_;
-  std::shared_ptr<SystemClock> clock_;
+  Env* env_;
 };
 
 // The FileSystemPtr is a wrapper class that takes pointer to storage systems
@@ -138,7 +135,7 @@ class FSSequentialFileTracingWrapper : public FSSequentialFileWrapper {
                                  const std::string& file_name)
       : FSSequentialFileWrapper(t),
         io_tracer_(io_tracer),
-        clock_(SystemClock::Default()),
+        env_(Env::Default()),
         file_name_(file_name) {}
 
   ~FSSequentialFileTracingWrapper() override {}
@@ -154,7 +151,7 @@ class FSSequentialFileTracingWrapper : public FSSequentialFileWrapper {
 
  private:
   std::shared_ptr<IOTracer> io_tracer_;
-  std::shared_ptr<SystemClock> clock_;
+  Env* env_;
   std::string file_name_;
 };
 
@@ -210,7 +207,7 @@ class FSRandomAccessFileTracingWrapper : public FSRandomAccessFileWrapper {
                                    const std::string& file_name)
       : FSRandomAccessFileWrapper(t),
         io_tracer_(io_tracer),
-        clock_(SystemClock::Default()),
+        env_(Env::Default()),
         file_name_(file_name) {}
 
   ~FSRandomAccessFileTracingWrapper() override {}
@@ -229,7 +226,7 @@ class FSRandomAccessFileTracingWrapper : public FSRandomAccessFileWrapper {
 
  private:
   std::shared_ptr<IOTracer> io_tracer_;
-  std::shared_ptr<SystemClock> clock_;
+  Env* env_;
   // Stores file name instead of full path.
   std::string file_name_;
 };
@@ -285,7 +282,7 @@ class FSWritableFileTracingWrapper : public FSWritableFileWrapper {
                                const std::string& file_name)
       : FSWritableFileWrapper(t),
         io_tracer_(io_tracer),
-        clock_(SystemClock::Default()),
+        env_(Env::Default()),
         file_name_(file_name) {}
 
   ~FSWritableFileTracingWrapper() override {}
@@ -319,7 +316,7 @@ class FSWritableFileTracingWrapper : public FSWritableFileWrapper {
 
  private:
   std::shared_ptr<IOTracer> io_tracer_;
-  std::shared_ptr<SystemClock> clock_;
+  Env* env_;
   // Stores file name instead of full path.
   std::string file_name_;
 };
@@ -382,7 +379,7 @@ class FSRandomRWFileTracingWrapper : public FSRandomRWFileWrapper {
                                const std::string& file_name)
       : FSRandomRWFileWrapper(t),
         io_tracer_(io_tracer),
-        clock_(SystemClock::Default()),
+        env_(Env::Default()),
         file_name_(file_name) {}
 
   ~FSRandomRWFileTracingWrapper() override {}
@@ -404,7 +401,7 @@ class FSRandomRWFileTracingWrapper : public FSRandomRWFileWrapper {
 
  private:
   std::shared_ptr<IOTracer> io_tracer_;
-  std::shared_ptr<SystemClock> clock_;
+  Env* env_;
   // Stores file name instead of full path.
   std::string file_name_;
 };

file/delete_scheduler.cc

@@ -15,20 +15,17 @@
 #include "logging/logging.h"
 #include "port/port.h"
 #include "rocksdb/env.h"
-#include "rocksdb/file_system.h"
-#include "rocksdb/system_clock.h"
 #include "test_util/sync_point.h"
 #include "util/mutexlock.h"
 
 namespace ROCKSDB_NAMESPACE {
 
-DeleteScheduler::DeleteScheduler(const std::shared_ptr<SystemClock>& clock,
-                                 FileSystem* fs, int64_t rate_bytes_per_sec,
-                                 Logger* info_log,
+DeleteScheduler::DeleteScheduler(Env* env, FileSystem* fs,
+                                 int64_t rate_bytes_per_sec, Logger* info_log,
                                  SstFileManagerImpl* sst_file_manager,
                                  double max_trash_db_ratio,
                                  uint64_t bytes_max_delete_chunk)
-    : clock_(clock),
+    : env_(env),
       fs_(fs),
       total_trash_size_(0),
       rate_bytes_per_sec_(rate_bytes_per_sec),
@@ -226,14 +223,14 @@ void DeleteScheduler::BackgroundEmptyTrash() {
     }
 
     // Delete all files in queue_
-    uint64_t start_time = clock_->NowMicros();
+    uint64_t start_time = env_->NowMicros();
     uint64_t total_deleted_bytes = 0;
     int64_t current_delete_rate = rate_bytes_per_sec_.load();
     while (!queue_.empty() && !closing_) {
       if (current_delete_rate != rate_bytes_per_sec_.load()) {
         // User changed the delete rate
         current_delete_rate = rate_bytes_per_sec_.load();
-        start_time = clock_->NowMicros();
+        start_time = env_->NowMicros();
         total_deleted_bytes = 0;
         ROCKS_LOG_INFO(info_log_, "rate_bytes_per_sec is changed to %" PRIi64,
                        current_delete_rate);

file/delete_scheduler.h

@@ -15,15 +15,14 @@
 #include "monitoring/instrumented_mutex.h"
 #include "port/port.h"
 
+#include "rocksdb/file_system.h"
 #include "rocksdb/status.h"
 
 namespace ROCKSDB_NAMESPACE {
 
 class Env;
-class FileSystem;
 class Logger;
 class SstFileManagerImpl;
-class SystemClock;
 
 // DeleteScheduler allows the DB to enforce a rate limit on file deletion,
 // Instead of deleteing files immediately, files are marked as trash
@@ -34,9 +33,8 @@ class SystemClock;
 // case DeleteScheduler will delete files immediately.
 class DeleteScheduler {
  public:
-  DeleteScheduler(const std::shared_ptr<SystemClock>& clock, FileSystem* fs,
-                  int64_t rate_bytes_per_sec, Logger* info_log,
-                  SstFileManagerImpl* sst_file_manager,
+  DeleteScheduler(Env* env, FileSystem* fs, int64_t rate_bytes_per_sec,
+                  Logger* info_log, SstFileManagerImpl* sst_file_manager,
                   double max_trash_db_ratio, uint64_t bytes_max_delete_chunk);
 
   ~DeleteScheduler();
@@ -101,7 +99,7 @@ class DeleteScheduler {
 
   void MaybeCreateBackgroundThread();
 
-  const std::shared_ptr<SystemClock> clock_;
+  Env* env_;
   FileSystem* fs_;
 
   // total size of trash files

file/delete_scheduler_test.cc

@@ -95,10 +95,9 @@ class DeleteSchedulerTest : public testing::Test {
     // Tests in this file are for DeleteScheduler component and don't create any
     // DBs, so we need to set max_trash_db_ratio to 100% (instead of default
     // 25%)
-    sst_file_mgr_.reset(
-        new SstFileManagerImpl(env_->GetSystemClock(), env_->GetFileSystem(),
-                               nullptr, rate_bytes_per_sec_,
-                               /* max_trash_db_ratio= */ 1.1, 128 * 1024));
+    sst_file_mgr_.reset(new SstFileManagerImpl(
+        env_, env_->GetFileSystem(), nullptr, rate_bytes_per_sec_,
+        /* max_trash_db_ratio= */ 1.1, 128 * 1024));
     delete_scheduler_ = sst_file_mgr_->delete_scheduler();
     sst_file_mgr_->SetStatisticsPtr(stats_);
   }

file/file_util.h

@@ -12,7 +12,6 @@
 #include "rocksdb/file_system.h"
 #include "rocksdb/sst_file_writer.h"
 #include "rocksdb/status.h"
-#include "rocksdb/system_clock.h"
 #include "rocksdb/types.h"
 #include "trace_replay/io_tracer.h"
 
@@ -68,12 +67,14 @@ inline IOStatus GenerateOneFileChecksum(
       allow_mmap_reads, io_tracer);
 }
 
-inline IOStatus PrepareIOFromReadOptions(
-    const ReadOptions& ro, const std::shared_ptr<SystemClock>& clock,
-    IOOptions& opts) {
+inline IOStatus PrepareIOFromReadOptions(const ReadOptions& ro, Env* env,
+                                         IOOptions& opts) {
+  if (!env) {
+    env = Env::Default();
+  }
+
   if (ro.deadline.count()) {
-    std::chrono::microseconds now =
-        std::chrono::microseconds(clock->NowMicros());
+    std::chrono::microseconds now = std::chrono::microseconds(env->NowMicros());
     // Ensure there is atleast 1us available. We don't want to pass a value of
     // 0 as that means no timeout
     if (now >= ro.deadline) {

file/filename.cc

@@ -419,17 +419,15 @@ Status SetIdentityFile(Env* env, const std::string& dbname,
   return s;
 }
 
-IOStatus SyncManifest(const std::shared_ptr<SystemClock>& clock,
-                      const ImmutableDBOptions* db_options,
+IOStatus SyncManifest(Env* env, const ImmutableDBOptions* db_options,
                       WritableFileWriter* file) {
   TEST_KILL_RANDOM("SyncManifest:0", rocksdb_kill_odds * REDUCE_ODDS2);
-  StopWatch sw(clock, db_options->statistics.get(), MANIFEST_FILE_SYNC_MICROS);
+  StopWatch sw(env, db_options->statistics.get(), MANIFEST_FILE_SYNC_MICROS);
   return file->Sync(db_options->use_fsync);
 }
 
-Status GetInfoLogFiles(const std::shared_ptr<FileSystem>& fs,
-                       const std::string& db_log_dir, const std::string& dbname,
-                       std::string* parent_dir,
+Status GetInfoLogFiles(Env* env, const std::string& db_log_dir,
+                       const std::string& dbname, std::string* parent_dir,
                        std::vector<std::string>* info_log_list) {
   assert(parent_dir != nullptr);
   assert(info_log_list != nullptr);
@@ -445,7 +443,7 @@ Status GetInfoLogFiles(const std::shared_ptr<FileSystem>& fs,
   InfoLogPrefix info_log_prefix(!db_log_dir.empty(), dbname);
 
   std::vector<std::string> file_names;
-  Status s = fs->GetChildren(*parent_dir, IOOptions(), &file_names, nullptr);
+  Status s = env->GetChildren(*parent_dir, &file_names);
 
   if (!s.ok()) {
     return s;

file/filename.h

@@ -27,7 +27,6 @@ namespace ROCKSDB_NAMESPACE {
 
 class Env;
 class Directory;
-class SystemClock;
 class WritableFileWriter;
 
 #ifdef OS_WIN
@@ -167,16 +166,14 @@ extern Status SetIdentityFile(Env* env, const std::string& dbname,
                               const std::string& db_id = {});
 
 // Sync manifest file `file`.
-extern IOStatus SyncManifest(const std::shared_ptr<SystemClock>& clock,
-                             const ImmutableDBOptions* db_options,
+extern IOStatus SyncManifest(Env* env, const ImmutableDBOptions* db_options,
                              WritableFileWriter* file);
 
 // Return list of file names of info logs in `file_names`.
 // The list only contains file name. The parent directory name is stored
 // in `parent_dir`.
 // `db_log_dir` should be the one as in options.db_log_dir
-extern Status GetInfoLogFiles(const std::shared_ptr<FileSystem>& fs,
-                              const std::string& db_log_dir,
+extern Status GetInfoLogFiles(Env* env, const std::string& db_log_dir,
                               const std::string& dbname,
                               std::string* parent_dir,
                               std::vector<std::string>* file_names);

file/random_access_file_reader.cc

@@ -12,7 +12,6 @@
 #include <algorithm>
 #include <mutex>
 
-#include "file/file_util.h"
 #include "monitoring/histogram.h"
 #include "monitoring/iostats_context_imp.h"
 #include "port/port.h"
@@ -22,17 +21,6 @@
 #include "util/rate_limiter.h"
 
 namespace ROCKSDB_NAMESPACE {
-Status RandomAccessFileReader::Create(
-    const std::shared_ptr<FileSystem>& fs, const std::string& fname,
-    const FileOptions& file_opts,
-    std::unique_ptr<RandomAccessFileReader>* reader, IODebugContext* dbg) {
-  std::unique_ptr<FSRandomAccessFile> file;
-  Status s = fs->NewRandomAccessFile(fname, file_opts, &file, dbg);
-  if (s.ok()) {
-    reader->reset(new RandomAccessFileReader(std::move(file), fname));
-  }
-  return s;
-}
 
 Status RandomAccessFileReader::Read(const IOOptions& opts, uint64_t offset,
                                     size_t n, Slice* result, char* scratch,
@@ -44,7 +32,7 @@ Status RandomAccessFileReader::Read(const IOOptions& opts, uint64_t offset,
   Status s;
   uint64_t elapsed = 0;
   {
-    StopWatch sw(clock_, stats_, hist_type_,
+    StopWatch sw(env_, stats_, hist_type_,
                  (stats_ != nullptr) ? &elapsed : nullptr, true /*overwrite*/,
                  true /*delay_enabled*/);
     auto prev_perf_level = GetPerfLevel();
@@ -80,7 +68,7 @@ Status RandomAccessFileReader::Read(const IOOptions& opts, uint64_t offset,
         }
 
         {
-          IOSTATS_CPU_TIMER_GUARD(cpu_read_nanos, clock_);
+          IOSTATS_CPU_TIMER_GUARD(cpu_read_nanos, env_);
           // Only user reads are expected to specify a timeout. And user reads
           // are not subjected to rate_limiter and should go through only
           // one iteration of this loop, so we don't need to check and adjust
@@ -140,7 +128,7 @@ Status RandomAccessFileReader::Read(const IOOptions& opts, uint64_t offset,
 #endif
 
         {
-          IOSTATS_CPU_TIMER_GUARD(cpu_read_nanos, clock_);
+          IOSTATS_CPU_TIMER_GUARD(cpu_read_nanos, env_);
           // Only user reads are expected to specify a timeout. And user reads
           // are not subjected to rate_limiter and should go through only
           // one iteration of this loop, so we don't need to check and adjust
@@ -217,7 +205,7 @@ Status RandomAccessFileReader::MultiRead(const IOOptions& opts,
   Status s;
   uint64_t elapsed = 0;
   {
-    StopWatch sw(clock_, stats_, hist_type_,
+    StopWatch sw(env_, stats_, hist_type_,
                  (stats_ != nullptr) ? &elapsed : nullptr, true /*overwrite*/,
                  true /*delay_enabled*/);
     auto prev_perf_level = GetPerfLevel();
@@ -279,7 +267,7 @@ Status RandomAccessFileReader::MultiRead(const IOOptions& opts,
 #endif  // ROCKSDB_LITE
 
     {
-      IOSTATS_CPU_TIMER_GUARD(cpu_read_nanos, clock_);
+      IOSTATS_CPU_TIMER_GUARD(cpu_read_nanos, env_);
       s = file_->MultiRead(fs_reqs, num_fs_reqs, opts, nullptr);
     }
 
@@ -324,12 +312,4 @@ Status RandomAccessFileReader::MultiRead(const IOOptions& opts,
   return s;
 }
 
-IOStatus RandomAccessFileReader::PrepareIOOptions(const ReadOptions& ro,
-                                                  IOOptions& opts) {
-  if (clock_.get() != nullptr) {
-    return PrepareIOFromReadOptions(ro, clock_, opts);
-  } else {
-    return PrepareIOFromReadOptions(ro, SystemClock::Default(), opts);
-  }
-}
 }  // namespace ROCKSDB_NAMESPACE

file/random_access_file_reader.h

@@ -14,6 +14,7 @@
 
 #include "env/file_system_tracer.h"
 #include "port/port.h"
+#include "rocksdb/env.h"
 #include "rocksdb/file_system.h"
 #include "rocksdb/listener.h"
 #include "rocksdb/options.h"
@@ -23,7 +24,6 @@
 namespace ROCKSDB_NAMESPACE {
 class Statistics;
 class HistogramImpl;
-class SystemClock;
 
 using AlignedBuf = std::unique_ptr<char[]>;
 
@@ -67,7 +67,7 @@ class RandomAccessFileReader {
 
   FSRandomAccessFilePtr file_;
   std::string file_name_;
-  std::shared_ptr<SystemClock> clock_;
+  Env* env_;
   Statistics* stats_;
   uint32_t hist_type_;
   HistogramImpl* file_read_hist_;
@@ -77,15 +77,14 @@ class RandomAccessFileReader {
  public:
   explicit RandomAccessFileReader(
       std::unique_ptr<FSRandomAccessFile>&& raf, const std::string& _file_name,
-      const std::shared_ptr<SystemClock>& clock = nullptr,
-      const std::shared_ptr<IOTracer>& io_tracer = nullptr,
+      Env* _env = nullptr, const std::shared_ptr<IOTracer>& io_tracer = nullptr,
       Statistics* stats = nullptr, uint32_t hist_type = 0,
       HistogramImpl* file_read_hist = nullptr,
       RateLimiter* rate_limiter = nullptr,
       const std::vector<std::shared_ptr<EventListener>>& listeners = {})
       : file_(std::move(raf), io_tracer, _file_name),
         file_name_(std::move(_file_name)),
-        clock_(clock),
+        env_(_env),
         stats_(stats),
         hist_type_(hist_type),
         file_read_hist_(file_read_hist),
@@ -103,10 +102,6 @@ class RandomAccessFileReader {
 #endif
   }
 
-  static Status Create(const std::shared_ptr<FileSystem>& fs,
-                       const std::string& fname, const FileOptions& file_opts,
-                       std::unique_ptr<RandomAccessFileReader>* reader,
-                       IODebugContext* dbg);
   RandomAccessFileReader(const RandomAccessFileReader&) = delete;
   RandomAccessFileReader& operator=(const RandomAccessFileReader&) = delete;
 
@@ -142,6 +137,6 @@ class RandomAccessFileReader {
 
   bool use_direct_io() const { return file_->use_direct_io(); }
 
-  IOStatus PrepareIOOptions(const ReadOptions& ro, IOOptions& opts);
+  Env* env() const { return env_; }
 };
 }  // namespace ROCKSDB_NAMESPACE

file/random_access_file_reader_test.cc

@@ -42,8 +42,7 @@ class RandomAccessFileReaderTest : public testing::Test {
     std::string fpath = Path(fname);
     std::unique_ptr<FSRandomAccessFile> f;
     ASSERT_OK(fs_->NewRandomAccessFile(fpath, opts, &f, nullptr));
-    (*reader).reset(new RandomAccessFileReader(std::move(f), fpath,
-                                               env_->GetSystemClock()));
+    (*reader).reset(new RandomAccessFileReader(std::move(f), fpath, env_));
   }
 
   void AssertResult(const std::string& content,

file/sequence_file_reader.cc

@@ -22,18 +22,6 @@
 #include "util/rate_limiter.h"
 
 namespace ROCKSDB_NAMESPACE {
-Status SequentialFileReader::Create(
-    const std::shared_ptr<FileSystem>& fs, const std::string& fname,
-    const FileOptions& file_opts, std::unique_ptr<SequentialFileReader>* reader,
-    IODebugContext* dbg) {
-  std::unique_ptr<FSSequentialFile> file;
-  Status s = fs->NewSequentialFile(fname, file_opts, &file, dbg);
-  if (s.ok()) {
-    reader->reset(new SequentialFileReader(std::move(file), fname));
-  }
-  return s;
-}
-
 Status SequentialFileReader::Read(size_t n, Slice* result, char* scratch) {
   Status s;
   if (use_direct_io()) {

file/sequence_file_reader.h

@@ -41,10 +41,6 @@ class SequentialFileReader {
       : file_name_(_file_name),
         file_(NewReadaheadSequentialFile(std::move(_file), _readahead_size),
               io_tracer, _file_name) {}
-  static Status Create(const std::shared_ptr<FileSystem>& fs,
-                       const std::string& fname, const FileOptions& file_opts,
-                       std::unique_ptr<SequentialFileReader>* reader,
-                       IODebugContext* dbg);
 
   SequentialFileReader(const SequentialFileReader&) = delete;
   SequentialFileReader& operator=(const SequentialFileReader&) = delete;

file/sst_file_manager_impl.cc

@@ -18,12 +18,12 @@
 namespace ROCKSDB_NAMESPACE {
 
 #ifndef ROCKSDB_LITE
-SstFileManagerImpl::SstFileManagerImpl(
-    const std::shared_ptr<SystemClock>& clock,
-    const std::shared_ptr<FileSystem>& fs,
-    const std::shared_ptr<Logger>& logger, int64_t rate_bytes_per_sec,
-    double max_trash_db_ratio, uint64_t bytes_max_delete_chunk)
-    : clock_(clock),
+SstFileManagerImpl::SstFileManagerImpl(Env* env, std::shared_ptr<FileSystem> fs,
+                                       std::shared_ptr<Logger> logger,
+                                       int64_t rate_bytes_per_sec,
+                                       double max_trash_db_ratio,
+                                       uint64_t bytes_max_delete_chunk)
+    : env_(env),
       fs_(fs),
       logger_(logger),
       total_files_size_(0),
@@ -31,8 +31,8 @@ SstFileManagerImpl::SstFileManagerImpl(
       compaction_buffer_size_(0),
       cur_compactions_reserved_size_(0),
       max_allowed_space_(0),
-      delete_scheduler_(clock_, fs_.get(), rate_bytes_per_sec, logger.get(),
-                        this, max_trash_db_ratio, bytes_max_delete_chunk),
+      delete_scheduler_(env, fs_.get(), rate_bytes_per_sec, logger.get(), this,
+                        max_trash_db_ratio, bytes_max_delete_chunk),
       cv_(&mu_),
       closing_(false),
       bg_thread_(nullptr),
@@ -347,7 +347,7 @@ void SstFileManagerImpl::ClearError() {
     if (!error_handler_list_.empty()) {
       // If there are more instances to be recovered, reschedule after 5
       // seconds
-      int64_t wait_until = clock_->NowMicros() + 5000000;
+      int64_t wait_until = env_->NowMicros() + 5000000;
       cv_.TimedWait(wait_until);
     }
 
@@ -485,6 +485,7 @@ SstFileManager* NewSstFileManager(Env* env, std::shared_ptr<Logger> info_log,
                                   double max_trash_db_ratio,
                                   uint64_t bytes_max_delete_chunk) {
   const auto& fs = env->GetFileSystem();
+
   return NewSstFileManager(env, fs, info_log, trash_dir, rate_bytes_per_sec,
                            delete_existing_trash, status, max_trash_db_ratio,
                            bytes_max_delete_chunk);
@@ -497,9 +498,8 @@ SstFileManager* NewSstFileManager(Env* env, std::shared_ptr<FileSystem> fs,
                                   bool delete_existing_trash, Status* status,
                                   double max_trash_db_ratio,
                                   uint64_t bytes_max_delete_chunk) {
-  const auto& clock = env->GetSystemClock();
   SstFileManagerImpl* res =
-      new SstFileManagerImpl(clock, fs, info_log, rate_bytes_per_sec,
+      new SstFileManagerImpl(env, fs, info_log, rate_bytes_per_sec,
                              max_trash_db_ratio, bytes_max_delete_chunk);
 
   // trash_dir is deprecated and not needed anymore, but if user passed it

file/sst_file_manager_impl.h

@@ -12,13 +12,14 @@
 #include "port/port.h"
 
 #include "db/compaction/compaction.h"
+#include "db/error_handler.h"
 #include "file/delete_scheduler.h"
+#include "rocksdb/file_system.h"
 #include "rocksdb/sst_file_manager.h"
 
 namespace ROCKSDB_NAMESPACE {
-class ErrorHandler;
-class FileSystem;
-class SystemClock;
+
+class Env;
 class Logger;
 
 // SstFileManager is used to track SST files in the DB and control their
@@ -26,9 +27,8 @@ class Logger;
 // All SstFileManager public functions are thread-safe.
 class SstFileManagerImpl : public SstFileManager {
  public:
-  explicit SstFileManagerImpl(const std::shared_ptr<SystemClock>& clock,
-                              const std::shared_ptr<FileSystem>& fs,
-                              const std::shared_ptr<Logger>& logger,
+  explicit SstFileManagerImpl(Env* env, std::shared_ptr<FileSystem> fs,
+                              std::shared_ptr<Logger> logger,
                               int64_t rate_bytes_per_sec,
                               double max_trash_db_ratio,
                               uint64_t bytes_max_delete_chunk);
@@ -152,7 +152,7 @@ class SstFileManagerImpl : public SstFileManager {
     return bg_err_.severity() == Status::Severity::kSoftError;
   }
 
-  std::shared_ptr<SystemClock> clock_;
+  Env* env_;
   std::shared_ptr<FileSystem> fs_;
   std::shared_ptr<Logger> logger_;
   // Mutex to protect tracked_files_, total_files_size_

file/writable_file_writer.cc

@@ -16,26 +16,12 @@
 #include "monitoring/histogram.h"
 #include "monitoring/iostats_context_imp.h"
 #include "port/port.h"
-#include "rocksdb/system_clock.h"
 #include "test_util/sync_point.h"
 #include "util/crc32c.h"
 #include "util/random.h"
 #include "util/rate_limiter.h"
 
 namespace ROCKSDB_NAMESPACE {
-Status WritableFileWriter::Create(const std::shared_ptr<FileSystem>& fs,
-                                  const std::string& fname,
-                                  const FileOptions& file_opts,
-                                  std::unique_ptr<WritableFileWriter>* writer,
-                                  IODebugContext* dbg) {
-  std::unique_ptr<FSWritableFile> file;
-  Status s = fs->NewWritableFile(fname, file_opts, &file, dbg);
-  if (s.ok()) {
-    writer->reset(new WritableFileWriter(std::move(file), fname, file_opts));
-  }
-  return s;
-}
-
 IOStatus WritableFileWriter::Append(const Slice& data) {
   const char* src = data.data();
   size_t left = data.size();
@@ -346,7 +332,7 @@ IOStatus WritableFileWriter::SyncInternal(bool use_fsync) {
   IOSTATS_TIMER_GUARD(fsync_nanos);
   TEST_SYNC_POINT("WritableFileWriter::SyncInternal:0");
   auto prev_perf_level = GetPerfLevel();
-  IOSTATS_CPU_TIMER_GUARD(cpu_write_nanos, clock_);
+  IOSTATS_CPU_TIMER_GUARD(cpu_write_nanos, env_);
 #ifndef ROCKSDB_LITE
   FileOperationInfo::StartTimePoint start_ts;
   if (ShouldNotifyListeners()) {
@@ -424,7 +410,7 @@ IOStatus WritableFileWriter::WriteBuffered(const char* data, size_t size) {
       {
         auto prev_perf_level = GetPerfLevel();
 
-        IOSTATS_CPU_TIMER_GUARD(cpu_write_nanos, clock_);
+        IOSTATS_CPU_TIMER_GUARD(cpu_write_nanos, env_);
         if (perform_data_verification_) {
           Crc32cHandoffChecksumCalculation(src, allowed, checksum_buf);
           v_info.checksum = Slice(checksum_buf, sizeof(uint32_t));

file/writable_file_writer.h

@@ -14,6 +14,7 @@
 #include "db/version_edit.h"
 #include "env/file_system_tracer.h"
 #include "port/port.h"
+#include "rocksdb/env.h"
 #include "rocksdb/file_checksum.h"
 #include "rocksdb/file_system.h"
 #include "rocksdb/io_status.h"
@@ -24,7 +25,6 @@
 
 namespace ROCKSDB_NAMESPACE {
 class Statistics;
-class SystemClock;
 
 // WritableFileWriter is a wrapper on top of Env::WritableFile. It provides
 // facilities to:
@@ -123,7 +123,7 @@ class WritableFileWriter {
 
   std::string file_name_;
   FSWritableFilePtr writable_file_;
-  std::shared_ptr<SystemClock> clock_;
+  Env* env_;
   AlignedBuffer buf_;
   size_t max_buffer_size_;
   // Actually written data size can be used for truncate
@@ -148,8 +148,7 @@ class WritableFileWriter {
  public:
   WritableFileWriter(
       std::unique_ptr<FSWritableFile>&& file, const std::string& _file_name,
-      const FileOptions& options,
-      const std::shared_ptr<SystemClock>& clock = nullptr,
+      const FileOptions& options, Env* env = nullptr,
       const std::shared_ptr<IOTracer>& io_tracer = nullptr,
       Statistics* stats = nullptr,
       const std::vector<std::shared_ptr<EventListener>>& listeners = {},
@@ -157,7 +156,7 @@ class WritableFileWriter {
       bool perform_data_verification = false)
       : file_name_(_file_name),
         writable_file_(std::move(file), io_tracer, _file_name),
-        clock_(clock),
+        env_(env),
         buf_(),
         max_buffer_size_(options.writable_file_max_buffer_size),
         filesize_(0),
@@ -196,10 +195,6 @@ class WritableFileWriter {
     }
   }
 
-  static Status Create(const std::shared_ptr<FileSystem>& fs,
-                       const std::string& fname, const FileOptions& file_opts,
-                       std::unique_ptr<WritableFileWriter>* writer,
-                       IODebugContext* dbg);
   WritableFileWriter(const WritableFileWriter&) = delete;
 
   WritableFileWriter& operator=(const WritableFileWriter&) = delete;

fuzz/sst_file_writer_fuzzer.cc

@@ -58,15 +58,16 @@ TableReader* NewTableReader(const std::string& sst_file_path,
   // This code block is similar to SstFileReader::Open.
 
   uint64_t file_size = 0;
+  std::unique_ptr<RandomAccessFile> file;
   std::unique_ptr<RandomAccessFileReader> file_reader;
   std::unique_ptr<TableReader> table_reader;
-  const auto& fs = options.env->GetFileSystem();
-  FileOptions fopts(env_options);
-  Status s = options.env->GetFileSize(sst_file_path, fopts.io_options,
-                                      &file_size, nullptr);
+  Status s = options.env->GetFileSize(sst_file_path, &file_size);
   if (s.ok()) {
-    s = RandomAccessFileReader::Create(fs, sst_file_path, fopts, &file_reader,
-                                       nullptr);
+    s = options.env->NewRandomAccessFile(sst_file_path, &file, env_options);
+  }
+  if (s.ok()) {
+    file_reader.reset(new RandomAccessFileReader(
+        NewLegacyRandomAccessFileWrapper(file), sst_file_path));
   }
   if (s.ok()) {
     TableReaderOptions t_opt(cf_ioptions, /*prefix_extractor=*/nullptr,

include/rocksdb/env.h

@@ -59,7 +59,6 @@ class RateLimiter;
 class ThreadStatusUpdater;
 struct ThreadStatus;
 class FileSystem;
-class SystemClock;
 
 const size_t kDefaultPageSize = 4 * 1024;
 
@@ -151,11 +150,8 @@ class Env {
   };
 
   Env();
-  // Construct an Env with a separate FileSystem and/or SystemClock
-  // implementation
-  explicit Env(const std::shared_ptr<FileSystem>& fs);
-  Env(const std::shared_ptr<FileSystem>& fs,
-      const std::shared_ptr<SystemClock>& clock);
+  // Construct an Env with a separate FileSystem implementation
+  Env(std::shared_ptr<FileSystem> fs);
   // No copying allowed
   Env(const Env&) = delete;
   void operator=(const Env&) = delete;
@@ -580,10 +576,6 @@ class Env {
   // could be a fully implemented one, or a wrapper class around the Env
   const std::shared_ptr<FileSystem>& GetFileSystem() const;
 
-  // Get the SystemClock implementation this Env was constructed with. It
-  // could be a fully implemented one, or a wrapper class around the Env
-  const std::shared_ptr<SystemClock>& GetSystemClock() const;
-
   // If you're adding methods here, remember to add them to EnvWrapper too.
 
  protected:
@@ -594,9 +586,6 @@ class Env {
   // Pointer to the underlying FileSystem implementation
   std::shared_ptr<FileSystem> file_system_;
 
-  // Pointer to the underlying SystemClock implementation
-  std::shared_ptr<SystemClock> system_clock_;
-
  private:
   static const size_t kMaxHostNameLen = 256;
 };

include/rocksdb/system_clock.h

@@ -1,102 +0,0 @@
-// Copyright (c) 2011-present, Facebook, Inc.  All rights reserved.
-//  This source code is licensed under both the GPLv2 (found in the
-//  COPYING file in the root directory) and Apache 2.0 License
-//  (found in the LICENSE.Apache file in the root directory).
-// Copyright (c) 2011 The LevelDB Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file. See the AUTHORS file for names of contributors.
-
-#pragma once
-#include <rocksdb/rocksdb_namespace.h>
-#include <rocksdb/status.h>
-#include <stdint.h>
-
-#include <memory>
-
-#ifdef _WIN32
-// Windows API macro interference
-#undef GetCurrentTime
-#endif
-
-namespace ROCKSDB_NAMESPACE {
-struct ConfigOptions;
-
-// A SystemClock is an interface used by the rocksdb implementation to access
-// operating system time-related functionality.
-class SystemClock {
- public:
-  virtual ~SystemClock() {}
-
-  static const char* Type() { return "SystemClock"; }
-
-  // The name of this system clock
-  virtual const char* Name() const = 0;
-
-  // Return a default SystemClock suitable for the current operating
-  // system.
-  static const std::shared_ptr<SystemClock>& Default();
-
-  // Returns the number of micro-seconds since some fixed point in time.
-  // It is often used as system time such as in GenericRateLimiter
-  // and other places so a port needs to return system time in order to work.
-  virtual uint64_t NowMicros() = 0;
-
-  // Returns the number of nano-seconds since some fixed point in time. Only
-  // useful for computing deltas of time in one run.
-  // Default implementation simply relies on NowMicros.
-  // In platform-specific implementations, NowNanos() should return time points
-  // that are MONOTONIC.
-  virtual uint64_t NowNanos() { return NowMicros() * 1000; }
-
-  // Returns the number of micro-seconds of CPU time used by the current thread.
-  // 0 indicates not supported.
-  virtual uint64_t CPUMicros() { return 0; }
-
-  // Returns the number of nano-seconds of CPU time used by the current thread.
-  // Default implementation simply relies on CPUMicros.
-  // 0 indicates not supported.
-  virtual uint64_t CPUNanos() { return CPUMicros() * 1000; }
-
-  // Sleep/delay the thread for the prescribed number of micro-seconds.
-  virtual void SleepForMicroseconds(int micros) = 0;
-
-  // Get the number of seconds since the Epoch, 1970-01-01 00:00:00 (UTC).
-  // Only overwrites *unix_time on success.
-  virtual Status GetCurrentTime(int64_t* unix_time) = 0;
-
-  // Converts seconds-since-Jan-01-1970 to a printable string
-  virtual std::string TimeToString(uint64_t time) = 0;
-};
-
-// Wrapper class for a SystemClock.  Redirects all methods (except Name)
-// of the SystemClock interface to the target/wrapped class.
-class SystemClockWrapper : public SystemClock {
- public:
-  explicit SystemClockWrapper(const std::shared_ptr<SystemClock>& t)
-      : target_(t) {}
-
-  uint64_t NowMicros() override { return target_->NowMicros(); }
-
-  uint64_t NowNanos() override { return target_->NowNanos(); }
-
-  uint64_t CPUMicros() override { return target_->CPUMicros(); }
-
-  uint64_t CPUNanos() override { return target_->CPUNanos(); }
-
-  virtual void SleepForMicroseconds(int micros) override {
-    return target_->SleepForMicroseconds(micros);
-  }
-
-  Status GetCurrentTime(int64_t* unix_time) override {
-    return target_->GetCurrentTime(unix_time);
-  }
-
-  std::string TimeToString(uint64_t time) override {
-    return target_->TimeToString(time);
-  }
-
- protected:
-  std::shared_ptr<SystemClock> target_;
-};
-
-}  // end namespace ROCKSDB_NAMESPACE

include/rocksdb/version.h

@@ -11,7 +11,7 @@
 
 #define ROCKSDB_MAJOR 6
 #define ROCKSDB_MINOR 18
-#define ROCKSDB_PATCH 0
+#define ROCKSDB_PATCH 1
 
 // Do not use these. We made the mistake of declaring macros starting with
 // double underscore. Now we have to live with our choice. We'll deprecate these

logging/auto_roll_logger.cc

@@ -6,12 +6,8 @@
 #include "logging/auto_roll_logger.h"
 
 #include <algorithm>
-
 #include "file/filename.h"
 #include "logging/logging.h"
-#include "rocksdb/env.h"
-#include "rocksdb/file_system.h"
-#include "rocksdb/system_clock.h"
 #include "util/mutexlock.h"
 
 namespace ROCKSDB_NAMESPACE {
@@ -19,9 +15,7 @@ namespace ROCKSDB_NAMESPACE {
 #ifndef ROCKSDB_LITE
 // -- AutoRollLogger
 
-AutoRollLogger::AutoRollLogger(const std::shared_ptr<FileSystem>& fs,
-                               const std::shared_ptr<SystemClock>& clock,
-                               const std::string& dbname,
+AutoRollLogger::AutoRollLogger(Env* env, const std::string& dbname,
                                const std::string& db_log_dir,
                                size_t log_max_size,
                                size_t log_file_time_to_roll,
@@ -30,26 +24,24 @@ AutoRollLogger::AutoRollLogger(const std::shared_ptr<FileSystem>& fs,
     : Logger(log_level),
       dbname_(dbname),
       db_log_dir_(db_log_dir),
-      fs_(fs),
-      clock_(clock),
+      env_(env),
       status_(Status::OK()),
       kMaxLogFileSize(log_max_size),
       kLogFileTimeToRoll(log_file_time_to_roll),
       kKeepLogFileNum(keep_log_file_num),
-      cached_now(static_cast<uint64_t>(clock_->NowMicros() * 1e-6)),
+      cached_now(static_cast<uint64_t>(env_->NowMicros() * 1e-6)),
       ctime_(cached_now),
       cached_now_access_count(0),
       call_NowMicros_every_N_records_(100),
       mutex_() {
-  Status s = fs->GetAbsolutePath(dbname, io_options_, &db_absolute_path_,
-                                 &io_context_);
+  Status s = env->GetAbsolutePath(dbname, &db_absolute_path_);
   if (s.IsNotSupported()) {
     db_absolute_path_ = dbname;
   } else {
     status_ = s;
   }
   log_fname_ = InfoLogFileName(dbname_, db_absolute_path_, db_log_dir_);
-  if (fs_->FileExists(log_fname_, io_options_, &io_context_).ok()) {
+  if (env_->FileExists(log_fname_).ok()) {
     RollLogFile();
   }
   GetExistingFiles();
@@ -61,7 +53,7 @@ AutoRollLogger::AutoRollLogger(const std::shared_ptr<FileSystem>& fs,
 
 Status AutoRollLogger::ResetLogger() {
   TEST_SYNC_POINT("AutoRollLogger::ResetLogger:BeforeNewLogger");
-  status_ = fs_->NewLogger(log_fname_, io_options_, &logger_, &io_context_);
+  status_ = env_->NewLogger(log_fname_, &logger_);
   TEST_SYNC_POINT("AutoRollLogger::ResetLogger:AfterNewLogger");
 
   if (!status_.ok()) {
@@ -75,7 +67,7 @@ Status AutoRollLogger::ResetLogger() {
         "The underlying logger doesn't support GetLogFileSize()");
   }
   if (status_.ok()) {
-    cached_now = static_cast<uint64_t>(clock_->NowMicros() * 1e-6);
+    cached_now = static_cast<uint64_t>(env_->NowMicros() * 1e-6);
     ctime_ = cached_now;
     cached_now_access_count = 0;
   }
@@ -87,14 +79,14 @@ void AutoRollLogger::RollLogFile() {
   // This function is called when log is rotating. Two rotations
   // can happen quickly (NowMicro returns same value). To not overwrite
   // previous log file we increment by one micro second and try again.
-  uint64_t now = clock_->NowMicros();
+  uint64_t now = env_->NowMicros();
   std::string old_fname;
   do {
     old_fname = OldInfoLogFileName(
       dbname_, now, db_absolute_path_, db_log_dir_);
     now++;
-  } while (fs_->FileExists(old_fname, io_options_, &io_context_).ok());
-  Status s = fs_->RenameFile(log_fname_, old_fname, io_options_, &io_context_);
+  } while (env_->FileExists(old_fname).ok());
+  Status s = env_->RenameFile(log_fname_, old_fname);
   if (!s.ok()) {
     // What should we do on error?
   }
@@ -111,7 +103,7 @@ void AutoRollLogger::GetExistingFiles() {
   std::string parent_dir;
   std::vector<std::string> info_log_files;
   Status s =
-      GetInfoLogFiles(fs_, db_log_dir_, dbname_, &parent_dir, &info_log_files);
+      GetInfoLogFiles(env_, db_log_dir_, dbname_, &parent_dir, &info_log_files);
   if (status_.ok()) {
     status_ = s;
   }
@@ -125,7 +117,7 @@ void AutoRollLogger::GetExistingFiles() {
 }
 
 Status AutoRollLogger::TrimOldLogFiles() {
-  // Here we directly list info files and delete them through FileSystem.
+  // Here we directly list info files and delete them through Env.
   // The deletion isn't going through DB, so there are shortcomes:
   // 1. the deletion is not rate limited by SstFileManager
   // 2. there is a chance that an I/O will be issued here
@@ -138,8 +130,7 @@ Status AutoRollLogger::TrimOldLogFiles() {
   // it's essentially the same thing, and checking empty before accessing
   // the queue feels safer.
   while (!old_log_files_.empty() && old_log_files_.size() >= kKeepLogFileNum) {
-    Status s =
-        fs_->DeleteFile(old_log_files_.front(), io_options_, &io_context_);
+    Status s = env_->DeleteFile(old_log_files_.front());
     // Remove the file from the tracking anyway. It's possible that
     // DB cleaned up the old log file, or people cleaned it up manually.
     old_log_files_.pop();
@@ -250,7 +241,7 @@ void AutoRollLogger::LogHeader(const char* format, va_list args) {
 
 bool AutoRollLogger::LogExpired() {
   if (cached_now_access_count >= call_NowMicros_every_N_records_) {
-    cached_now = static_cast<uint64_t>(clock_->NowMicros() * 1e-6);
+    cached_now = static_cast<uint64_t>(env_->NowMicros() * 1e-6);
     cached_now_access_count = 0;
   }
 
@@ -276,16 +267,15 @@ Status CreateLoggerFromOptions(const std::string& dbname,
   std::string fname =
       InfoLogFileName(dbname, db_absolute_path, options.db_log_dir);
 
-  const auto& clock = env->GetSystemClock();
   env->CreateDirIfMissing(dbname)
       .PermitUncheckedError();  // In case it does not exist
   // Currently we only support roll by time-to-roll and log size
 #ifndef ROCKSDB_LITE
   if (options.log_file_time_to_roll > 0 || options.max_log_file_size > 0) {
     AutoRollLogger* result = new AutoRollLogger(
-        env->GetFileSystem(), clock, dbname, options.db_log_dir,
-        options.max_log_file_size, options.log_file_time_to_roll,
-        options.keep_log_file_num, options.info_log_level);
+        env, dbname, options.db_log_dir, options.max_log_file_size,
+        options.log_file_time_to_roll, options.keep_log_file_num,
+        options.info_log_level);
     s = result->GetStatus();
     if (!s.ok()) {
       delete result;
@@ -296,9 +286,9 @@ Status CreateLoggerFromOptions(const std::string& dbname,
   }
 #endif  // !ROCKSDB_LITE
   // Open a log file in the same directory as the db
-  env->RenameFile(
-         fname, OldInfoLogFileName(dbname, clock->NowMicros(), db_absolute_path,
-                                   options.db_log_dir))
+  env->RenameFile(fname,
+                  OldInfoLogFileName(dbname, env->NowMicros(), db_absolute_path,
+                                     options.db_log_dir))
       .PermitUncheckedError();
   s = env->NewLogger(fname, logger);
   if (logger->get() != nullptr) {

logging/auto_roll_logger.h

@@ -18,18 +18,14 @@
 #include "util/mutexlock.h"
 
 namespace ROCKSDB_NAMESPACE {
-class FileSystem;
-class SystemClock;
 
 #ifndef ROCKSDB_LITE
 // Rolls the log file by size and/or time
 class AutoRollLogger : public Logger {
  public:
-  AutoRollLogger(const std::shared_ptr<FileSystem>& fs,
-                 const std::shared_ptr<SystemClock>& clock,
-                 const std::string& dbname, const std::string& db_log_dir,
-                 size_t log_max_size, size_t log_file_time_to_roll,
-                 size_t keep_log_file_num,
+  AutoRollLogger(Env* env, const std::string& dbname,
+                 const std::string& db_log_dir, size_t log_max_size,
+                 size_t log_file_time_to_roll, size_t keep_log_file_num,
                  const InfoLogLevel log_level = InfoLogLevel::INFO_LEVEL);
 
   using Logger::Logv;
@@ -138,8 +134,7 @@ class AutoRollLogger : public Logger {
   std::string dbname_;
   std::string db_log_dir_;
   std::string db_absolute_path_;
-  std::shared_ptr<FileSystem> fs_;
-  std::shared_ptr<SystemClock> clock_;
+  Env* env_;
   std::shared_ptr<Logger> logger_;
   // current status of the logger
   Status status_;
@@ -153,13 +148,11 @@ class AutoRollLogger : public Logger {
   // Full path is stored here. It consumes signifianctly more memory
   // than only storing file name. Can optimize if it causes a problem.
   std::queue<std::string> old_log_files_;
-  // to avoid frequent clock->NowMicros() calls, we cached the current time
+  // to avoid frequent env->NowMicros() calls, we cached the current time
   uint64_t cached_now;
   uint64_t ctime_;
   uint64_t cached_now_access_count;
   uint64_t call_NowMicros_every_N_records_;
-  IOOptions io_options_;
-  IODebugContext io_context_;
   mutable port::Mutex mutex_;
 };
 #endif  // !ROCKSDB_LITE

logging/auto_roll_logger_test.cc

@@ -7,9 +7,7 @@
 #ifndef ROCKSDB_LITE
 
 #include "logging/auto_roll_logger.h"
-
 #include <sys/stat.h>
-
 #include <algorithm>
 #include <cmath>
 #include <fstream>
@@ -18,24 +16,18 @@
 #include <string>
 #include <thread>
 #include <vector>
-
 #include "logging/logging.h"
 #include "port/port.h"
 #include "rocksdb/db.h"
-#include "rocksdb/file_system.h"
-#include "rocksdb/system_clock.h"
 #include "test_util/sync_point.h"
 #include "test_util/testharness.h"
 #include "test_util/testutil.h"
 
 namespace ROCKSDB_NAMESPACE {
 namespace {
-class NoSleepClock : public SystemClockWrapper {
+class NoSleepEnv : public EnvWrapper {
  public:
-  NoSleepClock(
-      const std::shared_ptr<SystemClock>& base = SystemClock::Default())
-      : SystemClockWrapper(base) {}
-  const char* Name() const override { return "NoSleepClock"; }
+  NoSleepEnv(Env* base) : EnvWrapper(base) {}
   void SleepForMicroseconds(int micros) override {
     fake_time_ += static_cast<uint64_t>(micros);
   }
@@ -83,9 +75,7 @@ class AutoRollLoggerTest : public testing::Test {
 
   void RollLogFileBySizeTest(AutoRollLogger* logger, size_t log_max_size,
                              const std::string& log_message);
-  void RollLogFileByTimeTest(const std::shared_ptr<FileSystem>& fs,
-                             const std::shared_ptr<SystemClock>& sc,
-                             AutoRollLogger* logger, size_t time,
+  void RollLogFileByTimeTest(Env*, AutoRollLogger* logger, size_t time,
                              const std::string& log_message);
   // return list of files under kTestDir that contains "LOG"
   std::vector<std::string> GetLogFiles() {
@@ -166,22 +156,21 @@ void AutoRollLoggerTest::RollLogFileBySizeTest(AutoRollLogger* logger,
   ASSERT_TRUE(message_size == logger->GetLogFileSize());
 }
 
-void AutoRollLoggerTest::RollLogFileByTimeTest(
-    const std::shared_ptr<FileSystem>& fs,
-    const std::shared_ptr<SystemClock>& sc, AutoRollLogger* logger, size_t time,
-    const std::string& log_message) {
+void AutoRollLoggerTest::RollLogFileByTimeTest(Env* env, AutoRollLogger* logger,
+                                               size_t time,
+                                               const std::string& log_message) {
   uint64_t expected_ctime;
   uint64_t actual_ctime;
 
   uint64_t total_log_size;
-  EXPECT_OK(fs->GetFileSize(kLogFile, IOOptions(), &total_log_size, nullptr));
+  EXPECT_OK(env->GetFileSize(kLogFile, &total_log_size));
   expected_ctime = logger->TEST_ctime();
   logger->SetCallNowMicrosEveryNRecords(0);
 
   // -- Write to the log for several times, which is supposed
   // to be finished before time.
   for (int i = 0; i < 10; ++i) {
-    sc->SleepForMicroseconds(50000);
+    env->SleepForMicroseconds(50000);
     LogMessage(logger, log_message.c_str());
     EXPECT_OK(logger->GetStatus());
     // Make sure we always write to the same log file (by
@@ -196,7 +185,7 @@ void AutoRollLoggerTest::RollLogFileByTimeTest(
   }
 
   // -- Make the log file expire
-  sc->SleepForMicroseconds(static_cast<int>(time * 1000000));
+  env->SleepForMicroseconds(static_cast<int>(time * 1000000));
   LogMessage(logger, log_message.c_str());
 
   // At this time, the new log file should be created.
@@ -210,15 +199,15 @@ TEST_F(AutoRollLoggerTest, RollLogFileBySize) {
     size_t log_max_size = 1024 * 5;
     size_t keep_log_file_num = 10;
 
-    AutoRollLogger logger(FileSystem::Default(), SystemClock::Default(),
-                          kTestDir, "", log_max_size, 0, keep_log_file_num);
+    AutoRollLogger logger(Env::Default(), kTestDir, "", log_max_size, 0,
+                          keep_log_file_num);
 
     RollLogFileBySizeTest(&logger, log_max_size,
                           kSampleMessage + ":RollLogFileBySize");
 }
 
 TEST_F(AutoRollLoggerTest, RollLogFileByTime) {
-  auto nsc = std::make_shared<NoSleepClock>();
+  NoSleepEnv nse(Env::Default());
 
   size_t time = 2;
   size_t log_size = 1024 * 5;
@@ -227,11 +216,10 @@ TEST_F(AutoRollLoggerTest, RollLogFileByTime) {
   InitTestDb();
   // -- Test the existence of file during the server restart.
   ASSERT_EQ(Status::NotFound(), default_env->FileExists(kLogFile));
-  AutoRollLogger logger(default_env->GetFileSystem(), nsc, kTestDir, "",
-                        log_size, time, keep_log_file_num);
+  AutoRollLogger logger(&nse, kTestDir, "", log_size, time, keep_log_file_num);
   ASSERT_OK(default_env->FileExists(kLogFile));
 
-  RollLogFileByTimeTest(default_env->GetFileSystem(), nsc, &logger, time,
+  RollLogFileByTimeTest(&nse, &logger, time,
                         kSampleMessage + ":RollLogFileByTime");
 }
 
@@ -266,17 +254,15 @@ TEST_F(AutoRollLoggerTest, OpenLogFilesMultipleTimesWithOptionLog_max_size) {
   size_t log_size = 1024;
   size_t keep_log_file_num = 10;
 
-  AutoRollLogger* logger =
-      new AutoRollLogger(FileSystem::Default(), SystemClock::Default(),
-                         kTestDir, "", log_size, 0, keep_log_file_num);
+  AutoRollLogger* logger = new AutoRollLogger(Env::Default(), kTestDir, "",
+                                              log_size, 0, keep_log_file_num);
 
   LogMessage(logger, kSampleMessage.c_str());
   ASSERT_GT(logger->GetLogFileSize(), kZero);
   delete logger;
 
   // reopens the log file and an empty log file will be created.
-  logger = new AutoRollLogger(FileSystem::Default(), SystemClock::Default(),
-                              kTestDir, "", log_size, 0, 10);
+  logger = new AutoRollLogger(Env::Default(), kTestDir, "", log_size, 0, 10);
   ASSERT_EQ(logger->GetLogFileSize(), kZero);
   delete logger;
 }
@@ -287,16 +273,16 @@ TEST_F(AutoRollLoggerTest, CompositeRollByTimeAndSizeLogger) {
 
   InitTestDb();
 
-  auto nsc = std::make_shared<NoSleepClock>();
-  AutoRollLogger logger(FileSystem::Default(), nsc, kTestDir, "", log_max_size,
-                        time, keep_log_file_num);
+  NoSleepEnv nse(Env::Default());
+  AutoRollLogger logger(&nse, kTestDir, "", log_max_size, time,
+                        keep_log_file_num);
 
   // Test the ability to roll by size
   RollLogFileBySizeTest(&logger, log_max_size,
                         kSampleMessage + ":CompositeRollByTimeAndSizeLogger");
 
   // Test the ability to roll by Time
-  RollLogFileByTimeTest(FileSystem::Default(), nsc, &logger, time,
+  RollLogFileByTimeTest(&nse, &logger, time,
                         kSampleMessage + ":CompositeRollByTimeAndSizeLogger");
 }
 
@@ -305,9 +291,7 @@ TEST_F(AutoRollLoggerTest, CompositeRollByTimeAndSizeLogger) {
 // port
 TEST_F(AutoRollLoggerTest, CreateLoggerFromOptions) {
   DBOptions options;
-  auto nsc = std::make_shared<NoSleepClock>();
-  std::unique_ptr<Env> nse(new CompositeEnvWrapper(Env::Default(), nsc));
-
+  NoSleepEnv nse(Env::Default());
   std::shared_ptr<Logger> logger;
 
   // Normal logger
@@ -326,15 +310,14 @@ TEST_F(AutoRollLoggerTest, CreateLoggerFromOptions) {
       kSampleMessage + ":CreateLoggerFromOptions - size");
 
   // Only roll by Time
-  options.env = nse.get();
+  options.env = &nse;
   InitTestDb();
   options.max_log_file_size = 0;
   options.log_file_time_to_roll = 2;
   ASSERT_OK(CreateLoggerFromOptions(kTestDir, options, &logger));
   auto_roll_logger =
     dynamic_cast<AutoRollLogger*>(logger.get());
-  RollLogFileByTimeTest(options.env->GetFileSystem(), nsc, auto_roll_logger,
-                        options.log_file_time_to_roll,
+  RollLogFileByTimeTest(&nse, auto_roll_logger, options.log_file_time_to_roll,
                         kSampleMessage + ":CreateLoggerFromOptions - time");
 
   // roll by both Time and size
@@ -346,8 +329,7 @@ TEST_F(AutoRollLoggerTest, CreateLoggerFromOptions) {
     dynamic_cast<AutoRollLogger*>(logger.get());
   RollLogFileBySizeTest(auto_roll_logger, options.max_log_file_size,
                         kSampleMessage + ":CreateLoggerFromOptions - both");
-  RollLogFileByTimeTest(options.env->GetFileSystem(), nsc, auto_roll_logger,
-                        options.log_file_time_to_roll,
+  RollLogFileByTimeTest(&nse, auto_roll_logger, options.log_file_time_to_roll,
                         kSampleMessage + ":CreateLoggerFromOptions - both");
 
   // Set keep_log_file_num
@@ -420,8 +402,8 @@ TEST_F(AutoRollLoggerTest, AutoDeleting) {
     const size_t kMaxFileSize = 512;
     {
       size_t log_num = 8;
-      AutoRollLogger logger(FileSystem::Default(), SystemClock::Default(),
-                            dbname, db_log_dir, kMaxFileSize, 0, log_num);
+      AutoRollLogger logger(Env::Default(), dbname, db_log_dir, kMaxFileSize, 0,
+                            log_num);
       RollNTimesBySize(&logger, log_num, kMaxFileSize);
 
       ASSERT_EQ(log_num, GetLogFiles().size());
@@ -429,8 +411,8 @@ TEST_F(AutoRollLoggerTest, AutoDeleting) {
     // Shrink number of files
     {
       size_t log_num = 5;
-      AutoRollLogger logger(FileSystem::Default(), SystemClock::Default(),
-                            dbname, db_log_dir, kMaxFileSize, 0, log_num);
+      AutoRollLogger logger(Env::Default(), dbname, db_log_dir, kMaxFileSize, 0,
+                            log_num);
       ASSERT_EQ(log_num, GetLogFiles().size());
 
       RollNTimesBySize(&logger, 3, kMaxFileSize);
@@ -440,8 +422,8 @@ TEST_F(AutoRollLoggerTest, AutoDeleting) {
     // Increase number of files again.
     {
       size_t log_num = 7;
-      AutoRollLogger logger(FileSystem::Default(), SystemClock::Default(),
-                            dbname, db_log_dir, kMaxFileSize, 0, log_num);
+      AutoRollLogger logger(Env::Default(), dbname, db_log_dir, kMaxFileSize, 0,
+                            log_num);
       ASSERT_EQ(6, GetLogFiles().size());
 
       RollNTimesBySize(&logger, 3, kMaxFileSize);
@@ -503,8 +485,7 @@ TEST_F(AutoRollLoggerTest, InfoLogLevel) {
   // an extra-scope to force the AutoRollLogger to flush the log file when it
   // becomes out of scope.
   {
-    AutoRollLogger logger(FileSystem::Default(), SystemClock::Default(),
-                          kTestDir, "", log_size, 0, 10);
+    AutoRollLogger logger(Env::Default(), kTestDir, "", log_size, 0, 10);
     for (int log_level = InfoLogLevel::HEADER_LEVEL;
          log_level >= InfoLogLevel::DEBUG_LEVEL; log_level--) {
       logger.SetInfoLogLevel((InfoLogLevel)log_level);
@@ -542,8 +523,7 @@ TEST_F(AutoRollLoggerTest, Close) {
 
   size_t log_size = 8192;
   size_t log_lines = 0;
-  AutoRollLogger logger(FileSystem::Default(), SystemClock::Default(), kTestDir,
-                        "", log_size, 0, 10);
+  AutoRollLogger logger(Env::Default(), kTestDir, "", log_size, 0, 10);
   for (int log_level = InfoLogLevel::HEADER_LEVEL;
        log_level >= InfoLogLevel::DEBUG_LEVEL; log_level--) {
     logger.SetInfoLogLevel((InfoLogLevel)log_level);
@@ -610,9 +590,8 @@ TEST_F(AutoRollLoggerTest, LogHeaderTest) {
 
     InitTestDb();
 
-    AutoRollLogger logger(FileSystem::Default(), SystemClock::Default(),
-                          kTestDir, /*db_log_dir=*/"", LOG_MAX_SIZE,
-                          /*log_file_time_to_roll=*/0,
+    AutoRollLogger logger(Env::Default(), kTestDir, /*db_log_dir=*/"",
+                          LOG_MAX_SIZE, /*log_file_time_to_roll=*/0,
                           /*keep_log_file_num=*/10);
 
     if (test_num == 0) {