rocksdb-native 2.6.2 → 2.6.4

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

@@ -1,120 +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 <functional>
-#include <memory>
-
-#include "rocksdb/env.h"
-#include "rocksdb/threadpool.h"
-
-namespace ROCKSDB_NAMESPACE {
-
-class ThreadPoolImpl : public ThreadPool {
- public:
-  ThreadPoolImpl();
-  ~ThreadPoolImpl();
-
-  ThreadPoolImpl(ThreadPoolImpl&&) = delete;
-  ThreadPoolImpl& operator=(ThreadPoolImpl&&) = delete;
-
-  // Implement ThreadPool interfaces
-
-  // Wait for all threads to finish.
-  // Discards all the jobs that did not
-  // start executing and waits for those running
-  // to complete
-  void JoinAllThreads() override;
-
-  // Set the number of background threads that will be executing the
-  // scheduled jobs.
-  void SetBackgroundThreads(int num) override;
-  int GetBackgroundThreads() override;
-
-  // Get the number of jobs scheduled in the ThreadPool queue.
-  unsigned int GetQueueLen() const override;
-
-  // Waits for all jobs to complete those
-  // that already started running and those that did not
-  // start yet
-  void WaitForJobsAndJoinAllThreads() override;
-
-  // Make threads to run at a lower kernel IO priority
-  // Currently only has effect on Linux
-  void LowerIOPriority();
-
-  // Make threads to run at a lower kernel CPU priority
-  // Currently only has effect on Linux
-  void LowerCPUPriority(CpuPriority pri);
-
-  // Ensure there is at aleast num threads in the pool
-  // but do not kill threads if there are more
-  void IncBackgroundThreadsIfNeeded(int num);
-
-  // Submit a fire and forget job
-  // These jobs can not be unscheduled
-
-  // This allows to submit the same job multiple times
-  void SubmitJob(const std::function<void()>&) override;
-  // This moves the function in for efficiency
-  void SubmitJob(std::function<void()>&&) override;
-
-  // Schedule a job with an unschedule tag and unschedule function
-  // Can be used to filter and unschedule jobs by a tag
-  // that are still in the queue and did not start running
-  void Schedule(void (*function)(void* arg1), void* arg, void* tag,
-                void (*unschedFunction)(void* arg));
-
-  // Filter jobs that are still in a queue and match
-  // the given tag. Remove them from a queue if any
-  // and for each such job execute an unschedule function
-  // if such was given at scheduling time.
-  int UnSchedule(void* tag);
-
-  void SetHostEnv(Env* env);
-
-  Env* GetHostEnv() const;
-
-  // Return the thread priority.
-  // This would allow its member-thread to know its priority.
-  Env::Priority GetThreadPriority() const;
-
-  // Set the thread priority.
-  void SetThreadPriority(Env::Priority priority);
-
-  // Reserve a specific number of threads, prevent them from running other
-  // functions The number of reserved threads could be fewer than the desired
-  // one
-  int ReserveThreads(int threads_to_be_reserved) override;
-
-  // Release a specific number of threads
-  int ReleaseThreads(int threads_to_be_released) override;
-
-  static void PthreadCall(const char* label, int result);
-
-  struct Impl;
-
- private:
-  // Current public interface does not provide usable
-  // functionality and thus can not be used internally to
-  // facade different implementations.
-  //
-  // We propose a pimpl idiom in order to easily replace the thread pool impl
-  // w/o touching the header file but providing a different .cc potentially
-  // CMake option driven.
-  //
-  // Another option is to introduce a Env::MakeThreadPool() virtual interface
-  // and override the environment. This would require refactoring ThreadPool
-  // usage.
-  //
-  // We can also combine these two approaches
-  std::unique_ptr<Impl> impl_;
-};
-
-}  // namespace ROCKSDB_NAMESPACE

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

