rocksdb-native 2.6.2 → 2.6.4

package/vendor/librocksdb/vendor/rocksdb/port/win/win_jemalloc.cc

@@ -1,80 +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.
-
-#if defined(OS_WIN)
-
-#ifndef ROCKSDB_JEMALLOC
-#error This file can only be part of jemalloc aware build
-#endif
-
-#include <stdexcept>
-
-#include "jemalloc/jemalloc.h"
-#include "port/win/port_win.h"
-
-#if defined(ZSTD) && defined(ZSTD_STATIC_LINKING_ONLY)
-#include <zstd.h>
-#if (ZSTD_VERSION_NUMBER >= 500)
-namespace ROCKSDB_NAMESPACE {
-namespace port {
-void* JemallocAllocateForZSTD(void* /* opaque */, size_t size) {
-  return je_malloc(size);
-}
-void JemallocDeallocateForZSTD(void* /* opaque */, void* address) {
-  je_free(address);
-}
-ZSTD_customMem GetJeZstdAllocationOverrides() {
-  return {JemallocAllocateForZSTD, JemallocDeallocateForZSTD, nullptr};
-}
-}  // namespace port
-}  // namespace ROCKSDB_NAMESPACE
-#endif  // (ZSTD_VERSION_NUMBER >= 500)
-#endif  // defined(ZSTD) defined(ZSTD_STATIC_LINKING_ONLY)
-
-// Global operators to be replaced by a linker when this file is
-// a part of the build
-
-namespace ROCKSDB_NAMESPACE {
-namespace port {
-void* jemalloc_aligned_alloc(size_t size, size_t alignment) noexcept {
-  return je_aligned_alloc(alignment, size);
-}
-void jemalloc_aligned_free(void* p) noexcept { je_free(p); }
-}  // namespace port
-}  // namespace ROCKSDB_NAMESPACE
-
-void* operator new(size_t size) {
-  void* p = je_malloc(size);
-  if (!p) {
-    throw std::bad_alloc();
-  }
-  return p;
-}
-
-void* operator new[](size_t size) {
-  void* p = je_malloc(size);
-  if (!p) {
-    throw std::bad_alloc();
-  }
-  return p;
-}
-
-void operator delete(void* p) {
-  if (p) {
-    je_free(p);
-  }
-}
-
-void operator delete[](void* p) {
-  if (p) {
-    je_free(p);
-  }
-}
-
-#endif

package/vendor/librocksdb/vendor/rocksdb/port/win/win_logger.cc

