rocksdb-native 2.6.2 → 2.6.4

package/vendor/librocksdb/vendor/rocksdb/trace_replay/trace_replay.h

@@ -1,184 +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).
-
-#pragma once
-
-#include <atomic>
-#include <memory>
-#include <mutex>
-#include <unordered_map>
-#include <utility>
-
-#include "rocksdb/options.h"
-#include "rocksdb/rocksdb_namespace.h"
-#include "rocksdb/status.h"
-#include "rocksdb/trace_record.h"
-#include "rocksdb/utilities/replayer.h"
-
-namespace ROCKSDB_NAMESPACE {
-
-// This file contains Tracer and Replayer classes that enable capturing and
-// replaying RocksDB traces.
-
-class ColumnFamilyHandle;
-class ColumnFamilyData;
-class DB;
-class DBImpl;
-class Env;
-class Slice;
-class SystemClock;
-class TraceReader;
-class TraceWriter;
-class WriteBatch;
-
-struct ReadOptions;
-struct TraceOptions;
-struct WriteOptions;
-
-extern const std::string kTraceMagic;
-const unsigned int kTraceTimestampSize = 8;
-const unsigned int kTraceTypeSize = 1;
-const unsigned int kTracePayloadLengthSize = 4;
-const unsigned int kTraceMetadataSize =
-    kTraceTimestampSize + kTraceTypeSize + kTracePayloadLengthSize;
-
-static const int kTraceFileMajorVersion = 0;
-static const int kTraceFileMinorVersion = 2;
-
-// The data structure that defines a single trace.
-struct Trace {
-  uint64_t ts;  // timestamp
-  TraceType type;
-  // Each bit in payload_map stores which corresponding struct member added in
-  // the payload. Each TraceType has its corresponding payload struct. For
-  // example, if bit at position 0 is set in write payload, then the write batch
-  // will be addedd.
-  uint64_t payload_map = 0;
-  // Each trace type has its own payload_struct, which will be serialized in the
-  // payload.
-  std::string payload;
-
-  void reset() {
-    ts = 0;
-    type = kTraceMax;
-    payload_map = 0;
-    payload.clear();
-  }
-};
-
-enum TracePayloadType : char {
-  // Each member of all query payload structs should have a corresponding flag
-  // here. Make sure to add them sequentially in the order of it is added.
-  kEmptyPayload = 0,
-  kWriteBatchData = 1,
-  kGetCFID = 2,
-  kGetKey = 3,
-  kIterCFID = 4,
-  kIterKey = 5,
-  kIterLowerBound = 6,
-  kIterUpperBound = 7,
-  kMultiGetSize = 8,
-  kMultiGetCFIDs = 9,
-  kMultiGetKeys = 10,
-};
-
-class TracerHelper {
- public:
-  // Parse the string with major and minor version only
-  static Status ParseVersionStr(std::string& v_string, int* v_num);
-
-  // Parse the trace file version and db version in trace header
-  static Status ParseTraceHeader(const Trace& header, int* trace_version,
-                                 int* db_version);
-
-  // Encode a version 0.1 trace object into the given string.
-  static void EncodeTrace(const Trace& trace, std::string* encoded_trace);
-
-  // Decode a string into the given trace object.
-  static Status DecodeTrace(const std::string& encoded_trace, Trace* trace);
-
-  // Decode a string into the given trace header.
-  static Status DecodeHeader(const std::string& encoded_trace, Trace* header);
-
-  // Set the payload map based on the payload type
-  static bool SetPayloadMap(uint64_t& payload_map,
-                            const TracePayloadType payload_type);
-
-  // Decode a Trace object into the corresponding TraceRecord.
-  // Return Status::OK() if nothing is wrong, record will be set accordingly.
-  // Return Status::NotSupported() if the trace type is not support, or the
-  // corresponding error status, record will be set to nullptr.
-  static Status DecodeTraceRecord(Trace* trace, int trace_file_version,
-                                  std::unique_ptr<TraceRecord>* record);
-};
-
-// Tracer captures all RocksDB operations using a user-provided TraceWriter.
-// Every RocksDB operation is written as a single trace. Each trace will have a
-// timestamp and type, followed by the trace payload.
-class Tracer {
- public:
-  Tracer(SystemClock* clock, const TraceOptions& trace_options,
-         std::unique_ptr<TraceWriter>&& trace_writer);
-  ~Tracer();
-
-  // Trace all write operations -- Put, Merge, Delete, SingleDelete, Write
-  Status Write(WriteBatch* write_batch);
-
-  // Trace Get operations.
-  Status Get(ColumnFamilyHandle* cfname, const Slice& key);
-
-  // Trace Iterators.
-  Status IteratorSeek(const uint32_t& cf_id, const Slice& key,
-                      const Slice& lower_bound, const Slice upper_bound);
-  Status IteratorSeekForPrev(const uint32_t& cf_id, const Slice& key,
-                             const Slice& lower_bound, const Slice upper_bound);
-
-  // Trace MultiGet
-
-  Status MultiGet(const size_t num_keys, ColumnFamilyHandle** column_families,
-                  const Slice* keys);
-
-  Status MultiGet(const size_t num_keys, ColumnFamilyHandle* column_family,
-                  const Slice* keys);
-
-  Status MultiGet(const std::vector<ColumnFamilyHandle*>& column_family,
-                  const std::vector<Slice>& keys);
-
-  // Returns true if the trace is over the configured max trace file limit.
-  // False otherwise.
-  bool IsTraceFileOverMax();
-
-  // Returns true if the order of write trace records must match the order of
-  // the corresponding records logged to WAL and applied to the DB.
-  bool IsWriteOrderPreserved() { return trace_options_.preserve_write_order; }
-
-  // Writes a trace footer at the end of the tracing
-  Status Close();
-
- private:
-  // Write a trace header at the beginning, typically on initiating a trace,
-  // with some metadata like a magic number, trace version, RocksDB version, and
-  // trace format.
-  Status WriteHeader();
-
-  // Write a trace footer, typically on ending a trace, with some metadata.
-  Status WriteFooter();
-
-  // Write a single trace using the provided TraceWriter to the underlying
-  // system, say, a filesystem or a streaming service.
-  Status WriteTrace(const Trace& trace);
-
-  // Helps in filtering and sampling of traces.
-  // Returns true if a trace should be skipped, false otherwise.
-  bool ShouldSkipTrace(const TraceType& type);
-
-  SystemClock* clock_;
-  TraceOptions trace_options_;
-  std::unique_ptr<TraceWriter> trace_writer_;
-  uint64_t trace_request_count_;
-  Status trace_write_status_;
-};
-
-}  // namespace ROCKSDB_NAMESPACE