@@ -1,340 +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 <functional>
-#include <memory>
-#include <queue>
-#include <unordered_map>
-#include <utility>
-#include <vector>
-
-#include "monitoring/instrumented_mutex.h"
-#include "rocksdb/system_clock.h"
-#include "test_util/sync_point.h"
-#include "util/mutexlock.h"
-
-namespace ROCKSDB_NAMESPACE {
-
-// A Timer class to handle repeated work.
-//
-// `Start()` and `Shutdown()` are currently not thread-safe. The client must
-// serialize calls to these two member functions.
-//
-// A single timer instance can handle multiple functions via a single thread.
-// It is better to leave long running work to a dedicated thread pool.
-//
-// Timer can be started by calling `Start()`, and ended by calling `Shutdown()`.
-// Work (in terms of a `void function`) can be scheduled by calling `Add` with
-// a unique function name and de-scheduled by calling `Cancel`.
-// Many functions can be added.
-//
-// Impl Details:
-// A heap is used to keep track of when the next timer goes off.
-// A map from a function name to the function keeps track of all the functions.
-class Timer {
- public:
-  explicit Timer(SystemClock* clock)
-      : clock_(clock),
-        mutex_(clock),
-        cond_var_(&mutex_),
-        running_(false),
-        executing_task_(false) {}
-
-  ~Timer() { Shutdown(); }
-
-  // Add a new function to run.
-  // fn_name has to be identical, otherwise it will fail to add and return false
-  // start_after_us is the initial delay.
-  // repeat_every_us is the interval between ending time of the last call and
-  // starting time of the next call. For example, repeat_every_us = 2000 and
-  // the function takes 1000us to run. If it starts at time [now]us, then it
-  // finishes at [now]+1000us, 2nd run starting time will be at [now]+3000us.
-  // repeat_every_us == 0 means do not repeat.
-  bool Add(std::function<void()> fn, const std::string& fn_name,
-           uint64_t start_after_us, uint64_t repeat_every_us) {
-    auto fn_info = std::make_unique<FunctionInfo>(std::move(fn), fn_name, 0,
-                                                  repeat_every_us);
-    InstrumentedMutexLock l(&mutex_);
-    // Assign time within mutex to make sure the next_run_time is larger than
-    // the current running one
-    fn_info->next_run_time_us = clock_->NowMicros() + start_after_us;
-    // the new task start time should never before the current task executing
-    // time, as the executing task can only be running if it's next_run_time_us
-    // is due (<= clock_->NowMicros()).
-    if (executing_task_ &&
-        fn_info->next_run_time_us < heap_.top()->next_run_time_us) {
-      return false;
-    }
-    auto it = map_.find(fn_name);
-    if (it == map_.end()) {
-      heap_.push(fn_info.get());
-      map_.try_emplace(fn_name, std::move(fn_info));
-    } else {
-      // timer doesn't support duplicated function name
-      return false;
-    }
-    cond_var_.SignalAll();
-    return true;
-  }
-
-  void Cancel(const std::string& fn_name) {
-    InstrumentedMutexLock l(&mutex_);
-
-    // Mark the function with fn_name as invalid so that it will not be
-    // requeued.
-    auto it = map_.find(fn_name);
-    if (it != map_.end() && it->second) {
-      it->second->Cancel();
-    }
-
-    // If the currently running function is fn_name, then we need to wait
-    // until it finishes before returning to caller.
-    while (!heap_.empty() && executing_task_) {
-      FunctionInfo* func_info = heap_.top();
-      assert(func_info);
-      if (func_info->name == fn_name) {
-        WaitForTaskCompleteIfNecessary();
-      } else {
-        break;
-      }
-    }
-  }
-
-  void CancelAll() {
-    InstrumentedMutexLock l(&mutex_);
-    CancelAllWithLock();
-  }
-
-  // Start the Timer
-  bool Start() {
-    InstrumentedMutexLock l(&mutex_);
-    if (running_) {
-      return false;
-    }
-
-    running_ = true;
-    thread_ = std::make_unique<port::Thread>(&Timer::Run, this);
-    return true;
-  }
-
-  // Shutdown the Timer
-  bool Shutdown() {
-    {
-      InstrumentedMutexLock l(&mutex_);
-      if (!running_) {
-        return false;
-      }
-      running_ = false;
-      CancelAllWithLock();
-      cond_var_.SignalAll();
-    }
-
-    if (thread_) {
-      thread_->join();
-    }
-    return true;
-  }
-
-  bool HasPendingTask() const {
-    InstrumentedMutexLock l(&mutex_);
-    for (const auto& fn_info : map_) {
-      if (fn_info.second->IsValid()) {
-        return true;
-      }
-    }
-    return false;
-  }
-
-#ifndef NDEBUG
-  // Wait until Timer starting waiting, call the optional callback, then wait
-  // for Timer waiting again.
-  // Tests can provide a custom Clock object to mock time, and use the callback
-  // here to bump current time and trigger Timer. See timer_test for example.
-  //
-  // Note: only support one caller of this method.
-  void TEST_WaitForRun(const std::function<void()>& callback = nullptr) {
-    InstrumentedMutexLock l(&mutex_);
-    // It act as a spin lock
-    while (executing_task_ ||
-           (!heap_.empty() &&
-            heap_.top()->next_run_time_us <= clock_->NowMicros())) {
-      cond_var_.TimedWait(clock_->NowMicros() + 1000);
-    }
-    if (callback != nullptr) {
-      callback();
-    }
-    cond_var_.SignalAll();
-    do {
-      cond_var_.TimedWait(clock_->NowMicros() + 1000);
-    } while (executing_task_ ||
-             (!heap_.empty() &&
-              heap_.top()->next_run_time_us <= clock_->NowMicros()));
-  }
-
-  size_t TEST_GetPendingTaskNum() const {
-    InstrumentedMutexLock l(&mutex_);
-    size_t ret = 0;
-    for (const auto& fn_info : map_) {
-      if (fn_info.second->IsValid()) {
-        ret++;
-      }
-    }
-    return ret;
-  }
-
-  void TEST_OverrideTimer(SystemClock* clock) {
-    InstrumentedMutexLock l(&mutex_);
-    clock_ = clock;
-  }
-#endif  // NDEBUG
-
- private:
-  void Run() {
-    InstrumentedMutexLock l(&mutex_);
-
-    while (running_) {
-      if (heap_.empty()) {
-        // wait
-        TEST_SYNC_POINT("Timer::Run::Waiting");
-        cond_var_.Wait();
-        continue;
-      }
-
-      FunctionInfo* current_fn = heap_.top();
-      assert(current_fn);
-
-      if (!current_fn->IsValid()) {
-        heap_.pop();
-        map_.erase(current_fn->name);
-        continue;
-      }
-
-      if (current_fn->next_run_time_us <= clock_->NowMicros()) {
-        // make a copy of the function so it won't be changed after
-        // mutex_.unlock.
-        std::function<void()> fn = current_fn->fn;
-        executing_task_ = true;
-        mutex_.Unlock();
-        // Execute the work
-        fn();
-        mutex_.Lock();
-        executing_task_ = false;
-        cond_var_.SignalAll();
-
-        // Remove the work from the heap once it is done executing, make sure
-        // it's the same function after executing the work while mutex is
-        // released.
-        // Note that we are just removing the pointer from the heap. Its
-        // memory is still managed in the map (as it holds a unique ptr).
-        // So current_fn is still a valid ptr.
-        assert(heap_.top() == current_fn);
-        heap_.pop();
-
-        // current_fn may be cancelled already.
-        if (current_fn->IsValid() && current_fn->repeat_every_us > 0) {
-          assert(running_);
-          current_fn->next_run_time_us =
-              clock_->NowMicros() + current_fn->repeat_every_us;
-
-          // Schedule new work into the heap with new time.
-          heap_.push(current_fn);
-        } else {
-          // if current_fn is cancelled or no need to repeat, remove it from the
-          // map to avoid leak.
-          map_.erase(current_fn->name);
-        }
-      } else {
-        cond_var_.TimedWait(current_fn->next_run_time_us);
-      }
-    }
-  }
-
-  void CancelAllWithLock() {
-    mutex_.AssertHeld();
-    if (map_.empty() && heap_.empty()) {
-      return;
-    }
-
-    // With mutex_ held, set all tasks to invalid so that they will not be
-    // re-queued.
-    for (auto& elem : map_) {
-      auto& func_info = elem.second;
-      assert(func_info);
-      func_info->Cancel();
-    }
-
-    // WaitForTaskCompleteIfNecessary() may release mutex_
-    WaitForTaskCompleteIfNecessary();
-
-    while (!heap_.empty()) {
-      heap_.pop();
-    }
-    map_.clear();
-  }
-
-  // A wrapper around std::function to keep track when it should run next
-  // and at what frequency.
-  struct FunctionInfo {
-    // the actual work
-    std::function<void()> fn;
-    // name of the function
-    std::string name;
-    // when the function should run next
-    uint64_t next_run_time_us;
-    // repeat interval
-    uint64_t repeat_every_us;
-    // controls whether this function is valid.
-    // A function is valid upon construction and until someone explicitly
-    // calls `Cancel()`.
-    bool valid;
-
-    FunctionInfo(std::function<void()>&& _fn, std::string _name,
-                 const uint64_t _next_run_time_us, uint64_t _repeat_every_us)
-        : fn(std::move(_fn)),
-          name(std::move(_name)),
-          next_run_time_us(_next_run_time_us),
-          repeat_every_us(_repeat_every_us),
-          valid(true) {}
-
-    void Cancel() { valid = false; }
-
-    bool IsValid() const { return valid; }
-  };
-
-  void WaitForTaskCompleteIfNecessary() {
-    mutex_.AssertHeld();
-    while (executing_task_) {
-      TEST_SYNC_POINT("Timer::WaitForTaskCompleteIfNecessary:TaskExecuting");
-      cond_var_.Wait();
-    }
-  }
-
-  struct RunTimeOrder {
-    bool operator()(const FunctionInfo* f1, const FunctionInfo* f2) {
-      return f1->next_run_time_us > f2->next_run_time_us;
-    }
-  };
-
-  SystemClock* clock_;
-  // This mutex controls both the heap_ and the map_. It needs to be held for
-  // making any changes in them.
-  mutable InstrumentedMutex mutex_;
-  InstrumentedCondVar cond_var_;
-  std::unique_ptr<port::Thread> thread_;
-  bool running_;
-  bool executing_task_;
-
-  std::priority_queue<FunctionInfo*, std::vector<FunctionInfo*>, RunTimeOrder>
-      heap_;
-
-  // In addition to providing a mapping from a function name to a function,
-  // it is also responsible for memory management.
-  std::unordered_map<std::string, std::unique_ptr<FunctionInfo>> map_;
-};
-
-}  // namespace ROCKSDB_NAMESPACE

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