@@ -1,192 +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.
-//
-// Logger implementation that can be shared by all environments
-// where enough posix functionality is available.
-
-#if defined(OS_WIN)
-
-#include "port/win/win_logger.h"
-
-#include <fcntl.h>
-#include <stdio.h>
-#include <time.h>
-
-#include <algorithm>
-#include <atomic>
-
-#include "monitoring/iostats_context_imp.h"
-#include "port/sys_time.h"
-#include "port/win/env_win.h"
-#include "port/win/io_win.h"
-#include "rocksdb/env.h"
-#include "rocksdb/system_clock.h"
-
-namespace ROCKSDB_NAMESPACE {
-
-namespace port {
-
-WinLogger::WinLogger(uint64_t (*gettid)(), SystemClock* clock, HANDLE file,
-                     const InfoLogLevel log_level)
-    : Logger(log_level),
-      file_(file),
-      gettid_(gettid),
-      log_size_(0),
-      last_flush_micros_(0),
-      clock_(clock),
-      flush_pending_(false) {
-  assert(file_ != NULL);
-  assert(file_ != INVALID_HANDLE_VALUE);
-}
-
-void WinLogger::DebugWriter(const char* str, int len) {
-  assert(file_ != INVALID_HANDLE_VALUE);
-  DWORD bytesWritten = 0;
-  BOOL ret = WriteFile(file_, str, len, &bytesWritten, NULL);
-  if (ret == FALSE) {
-    std::string errSz = GetWindowsErrSz(GetLastError());
-    fprintf(stderr, "%s", errSz.c_str());
-  }
-}
-
-WinLogger::~WinLogger() { CloseInternal().PermitUncheckedError(); }
-
-Status WinLogger::CloseImpl() { return CloseInternal(); }
-
-Status WinLogger::CloseInternal() {
-  Status s;
-  if (INVALID_HANDLE_VALUE != file_) {
-    BOOL ret = FlushFileBuffers(file_);
-    if (ret == 0) {
-      auto lastError = GetLastError();
-      s = IOErrorFromWindowsError("Failed to flush LOG on Close() ", lastError);
-    }
-    ret = CloseHandle(file_);
-    // On error the return value is zero
-    if (ret == 0 && s.ok()) {
-      auto lastError = GetLastError();
-      s = IOErrorFromWindowsError("Failed to flush LOG on Close() ", lastError);
-    }
-    file_ = INVALID_HANDLE_VALUE;
-    closed_ = true;
-  }
-  return s;
-}
-
-void WinLogger::Flush() {
-  assert(file_ != INVALID_HANDLE_VALUE);
-  if (flush_pending_) {
-    flush_pending_ = false;
-    // With Windows API writes go to OS buffers directly so no fflush needed
-    // unlike with C runtime API. We don't flush all the way to disk
-    // for perf reasons.
-  }
-
-  last_flush_micros_ = clock_->NowMicros();
-}
-
-void WinLogger::Logv(const char* format, va_list ap) {
-  IOSTATS_TIMER_GUARD(logger_nanos);
-  assert(file_ != INVALID_HANDLE_VALUE);
-
-  const uint64_t thread_id = (*gettid_)();
-
-  // We try twice: the first time with a fixed-size stack allocated buffer,
-  // and the second time with a much larger dynamically allocated buffer.
-  char buffer[500];
-  std::unique_ptr<char[]> largeBuffer;
-  for (int iter = 0; iter < 2; ++iter) {
-    char* base;
-    int bufsize;
-    if (iter == 0) {
-      bufsize = sizeof(buffer);
-      base = buffer;
-    } else {
-      bufsize = 30000;
-      largeBuffer.reset(new char[bufsize]);
-      base = largeBuffer.get();
-    }
-
-    char* p = base;
-    char* limit = base + bufsize;
-
-    port::TimeVal now_tv;
-    port::GetTimeOfDay(&now_tv, nullptr);
-    const time_t seconds = now_tv.tv_sec;
-    struct tm t;
-    localtime_s(&t, &seconds);
-    p += snprintf(p, limit - p, "%04d/%02d/%02d-%02d:%02d:%02d.%06d %llx ",
-                  t.tm_year + 1900, t.tm_mon + 1, t.tm_mday, t.tm_hour,
-                  t.tm_min, t.tm_sec, static_cast<int>(now_tv.tv_usec),
-                  static_cast<long long unsigned int>(thread_id));
-
-    // Print the message
-    if (p < limit) {
-      va_list backup_ap;
-      va_copy(backup_ap, ap);
-      int done = vsnprintf(p, limit - p, format, backup_ap);
-      if (done > 0) {
-        p += done;
-      } else {
-        continue;
-      }
-      va_end(backup_ap);
-    }
-
-    // Truncate to available space if necessary
-    if (p >= limit) {
-      if (iter == 0) {
-        continue;  // Try again with larger buffer
-      } else {
-        p = limit - 1;
-      }
-    }
-
-    // Add newline if necessary
-    if (p == base || p[-1] != '\n') {
-      *p++ = '\n';
-    }
-
-    assert(p <= limit);
-    const size_t write_size = p - base;
-
-    DWORD bytesWritten = 0;
-    BOOL ret = WriteFile(file_, base, static_cast<DWORD>(write_size),
-                         &bytesWritten, NULL);
-    if (ret == FALSE) {
-      std::string errSz = GetWindowsErrSz(GetLastError());
-      fprintf(stderr, "%s", errSz.c_str());
-    }
-
-    flush_pending_ = true;
-    assert((bytesWritten == write_size) || (ret == FALSE));
-    if (bytesWritten > 0) {
-      log_size_ += write_size;
-    }
-
-    uint64_t now_micros =
-        static_cast<uint64_t>(now_tv.tv_sec) * 1000000 + now_tv.tv_usec;
-    if (now_micros - last_flush_micros_ >= flush_every_seconds_ * 1000000) {
-      flush_pending_ = false;
-      // With Windows API writes go to OS buffers directly so no fflush needed
-      // unlike with C runtime API. We don't flush all the way to disk
-      // for perf reasons.
-      last_flush_micros_ = now_micros;
-    }
-    break;
-  }
-}
-
-size_t WinLogger::GetLogFileSize() const { return log_size_; }
-
-}  // namespace port
-
-}  // namespace ROCKSDB_NAMESPACE
-
-#endif