package/vendor/librocksdb/vendor/rocksdb/util/aligned_buffer.h

@@ -1,235 +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 <algorithm>
-#include <cassert>
-
-#include "port/port.h"
-
-namespace ROCKSDB_NAMESPACE {
-
-// This file contains utilities to handle the alignment of pages and buffers.
-
-// Truncate to a multiple of page_size, which is also a page boundary. This
-// helps to figuring out the right alignment.
-// Example:
-//   TruncateToPageBoundary(4096, 5000)  => 4096
-//   TruncateToPageBoundary((4096, 10000) => 8192
-inline size_t TruncateToPageBoundary(size_t page_size, size_t s) {
-  s -= (s & (page_size - 1));
-  assert((s % page_size) == 0);
-  return s;
-}
-
-// Round up x to a multiple of y.
-// Example:
-//   Roundup(13, 5)   => 15
-//   Roundup(201, 16) => 208
-inline size_t Roundup(size_t x, size_t y) { return ((x + y - 1) / y) * y; }
-
-// Round down x to a multiple of y.
-// Example:
-//   Rounddown(13, 5)   => 10
-//   Rounddown(201, 16) => 192
-inline size_t Rounddown(size_t x, size_t y) { return (x / y) * y; }
-
-// AlignedBuffer manages a buffer by taking alignment into consideration, and
-// aligns the buffer start and end positions. It is mainly used for direct I/O,
-// though it can be used other purposes as well.
-// It also supports expanding the managed buffer, and copying whole or part of
-// the data from old buffer into the new expanded buffer. Such a copy especially
-// helps in cases avoiding an IO to re-fetch the data from disk.
-//
-// Example:
-//   AlignedBuffer buf;
-//   buf.Alignment(alignment);
-//   buf.AllocateNewBuffer(user_requested_buf_size);
-//   ...
-//   buf.AllocateNewBuffer(2*user_requested_buf_size, /*copy_data*/ true,
-//                         copy_offset, copy_len);
-class AlignedBuffer {
-  size_t alignment_;
-  std::unique_ptr<char[]> buf_;
-  size_t capacity_;
-  size_t cursize_;
-  char* bufstart_;
-
- public:
-  AlignedBuffer()
-      : alignment_(), capacity_(0), cursize_(0), bufstart_(nullptr) {}
-
-  AlignedBuffer(AlignedBuffer&& o) noexcept { *this = std::move(o); }
-
-  AlignedBuffer& operator=(AlignedBuffer&& o) noexcept {
-    alignment_ = std::move(o.alignment_);
-    buf_ = std::move(o.buf_);
-    capacity_ = std::move(o.capacity_);
-    cursize_ = std::move(o.cursize_);
-    bufstart_ = std::move(o.bufstart_);
-    return *this;
-  }
-
-  AlignedBuffer(const AlignedBuffer&) = delete;
-
-  AlignedBuffer& operator=(const AlignedBuffer&) = delete;
-
-  static bool isAligned(const void* ptr, size_t alignment) {
-    return reinterpret_cast<uintptr_t>(ptr) % alignment == 0;
-  }
-
-  static bool isAligned(size_t n, size_t alignment) {
-    return n % alignment == 0;
-  }
-
-  size_t Alignment() const { return alignment_; }
-
-  size_t Capacity() const { return capacity_; }
-
-  size_t CurrentSize() const { return cursize_; }
-
-  const char* BufferStart() const { return bufstart_; }
-
-  char* BufferStart() { return bufstart_; }
-
-  void Clear() { cursize_ = 0; }
-
-  char* Release() {
-    cursize_ = 0;
-    capacity_ = 0;
-    bufstart_ = nullptr;
-    return buf_.release();
-  }
-
-  void Alignment(size_t alignment) {
-    assert(alignment > 0);
-    assert((alignment & (alignment - 1)) == 0);
-    alignment_ = alignment;
-  }
-
-  // Allocates a new buffer and sets the start position to the first aligned
-  // byte.
-  //
-  // requested_capacity: requested new buffer capacity. This capacity will be
-  //     rounded up based on alignment.
-  // copy_data: Copy data from old buffer to new buffer. If copy_offset and
-  //     copy_len are not passed in and the new requested capacity is bigger
-  //     than the existing buffer's capacity, the data in the exising buffer is
-  //     fully copied over to the new buffer.
-  // copy_offset: Copy data from this offset in old buffer.
-  // copy_len: Number of bytes to copy.
-  //
-  // The function does nothing if the new requested_capacity is smaller than
-  // the current buffer capacity and copy_data is true i.e. the old buffer is
-  // retained as is.
-  void AllocateNewBuffer(size_t requested_capacity, bool copy_data = false,
-                         uint64_t copy_offset = 0, size_t copy_len = 0) {
-    assert(alignment_ > 0);
-    assert((alignment_ & (alignment_ - 1)) == 0);
-
-    copy_len = copy_len > 0 ? copy_len : cursize_;
-    if (copy_data && requested_capacity < copy_len) {
-      // If we are downsizing to a capacity that is smaller than the current
-      // data in the buffer -- Ignore the request.
-      return;
-    }
-
-    size_t new_capacity = Roundup(requested_capacity, alignment_);
-    char* new_buf = new char[new_capacity + alignment_];
-    char* new_bufstart = reinterpret_cast<char*>(
-        (reinterpret_cast<uintptr_t>(new_buf) + (alignment_ - 1)) &
-        ~static_cast<uintptr_t>(alignment_ - 1));
-
-    if (copy_data) {
-      assert(bufstart_ + copy_offset + copy_len <= bufstart_ + cursize_);
-      memcpy(new_bufstart, bufstart_ + copy_offset, copy_len);
-      cursize_ = copy_len;
-    } else {
-      cursize_ = 0;
-    }
-
-    bufstart_ = new_bufstart;
-    capacity_ = new_capacity;
-    buf_.reset(new_buf);
-  }
-
-  // Append to the buffer.
-  //
-  // src         : source to copy the data from.
-  // append_size : number of bytes to copy from src.
-  // Returns the number of bytes appended.
-  //
-  // If append_size is more than the remaining buffer size only the
-  // remaining-size worth of bytes are copied.
-  size_t Append(const char* src, size_t append_size) {
-    size_t buffer_remaining = capacity_ - cursize_;
-    size_t to_copy = std::min(append_size, buffer_remaining);
-
-    if (to_copy > 0) {
-      memcpy(bufstart_ + cursize_, src, to_copy);
-      cursize_ += to_copy;
-    }
-    return to_copy;
-  }
-
-  // Read from the buffer.
-  //
-  // dest      : destination buffer to copy the data to.
-  // offset    : the buffer offset to start reading from.
-  // read_size : the number of bytes to copy from the buffer to dest.
-  // Returns the number of bytes read/copied to dest.
-  size_t Read(char* dest, size_t offset, size_t read_size) const {
-    assert(offset < cursize_);
-
-    size_t to_read = 0;
-    if (offset < cursize_) {
-      to_read = std::min(cursize_ - offset, read_size);
-    }
-    if (to_read > 0) {
-      memcpy(dest, bufstart_ + offset, to_read);
-    }
-    return to_read;
-  }
-
-  // Pad to the end of alignment with "padding"
-  void PadToAlignmentWith(int padding) {
-    size_t total_size = Roundup(cursize_, alignment_);
-    size_t pad_size = total_size - cursize_;
-
-    if (pad_size > 0) {
-      assert((pad_size + cursize_) <= capacity_);
-      memset(bufstart_ + cursize_, padding, pad_size);
-      cursize_ += pad_size;
-    }
-  }
-
-  void PadWith(size_t pad_size, int padding) {
-    assert((pad_size + cursize_) <= capacity_);
-    memset(bufstart_ + cursize_, padding, pad_size);
-    cursize_ += pad_size;
-  }
-
-  // After a partial flush move the tail to the beginning of the buffer.
-  void RefitTail(size_t tail_offset, size_t tail_size) {
-    if (tail_size > 0) {
-      memmove(bufstart_, bufstart_ + tail_offset, tail_size);
-    }
-    cursize_ = tail_size;
-  }
-
-  // Returns a place to start appending.
-  // WARNING: Note that it is possible to write past the end of the buffer if
-  // the buffer is modified without using the write APIs or encapsulation
-  // offered by AlignedBuffer. It is up to the user to guard against such
-  // errors.
-  char* Destination() { return bufstart_ + cursize_; }
-
-  void Size(size_t cursize) { cursize_ = cursize; }
-};
-}  // namespace ROCKSDB_NAMESPACE