@@ -1,231 +0,0 @@
-//  Portions 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).
-//
-// Borrowed from
-// http://www.crazygaze.com/blog/2016/03/24/portable-c-timer-queue/
-// Timer Queue
-//
-// License
-//
-// The source code in this article is licensed under the CC0 license, so feel
-// free to copy, modify, share, do whatever you want with it.
-// No attribution is required, but Ill be happy if you do.
-// CC0 license
-
-// The person who associated a work with this deed has dedicated the work to the
-// public domain by waiving all of his or her rights to the work worldwide
-// under copyright law, including all related and neighboring rights, to the
-// extent allowed by law.  You can copy, modify, distribute and perform the
-// work, even for commercial purposes, all without asking permission.
-
-#pragma once
-
-#include <assert.h>
-
-#include <chrono>
-#include <condition_variable>
-#include <functional>
-#include <queue>
-#include <thread>
-#include <utility>
-#include <vector>
-
-#include "port/port.h"
-#include "test_util/sync_point.h"
-
-// Allows execution of handlers at a specified time in the future
-// Guarantees:
-//  - All handlers are executed ONCE, even if cancelled (aborted parameter will
-// be set to true)
-//      - If TimerQueue is destroyed, it will cancel all handlers.
-//  - Handlers are ALWAYS executed in the Timer Queue worker thread.
-//  - Handlers execution order is NOT guaranteed
-//
-////////////////////////////////////////////////////////////////////////////////
-// borrowed from
-// http://www.crazygaze.com/blog/2016/03/24/portable-c-timer-queue/
-class TimerQueue {
- public:
-  TimerQueue() : m_th(&TimerQueue::run, this) {}
-
-  ~TimerQueue() { shutdown(); }
-
-  // This function is not thread-safe.
-  void shutdown() {
-    if (closed_) {
-      return;
-    }
-    cancelAll();
-    // Abusing the timer queue to trigger the shutdown.
-    add(0, [this](bool) {
-      m_finish = true;
-      return std::make_pair(false, 0);
-    });
-    m_th.join();
-    closed_ = true;
-  }
-
-  // Adds a new timer
-  // \return
-  //  Returns the ID of the new timer. You can use this ID to cancel the
-  // timer
-  uint64_t add(int64_t milliseconds,
-               std::function<std::pair<bool, int64_t>(bool)> handler) {
-    WorkItem item;
-    Clock::time_point tp = Clock::now();
-    item.end = tp + std::chrono::milliseconds(milliseconds);
-    TEST_SYNC_POINT_CALLBACK("TimeQueue::Add:item.end", &item.end);
-    item.period = milliseconds;
-    item.handler = std::move(handler);
-
-    std::unique_lock<std::mutex> lk(m_mtx);
-    uint64_t id = ++m_idcounter;
-    item.id = id;
-    m_items.push(std::move(item));
-
-    // Something changed, so wake up timer thread
-    m_checkWork.notify_one();
-    return id;
-  }
-
-  // Cancels the specified timer
-  // \return
-  //  1 if the timer was cancelled.
-  //  0 if you were too late to cancel (or the timer ID was never valid to
-  // start with)
-  size_t cancel(uint64_t id) {
-    // Instead of removing the item from the container (thus breaking the
-    // heap integrity), we set the item as having no handler, and put
-    // that handler on a new item at the top for immediate execution
-    // The timer thread will then ignore the original item, since it has no
-    // handler.
-    std::unique_lock<std::mutex> lk(m_mtx);
-    for (auto&& item : m_items.getContainer()) {
-      if (item.id == id && item.handler) {
-        WorkItem newItem;
-        // Zero time, so it stays at the top for immediate execution
-        newItem.end = Clock::time_point();
-        newItem.id = 0;  // Means it is a canceled item
-        // Move the handler from item to newitem (thus clearing item)
-        newItem.handler = std::move(item.handler);
-        m_items.push(std::move(newItem));
-
-        // Something changed, so wake up timer thread
-        m_checkWork.notify_one();
-        return 1;
-      }
-    }
-    return 0;
-  }
-
-  // Cancels all timers
-  // \return
-  //  The number of timers cancelled
-  size_t cancelAll() {
-    // Setting all "end" to 0 (for immediate execution) is ok,
-    // since it maintains the heap integrity
-    std::unique_lock<std::mutex> lk(m_mtx);
-    m_cancel = true;
-    for (auto&& item : m_items.getContainer()) {
-      if (item.id && item.handler) {
-        item.end = Clock::time_point();
-        item.id = 0;
-      }
-    }
-    auto ret = m_items.size();
-
-    m_checkWork.notify_one();
-    return ret;
-  }
-
- private:
-  using Clock = std::chrono::steady_clock;
-  TimerQueue(const TimerQueue&) = delete;
-  TimerQueue& operator=(const TimerQueue&) = delete;
-
-  void run() {
-    std::unique_lock<std::mutex> lk(m_mtx);
-    while (!m_finish) {
-      auto end = calcWaitTime_lock();
-      if (end.first) {
-        // Timers found, so wait until it expires (or something else
-        // changes)
-        m_checkWork.wait_until(lk, end.second);
-      } else {
-        // No timers exist, so wait forever until something changes
-        m_checkWork.wait(lk);
-      }
-
-      // Check and execute as much work as possible, such as, all expired
-      // timers
-      checkWork(&lk);
-    }
-
-    // If we are shutting down, we should not have any items left,
-    // since the shutdown cancels all items
-    assert(m_items.size() == 0);
-  }
-
-  std::pair<bool, Clock::time_point> calcWaitTime_lock() {
-    while (m_items.size()) {
-      if (m_items.top().handler) {
-        // Item present, so return the new wait time
-        return std::make_pair(true, m_items.top().end);
-      } else {
-        // Discard empty handlers (they were cancelled)
-        m_items.pop();
-      }
-    }
-
-    // No items found, so return no wait time (causes the thread to wait
-    // indefinitely)
-    return std::make_pair(false, Clock::time_point());
-  }
-
-  void checkWork(std::unique_lock<std::mutex>* lk) {
-    while (m_items.size() && m_items.top().end <= Clock::now()) {
-      WorkItem item(m_items.top());
-      m_items.pop();
-
-      if (item.handler) {
-        (*lk).unlock();
-        auto reschedule_pair = item.handler(item.id == 0);
-        (*lk).lock();
-        if (!m_cancel && reschedule_pair.first) {
-          int64_t new_period = (reschedule_pair.second == -1)
-                                   ? item.period
-                                   : reschedule_pair.second;
-
-          item.period = new_period;
-          item.end = Clock::now() + std::chrono::milliseconds(new_period);
-          m_items.push(std::move(item));
-        }
-      }
-    }
-  }
-
-  bool m_finish = false;
-  bool m_cancel = false;
-  uint64_t m_idcounter = 0;
-  std::condition_variable m_checkWork;
-
-  struct WorkItem {
-    Clock::time_point end;
-    int64_t period;
-    uint64_t id;  // id==0 means it was cancelled
-    std::function<std::pair<bool, int64_t>(bool)> handler;
-    bool operator>(const WorkItem& other) const { return end > other.end; }
-  };
-
-  std::mutex m_mtx;
-  // Inheriting from priority_queue, so we can access the internal container
-  class Queue : public std::priority_queue<WorkItem, std::vector<WorkItem>,
-                                           std::greater<WorkItem>> {
-   public:
-    std::vector<WorkItem>& getContainer() { return this->c; }
-  } m_items;
-  ROCKSDB_NAMESPACE::port::Thread m_th;
-  bool closed_ = false;
-};