package/vendor/librocksdb/vendor/rocksdb/port/win/win_logger.h

@@ -1,64 +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.
-//
-// Logger implementation that can be shared by all environments
-// where enough posix functionality is available.
-
-#pragma once
-
-#include <stdint.h>
-#include <windows.h>
-
-#include <atomic>
-#include <memory>
-
-#include "rocksdb/env.h"
-
-namespace ROCKSDB_NAMESPACE {
-class SystemClock;
-
-namespace port {
-class WinLogger : public ROCKSDB_NAMESPACE::Logger {
- public:
-  WinLogger(uint64_t (*gettid)(), SystemClock* clock, HANDLE file,
-            const InfoLogLevel log_level = InfoLogLevel::ERROR_LEVEL);
-
-  virtual ~WinLogger();
-
-  WinLogger(const WinLogger&) = delete;
-
-  WinLogger& operator=(const WinLogger&) = delete;
-
-  void Flush() override;
-
-  using ROCKSDB_NAMESPACE::Logger::Logv;
-  void Logv(const char* format, va_list ap) override;
-
-  size_t GetLogFileSize() const override;
-
-  void DebugWriter(const char* str, int len);
-
- protected:
-  Status CloseImpl() override;
-
- private:
-  HANDLE file_;
-  uint64_t (*gettid_)();  // Return the thread id for the current thread
-  std::atomic_size_t log_size_;
-  std::atomic_uint_fast64_t last_flush_micros_;
-  SystemClock* clock_;
-  bool flush_pending_;
-
-  Status CloseInternal();
-
-  const static uint64_t flush_every_seconds_ = 5;
-};
-}  // namespace port
-
-}  // namespace ROCKSDB_NAMESPACE

package/vendor/librocksdb/vendor/rocksdb/port/win/win_thread.cc