package/vendor/librocksdb/vendor/rocksdb/util/aligned_storage.h

@@ -1,24 +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 <cstddef>
-
-#include "rocksdb/rocksdb_namespace.h"
-
-namespace ROCKSDB_NAMESPACE {
-
-template <typename T, std::size_t Align = alignof(T)>
-struct aligned_storage {
-  struct type {
-    alignas(Align) unsigned char data[sizeof(T)];
-  };
-};
-
-}  // namespace ROCKSDB_NAMESPACE

package/vendor/librocksdb/vendor/rocksdb/util/async_file_reader.cc

@@ -1,84 +0,0 @@
-//  Copyright (c) Meta Platforms, Inc. and affiliates.
-//
-//  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).
-//
-#if USE_COROUTINES
-#include "util/async_file_reader.h"
-
-namespace ROCKSDB_NAMESPACE {
-bool AsyncFileReader::MultiReadAsyncImpl(ReadAwaiter* awaiter) {
-  if (tail_) {
-    tail_->next_ = awaiter;
-  }
-  tail_ = awaiter;
-  if (!head_) {
-    head_ = awaiter;
-  }
-  num_reqs_ += awaiter->num_reqs_;
-  awaiter->io_handle_.resize(awaiter->num_reqs_);
-  awaiter->del_fn_.resize(awaiter->num_reqs_);
-  for (size_t i = 0; i < awaiter->num_reqs_; ++i) {
-    IOStatus s = awaiter->file_->ReadAsync(
-        awaiter->read_reqs_[i], awaiter->opts_,
-        [](FSReadRequest& req, void* cb_arg) {
-          FSReadRequest* read_req = static_cast<FSReadRequest*>(cb_arg);
-          read_req->status = req.status;
-          read_req->result = req.result;
-          if (req.fs_scratch != nullptr) {
-            read_req->fs_scratch = std::move(req.fs_scratch);
-          }
-        },
-        &awaiter->read_reqs_[i], &awaiter->io_handle_[i], &awaiter->del_fn_[i],
-        /*aligned_buf=*/nullptr);
-    if (!s.ok()) {
-      // For any non-ok status, the FileSystem will not call the callback
-      // So let's update the status ourselves
-      awaiter->read_reqs_[i].status = s;
-    }
-  }
-  return true;
-}
-
-void AsyncFileReader::Wait() {
-  if (!head_) {
-    return;
-  }
-  ReadAwaiter* waiter;
-  std::vector<void*> io_handles;
-  IOStatus s;
-  io_handles.reserve(num_reqs_);
-  waiter = head_;
-  do {
-    for (size_t i = 0; i < waiter->num_reqs_; ++i) {
-      if (waiter->io_handle_[i]) {
-        io_handles.push_back(waiter->io_handle_[i]);
-      }
-    }
-  } while (waiter != tail_ && (waiter = waiter->next_));
-  if (io_handles.size() > 0) {
-    StopWatch sw(SystemClock::Default().get(), stats_, POLL_WAIT_MICROS);
-    s = fs_->Poll(io_handles, io_handles.size());
-  }
-  do {
-    waiter = head_;
-    head_ = waiter->next_;
-
-    for (size_t i = 0; i < waiter->num_reqs_; ++i) {
-      if (waiter->io_handle_[i] && waiter->del_fn_[i]) {
-        waiter->del_fn_[i](waiter->io_handle_[i]);
-      }
-      if (waiter->read_reqs_[i].status.ok() && !s.ok()) {
-        // Override the request status with the Poll error
-        waiter->read_reqs_[i].status = s;
-      }
-    }
-    waiter->awaiting_coro_.resume();
-  } while (waiter != tail_);
-  head_ = tail_ = nullptr;
-  RecordInHistogram(stats_, MULTIGET_IO_BATCH_SIZE, num_reqs_);
-  num_reqs_ = 0;
-}
-}  // namespace ROCKSDB_NAMESPACE
-#endif  // USE_COROUTINES