@@ -1,170 +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.
-
-#if defined(OS_WIN)
-// Most Mingw builds support std::thread only when using posix threads.
-// In that case, some of these functions will be unavailable.
-// Note that we're using either WindowsThread or std::thread, depending on
-// which one is available.
-#ifndef _POSIX_THREADS
-
-#include "port/win/win_thread.h"
-
-#include <assert.h>
-#include <process.h>  // __beginthreadex
-#include <windows.h>
-
-#include <stdexcept>
-#include <system_error>
-#include <thread>
-
-namespace ROCKSDB_NAMESPACE {
-namespace port {
-
-struct WindowsThread::Data {
-  std::function<void()> func_;
-  uintptr_t handle_;
-
-  Data(std::function<void()>&& func) : func_(std::move(func)), handle_(0) {}
-
-  Data(const Data&) = delete;
-  Data& operator=(const Data&) = delete;
-
-  static unsigned int __stdcall ThreadProc(void* arg);
-};
-
-void WindowsThread::Init(std::function<void()>&& func) {
-  data_ = std::make_shared<Data>(std::move(func));
-  // We create another instance of std::shared_ptr to get an additional ref
-  // since we may detach and destroy this instance before the threadproc
-  // may start to run. We choose to allocate this additional ref on the heap
-  // so we do not need to synchronize and allow this thread to proceed
-  std::unique_ptr<std::shared_ptr<Data>> th_data(
-      new std::shared_ptr<Data>(data_));
-
-  data_->handle_ = _beginthreadex(NULL,
-                                  0,  // stack size
-                                  &Data::ThreadProc, th_data.get(),
-                                  0,  // init flag
-                                  &th_id_);
-
-  if (data_->handle_ == 0) {
-    throw std::system_error(
-        std::make_error_code(std::errc::resource_unavailable_try_again),
-        "Unable to create a thread");
-  }
-  th_data.release();
-}
-
-WindowsThread::WindowsThread() : data_(nullptr), th_id_(0) {}
-
-WindowsThread::~WindowsThread() {
-  // Must be joined or detached
-  // before destruction.
-  // This is the same as std::thread
-  if (data_) {
-    if (joinable()) {
-      assert(false);
-      std::terminate();
-    }
-    data_.reset();
-  }
-}
-
-WindowsThread::WindowsThread(WindowsThread&& o) noexcept : WindowsThread() {
-  *this = std::move(o);
-}
-
-WindowsThread& WindowsThread::operator=(WindowsThread&& o) noexcept {
-  if (joinable()) {
-    assert(false);
-    std::terminate();
-  }
-
-  data_ = std::move(o.data_);
-
-  // Per spec both instances will have the same id
-  th_id_ = o.th_id_;
-
-  return *this;
-}
-
-bool WindowsThread::joinable() const { return (data_ && data_->handle_ != 0); }
-
-WindowsThread::native_handle_type WindowsThread::native_handle() const {
-  return reinterpret_cast<native_handle_type>(data_->handle_);
-}
-
-unsigned WindowsThread::hardware_concurrency() {
-  return std::thread::hardware_concurrency();
-}
-
-void WindowsThread::join() {
-  if (!joinable()) {
-    assert(false);
-    throw std::system_error(std::make_error_code(std::errc::invalid_argument),
-                            "Thread is no longer joinable");
-  }
-
-  if (GetThreadId(GetCurrentThread()) == th_id_) {
-    assert(false);
-    throw std::system_error(
-        std::make_error_code(std::errc::resource_deadlock_would_occur),
-        "Can not join itself");
-  }
-
-  auto ret =
-      WaitForSingleObject(reinterpret_cast<HANDLE>(data_->handle_), INFINITE);
-  if (ret != WAIT_OBJECT_0) {
-    auto lastError = GetLastError();
-    assert(false);
-    throw std::system_error(static_cast<int>(lastError), std::system_category(),
-                            "WaitForSingleObjectFailed: thread join");
-  }
-
-  BOOL rc
-#if defined(_MSC_VER)
-      = FALSE;
-#else
-      __attribute__((__unused__));
-#endif
-  rc = CloseHandle(reinterpret_cast<HANDLE>(data_->handle_));
-  assert(rc != 0);
-  data_->handle_ = 0;
-}
-
-bool WindowsThread::detach() {
-  if (!joinable()) {
-    assert(false);
-    throw std::system_error(std::make_error_code(std::errc::invalid_argument),
-                            "Thread is no longer available");
-  }
-
-  BOOL ret = CloseHandle(reinterpret_cast<HANDLE>(data_->handle_));
-  data_->handle_ = 0;
-
-  return (ret != 0);
-}
-
-void WindowsThread::swap(WindowsThread& o) {
-  data_.swap(o.data_);
-  std::swap(th_id_, o.th_id_);
-}
-
-unsigned int __stdcall WindowsThread::Data::ThreadProc(void* arg) {
-  auto ptr = reinterpret_cast<std::shared_ptr<Data>*>(arg);
-  std::unique_ptr<std::shared_ptr<Data>> data(ptr);
-  (*data)->func_();
-  return 0;
-}
-}  // namespace port
-}  // namespace ROCKSDB_NAMESPACE
-
-#endif  // !_POSIX_THREADS
-#endif  // OS_WIN