package/vendor/librocksdb/vendor/rocksdb/util/async_file_reader.h

@@ -1,144 +0,0 @@
-//  Copyright (c) Meta Platforms, Inc. and affiliates.
-//
-//  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).#pragma once
-#pragma once
-
-#if USE_COROUTINES
-#include "file/random_access_file_reader.h"
-#include "folly/experimental/coro/ViaIfAsync.h"
-#include "port/port.h"
-#include "rocksdb/file_system.h"
-#include "rocksdb/statistics.h"
-#include "util/autovector.h"
-#include "util/stop_watch.h"
-
-namespace ROCKSDB_NAMESPACE {
-class SingleThreadExecutor;
-
-// AsyncFileReader implements the Awaitable concept, which allows calling
-// coroutines to co_await it. When the AsyncFileReader Awaitable is
-// resumed, it initiates the fie reads requested by the awaiting caller
-// by calling RandomAccessFileReader's ReadAsync. It then suspends the
-// awaiting coroutine. The suspended awaiter is later resumed by Wait().
-class AsyncFileReader {
-  class ReadAwaiter;
-  template <typename Awaiter>
-  class ReadOperation;
-
- public:
-  AsyncFileReader(FileSystem* fs, Statistics* stats) : fs_(fs), stats_(stats) {}
-
-  ~AsyncFileReader() {}
-
-  ReadOperation<ReadAwaiter> MultiReadAsync(RandomAccessFileReader* file,
-                                            const IOOptions& opts,
-                                            FSReadRequest* read_reqs,
-                                            size_t num_reqs,
-                                            AlignedBuf* aligned_buf) noexcept {
-    return ReadOperation<ReadAwaiter>{*this,     file,     opts,
-                                      read_reqs, num_reqs, aligned_buf};
-  }
-
- private:
-  friend SingleThreadExecutor;
-
-  // Implementation of the Awaitable concept
-  class ReadAwaiter {
-   public:
-    explicit ReadAwaiter(AsyncFileReader& reader, RandomAccessFileReader* file,
-                         const IOOptions& opts, FSReadRequest* read_reqs,
-                         size_t num_reqs, AlignedBuf* /*aligned_buf*/) noexcept
-        : reader_(reader),
-          file_(file),
-          opts_(opts),
-          read_reqs_(read_reqs),
-          num_reqs_(num_reqs),
-          next_(nullptr) {}
-
-    bool await_ready() noexcept { return false; }
-
-    // A return value of true means suspend the awaiter (calling coroutine). The
-    // awaiting_coro parameter is the handle of the awaiter. The handle can be
-    // resumed later, so we cache it here.
-    bool await_suspend(
-        folly::coro::impl::coroutine_handle<> awaiting_coro) noexcept {
-      awaiting_coro_ = awaiting_coro;
-      // MultiReadAsyncImpl always returns true, so caller will be suspended
-      return reader_.MultiReadAsyncImpl(this);
-    }
-
-    void await_resume() noexcept {}
-
-   private:
-    friend AsyncFileReader;
-
-    // The parameters passed to MultiReadAsync are cached here when the caller
-    // calls MultiReadAsync. Later, when the execution of this awaitable is
-    // started, these are used to do the actual IO
-    AsyncFileReader& reader_;
-    RandomAccessFileReader* file_;
-    const IOOptions& opts_;
-    FSReadRequest* read_reqs_;
-    size_t num_reqs_;
-    autovector<void*, 32> io_handle_;
-    autovector<IOHandleDeleter, 32> del_fn_;
-    folly::coro::impl::coroutine_handle<> awaiting_coro_;
-    // Use this to link to the next ReadAwaiter in the suspended coroutine
-    // list. The head and tail of the list are tracked by AsyncFileReader.
-    // We use this approach rather than an STL container in order to avoid
-    // extra memory allocations. The coroutine call already allocates a
-    // ReadAwaiter object.
-    ReadAwaiter* next_;
-  };
-
-  // An instance of ReadOperation is returned to the caller of MultiGetAsync.
-  // This represents an awaitable that can be started later.
-  template <typename Awaiter>
-  class ReadOperation {
-   public:
-    explicit ReadOperation(AsyncFileReader& reader,
-                           RandomAccessFileReader* file, const IOOptions& opts,
-                           FSReadRequest* read_reqs, size_t num_reqs,
-                           AlignedBuf* aligned_buf) noexcept
-        : reader_(reader),
-          file_(file),
-          opts_(opts),
-          read_reqs_(read_reqs),
-          num_reqs_(num_reqs),
-          aligned_buf_(aligned_buf) {}
-
-    auto viaIfAsync(folly::Executor::KeepAlive<> executor) const {
-      return folly::coro::co_viaIfAsync(
-          std::move(executor),
-          Awaiter{reader_, file_, opts_, read_reqs_, num_reqs_, aligned_buf_});
-    }
-
-   private:
-    AsyncFileReader& reader_;
-    RandomAccessFileReader* file_;
-    const IOOptions& opts_;
-    FSReadRequest* read_reqs_;
-    size_t num_reqs_;
-    AlignedBuf* aligned_buf_;
-  };
-
-  // This function does the actual work when this awaitable starts execution
-  bool MultiReadAsyncImpl(ReadAwaiter* awaiter);
-
-  // Called by the SingleThreadExecutor to poll for async IO completion.
-  // This also resumes the awaiting coroutines.
-  void Wait();
-
-  // Head of the queue of awaiters waiting for async IO completion
-  ReadAwaiter* head_ = nullptr;
-  // Tail of the awaiter queue
-  ReadAwaiter* tail_ = nullptr;
-  // Total number of pending async IOs
-  size_t num_reqs_ = 0;
-  FileSystem* fs_;
-  Statistics* stats_;
-};
-}  // namespace ROCKSDB_NAMESPACE
-#endif  // USE_COROUTINES