package/vendor/librocksdb/vendor/rocksdb/port/win/win_thread.h

@@ -1,117 +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
-
-#ifndef _POSIX_THREADS
-
-#include <functional>
-#include <memory>
-#include <type_traits>
-
-#include "rocksdb/rocksdb_namespace.h"
-
-namespace ROCKSDB_NAMESPACE {
-namespace port {
-
-// This class is a replacement for std::thread
-// 2 reasons we do not like std::thread:
-//  -- is that it dynamically allocates its internals that are automatically
-//     freed when  the thread terminates and not on the destruction of the
-//     object. This makes it difficult to control the source of memory
-//     allocation
-//  -  This implements Pimpl so we can easily replace the guts of the
-//      object in our private version if necessary.
-class WindowsThread {
-  struct Data;
-
-  std::shared_ptr<Data> data_;
-  unsigned int th_id_;
-
-  void Init(std::function<void()>&&);
-
- public:
-  using native_handle_type = void*;
-
-  // Construct with no thread
-  WindowsThread();
-
-  // Template constructor
-  //
-  // This templated constructor accomplishes several things
-  //
-  // - Allows the class as whole to be not a template
-  //
-  // - take "universal" references to support both _lvalues and _rvalues
-  //
-  // -  because this constructor is a catchall case in many respects it
-  //    may prevent us from using both the default __ctor, the move __ctor.
-  //    Also it may circumvent copy __ctor deletion. To work around this
-  //    we make sure this one has at least one argument and eliminate
-  //    it from the overload  selection when WindowsThread is the first
-  //    argument.
-  //
-  // - construct with Fx(Ax...) with a variable number of types/arguments.
-  //
-  // - Gathers together the callable object with its arguments and constructs
-  //   a single callable entity
-  //
-  // - Makes use of std::function to convert it to a specification-template
-  //   dependent type that both checks the signature conformance to ensure
-  //   that all of the necessary arguments are provided and allows pimpl
-  //   implementation.
-  template <class Fn, class... Args,
-            class = typename std::enable_if<!std::is_same<
-                typename std::decay<Fn>::type, WindowsThread>::value>::type>
-  explicit WindowsThread(Fn&& fx, Args&&... ax) : WindowsThread() {
-    // Use binder to create a single callable entity
-    auto binder = std::bind(std::forward<Fn>(fx), std::forward<Args>(ax)...);
-    // Use std::function to take advantage of the type erasure
-    // so we can still hide implementation within pimpl
-    // This also makes sure that the binder signature is compliant
-    std::function<void()> target = binder;
-
-    Init(std::move(target));
-  }
-
-  ~WindowsThread();
-
-  WindowsThread(const WindowsThread&) = delete;
-
-  WindowsThread& operator=(const WindowsThread&) = delete;
-
-  WindowsThread(WindowsThread&&) noexcept;
-
-  WindowsThread& operator=(WindowsThread&&) noexcept;
-
-  bool joinable() const;
-
-  unsigned int get_id() const { return th_id_; }
-
-  native_handle_type native_handle() const;
-
-  static unsigned hardware_concurrency();
-
-  void join();
-
-  bool detach();
-
-  void swap(WindowsThread&);
-};
-}  // namespace port
-}  // namespace ROCKSDB_NAMESPACE
-
-namespace std {
-inline void swap(ROCKSDB_NAMESPACE::port::WindowsThread& th1,
-                 ROCKSDB_NAMESPACE::port::WindowsThread& th2) {
-  th1.swap(th2);
-}
-}  // namespace std
-
-#endif  // !_POSIX_THREADS