rocksdb-native 2.6.2 → 2.6.4

package/vendor/librocksdb/vendor/rocksdb/utilities/transactions/lock/range/range_tree/lib/ft/ft-status.h

@@ -1,102 +0,0 @@
-/* -*- mode: C++; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-// vim: ft=cpp:expandtab:ts=8:sw=4:softtabstop=4:
-#ident "$Id$"
-/*======
-This file is part of PerconaFT.
-
-
-Copyright (c) 2006, 2015, Percona and/or its affiliates. All rights reserved.
-
-    PerconaFT is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License, version 2,
-    as published by the Free Software Foundation.
-
-    PerconaFT is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with PerconaFT.  If not, see <http://www.gnu.org/licenses/>.
-
-----------------------------------------
-
-    PerconaFT is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Affero General Public License, version 3,
-    as published by the Free Software Foundation.
-
-    PerconaFT is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Affero General Public License for more details.
-
-    You should have received a copy of the GNU Affero General Public License
-    along with PerconaFT.  If not, see <http://www.gnu.org/licenses/>.
-
-----------------------------------------
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.
-======= */
-
-#ident \
-    "Copyright (c) 2006, 2015, Percona and/or its affiliates. All rights reserved."
-
-#pragma once
-
-#include "../db.h"
-#include "../portability/toku_race_tools.h"
-#include "../util/status.h"
-
-//
-// Lock Tree Manager statistics
-//
-class LTM_STATUS_S {
- public:
-  enum {
-    LTM_SIZE_CURRENT = 0,
-    LTM_SIZE_LIMIT,
-    LTM_ESCALATION_COUNT,
-    LTM_ESCALATION_TIME,
-    LTM_ESCALATION_LATEST_RESULT,
-    LTM_NUM_LOCKTREES,
-    LTM_LOCK_REQUESTS_PENDING,
-    LTM_STO_NUM_ELIGIBLE,
-    LTM_STO_END_EARLY_COUNT,
-    LTM_STO_END_EARLY_TIME,
-    LTM_WAIT_COUNT,
-    LTM_WAIT_TIME,
-    LTM_LONG_WAIT_COUNT,
-    LTM_LONG_WAIT_TIME,
-    LTM_TIMEOUT_COUNT,
-    LTM_WAIT_ESCALATION_COUNT,
-    LTM_WAIT_ESCALATION_TIME,
-    LTM_LONG_WAIT_ESCALATION_COUNT,
-    LTM_LONG_WAIT_ESCALATION_TIME,
-    LTM_STATUS_NUM_ROWS  // must be last
-  };
-
-  void init(void);
-  void destroy(void);
-
-  TOKU_ENGINE_STATUS_ROW_S status[LTM_STATUS_NUM_ROWS];
-
- private:
-  bool m_initialized = false;
-};
-typedef LTM_STATUS_S* LTM_STATUS;
-extern LTM_STATUS_S ltm_status;
-
-#define LTM_STATUS_VAL(x) ltm_status.status[LTM_STATUS_S::x].value.num
-
-void toku_status_init(void);     // just call ltm_status.init();
-void toku_status_destroy(void);  // just call ltm_status.destroy();

package/vendor/librocksdb/vendor/rocksdb/utilities/transactions/lock/range/range_tree/lib/locktree/concurrent_tree.cc

@@ -1,137 +0,0 @@
-/* -*- mode: C++; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-// vim: ft=cpp:expandtab:ts=8:sw=4:softtabstop=4:
-#ifndef OS_WIN
-#ident "$Id$"
-/*======
-This file is part of PerconaFT.
-
-
-Copyright (c) 2006, 2015, Percona and/or its affiliates. All rights reserved.
-
-    PerconaFT is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License, version 2,
-    as published by the Free Software Foundation.
-
-    PerconaFT is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with PerconaFT.  If not, see <http://www.gnu.org/licenses/>.
-
-----------------------------------------
-
-    PerconaFT is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Affero General Public License, version 3,
-    as published by the Free Software Foundation.
-
-    PerconaFT is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Affero General Public License for more details.
-
-    You should have received a copy of the GNU Affero General Public License
-    along with PerconaFT.  If not, see <http://www.gnu.org/licenses/>.
-
-----------------------------------------
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.
-======= */
-
-#ident \
-    "Copyright (c) 2006, 2015, Percona and/or its affiliates. All rights reserved."
-
-#include "concurrent_tree.h"
-
-// PORT #include <toku_assert.h>
-namespace toku {
-
-void concurrent_tree::create(const comparator *cmp) {
-  // start with an empty root node. we do this instead of
-  // setting m_root to null so there's always a root to lock
-  m_root.create_root(cmp);
-}
-
-void concurrent_tree::destroy(void) { m_root.destroy_root(); }
-
-bool concurrent_tree::is_empty(void) { return m_root.is_empty(); }
-
-uint64_t concurrent_tree::get_insertion_memory_overhead(void) {
-  return sizeof(treenode);
-}
-
-void concurrent_tree::locked_keyrange::prepare(concurrent_tree *tree) {
-  // the first step in acquiring a locked keyrange is locking the root
-  treenode *const root = &tree->m_root;
-  m_tree = tree;
-  m_subtree = root;
-  m_range = keyrange::get_infinite_range();
-  root->mutex_lock();
-}
-
-void concurrent_tree::locked_keyrange::acquire(const keyrange &range) {
-  treenode *const root = &m_tree->m_root;
-
-  treenode *subtree;
-  if (root->is_empty() || root->range_overlaps(range)) {
-    subtree = root;
-  } else {
-    // we do not have a precomputed comparison hint, so pass null
-    const keyrange::comparison *cmp_hint = nullptr;
-    subtree = root->find_node_with_overlapping_child(range, cmp_hint);
-  }
-
-  // subtree is locked. it will be unlocked when this is release()'d
-  invariant_notnull(subtree);
-  m_range = range;
-  m_subtree = subtree;
-}
-
-bool concurrent_tree::locked_keyrange::add_shared_owner(const keyrange &range,
-                                                        TXNID new_owner) {
-  return m_subtree->insert(range, new_owner, /*is_shared*/ true);
-}
-
-void concurrent_tree::locked_keyrange::release(void) {
-  m_subtree->mutex_unlock();
-}
-
-void concurrent_tree::locked_keyrange::insert(const keyrange &range,
-                                              TXNID txnid, bool is_shared) {
-  // empty means no children, and only the root should ever be empty
-  if (m_subtree->is_empty()) {
-    m_subtree->set_range_and_txnid(range, txnid, is_shared);
-  } else {
-    m_subtree->insert(range, txnid, is_shared);
-  }
-}
-
-void concurrent_tree::locked_keyrange::remove(const keyrange &range,
-                                              TXNID txnid) {
-  invariant(!m_subtree->is_empty());
-  treenode *new_subtree = m_subtree->remove(range, txnid);
-  // if removing range changed the root of the subtree,
-  // then the subtree must be the root of the entire tree.
-  if (new_subtree == nullptr) {
-    invariant(m_subtree->is_root());
-    invariant(m_subtree->is_empty());
-  }
-}
-
-void concurrent_tree::locked_keyrange::remove_all(void) {
-  m_subtree->recursive_remove();
-}
-
-} /* namespace toku */
-#endif  // OS_WIN

package/vendor/librocksdb/vendor/rocksdb/utilities/transactions/lock/range/range_tree/lib/locktree/concurrent_tree.h

@@ -1,174 +0,0 @@
-/* -*- mode: C++; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-// vim: ft=cpp:expandtab:ts=8:sw=2:softtabstop=2:
-#ident "$Id$"
-/*======
-This file is part of PerconaFT.
-
-
-Copyright (c) 2006, 2015, Percona and/or its affiliates. All rights reserved.
-
-    PerconaFT is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License, version 2,
-    as published by the Free Software Foundation.
-
-    PerconaFT is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with PerconaFT.  If not, see <http://www.gnu.org/licenses/>.
-
-----------------------------------------
-
-    PerconaFT is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Affero General Public License, version 3,
-    as published by the Free Software Foundation.
-
-    PerconaFT is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Affero General Public License for more details.
-
-    You should have received a copy of the GNU Affero General Public License
-    along with PerconaFT.  If not, see <http://www.gnu.org/licenses/>.
-
-----------------------------------------
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.
-======= */
-
-#ident \
-    "Copyright (c) 2006, 2015, Percona and/or its affiliates. All rights reserved."
-
-#pragma once
-
-#include "../ft/comparator.h"
-#include "keyrange.h"
-#include "treenode.h"
-
-namespace toku {
-
-// A concurrent_tree stores non-overlapping ranges.
-// Access to disjoint parts of the tree usually occurs concurrently.
-
-class concurrent_tree {
- public:
-  // A locked_keyrange gives you exclusive access to read and write
-  // operations that occur on any keys in that range. You only have
-  // the right to operate on keys in that range or keys that were read
-  // from the keyrange using iterate()
-  //
-  // Access model:
-  // - user prepares a locked keyrange. all threads serialize behind prepare().
-  // - user breaks the serialzation point by acquiring a range, or releasing.
-  // - one thread operates on a certain locked_keyrange object at a time.
-  // - when the thread is finished, it releases
-
-  class locked_keyrange {
-   public:
-    // effect: prepare to acquire a locked keyrange over the given
-    //         concurrent_tree, preventing other threads from preparing
-    //         until this thread either does acquire() or release().
-    // note: operations performed on a prepared keyrange are equivalent
-    //         to ones performed on an acquired keyrange over -inf, +inf.
-    // rationale: this provides the user with a serialization point for
-    // descending
-    //            or modifying the the tree. it also proives a convenient way of
-    //            doing serializable operations on the tree.
-    // There are two valid sequences of calls:
-    //  - prepare, acquire, [operations], release
-    //  - prepare, [operations],release
-    void prepare(concurrent_tree *tree);
-
-    // requires: the locked keyrange was prepare()'d
-    // effect: acquire a locked keyrange over the given concurrent_tree.
-    //         the locked keyrange represents the range of keys overlapped
-    //         by the given range
-    void acquire(const keyrange &range);
-
-    // effect: releases a locked keyrange and the mutex it holds
-    void release(void);
-
-    // effect: iterate over each range this locked_keyrange represents,
-    //         calling function->fn() on each node's keyrange and txnid
-    //         until there are no more or the function returns false
-    template <class F>
-    void iterate(F *function) const {
-      // if the subtree is non-empty, traverse it by calling the given
-      // function on each range, txnid pair found that overlaps.
-      if (!m_subtree->is_empty()) {
-        m_subtree->traverse_overlaps(m_range, function);
-      }
-    }
-
-    // Adds another owner to the lock on the specified keyrange.
-    // requires: the keyrange contains one treenode whose bounds are
-    //           exactly equal to the specifed range (no sub/supersets)
-    bool add_shared_owner(const keyrange &range, TXNID new_owner);
-
-    // inserts the given range into the tree, with an associated txnid.
-    // requires: range does not overlap with anything in this locked_keyrange
-    // rationale: caller is responsible for only inserting unique ranges
-    void insert(const keyrange &range, TXNID txnid, bool is_shared);
-
-    // effect: removes the given range from the tree.
-    //         - txnid=TXNID_ANY means remove the range no matter what its
-    //           owners are
-    //         - Other value means remove the specified txnid from
-    //           ownership (if the range has other owners, it will remain
-    //           in the tree)
-    // requires: range exists exactly in this locked_keyrange
-    // rationale: caller is responsible for only removing existing ranges
-    void remove(const keyrange &range, TXNID txnid);
-
-    // effect: removes all of the keys represented by this locked keyrange
-    // rationale: we'd like a fast way to empty out a tree
-    void remove_all(void);
-
-   private:
-    // the concurrent tree this locked keyrange is for
-    concurrent_tree *m_tree;
-
-    // the range of keys this locked keyrange represents
-    keyrange m_range;
-
-    // the subtree under which all overlapping ranges exist
-    treenode *m_subtree;
-
-    friend class concurrent_tree_unit_test;
-  };
-
-  // effect: initialize the tree to an empty state
-  void create(const comparator *cmp);
-
-  // effect: destroy the tree.
-  // requires: tree is empty
-  void destroy(void);
-
-  // returns: true iff the tree is empty
-  bool is_empty(void);
-
-  // returns: the memory overhead of a single insertion into the tree
-  static uint64_t get_insertion_memory_overhead(void);
-
- private:
-  // the root needs to always exist so there's a lock to grab
-  // even if the tree is empty. that's why we store a treenode
-  // here and not a pointer to one.
-  treenode m_root;
-
-  friend class concurrent_tree_unit_test;
-};
-
-} /* namespace toku */

package/vendor/librocksdb/vendor/rocksdb/utilities/transactions/lock/range/range_tree/lib/locktree/keyrange.cc

@@ -1,220 +0,0 @@
-/* -*- mode: C++; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-// vim: ft=cpp:expandtab:ts=8:sw=4:softtabstop=4:
-#ifndef OS_WIN
-#ident "$Id$"
-/*======
-This file is part of PerconaFT.
-
-
-Copyright (c) 2006, 2015, Percona and/or its affiliates. All rights reserved.
-
-    PerconaFT is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License, version 2,
-    as published by the Free Software Foundation.
-
-    PerconaFT is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with PerconaFT.  If not, see <http://www.gnu.org/licenses/>.
-
-----------------------------------------
-
-    PerconaFT is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Affero General Public License, version 3,
-    as published by the Free Software Foundation.
-
-    PerconaFT is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Affero General Public License for more details.
-
-    You should have received a copy of the GNU Affero General Public License
-    along with PerconaFT.  If not, see <http://www.gnu.org/licenses/>.
-
-----------------------------------------
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.
-======= */
-
-#ident \
-    "Copyright (c) 2006, 2015, Percona and/or its affiliates. All rights reserved."
-
-#include "keyrange.h"
-
-#include "../util/dbt.h"
-
-namespace toku {
-
-// create a keyrange by borrowing the left and right dbt
-// pointers. no memory is copied. no checks for infinity needed.
-void keyrange::create(const DBT *left, const DBT *right) {
-  init_empty();
-  m_left_key = left;
-  m_right_key = right;
-}
-
-// destroy the key copies. if they were never set, then destroy does nothing.
-void keyrange::destroy(void) {
-  toku_destroy_dbt(&m_left_key_copy);
-  toku_destroy_dbt(&m_right_key_copy);
-}
-
-// create a keyrange by copying the keys from the given range.
-void keyrange::create_copy(const keyrange &range) {
-  // start with an initialized, empty range
-  init_empty();
-
-  // optimize the case where the left and right keys are the same.
-  // we'd like to only have one copy of the data.
-  if (toku_dbt_equals(range.get_left_key(), range.get_right_key())) {
-    set_both_keys(range.get_left_key());
-  } else {
-    // replace our empty left and right keys with
-    // copies of the range's left and right keys
-    replace_left_key(range.get_left_key());
-    replace_right_key(range.get_right_key());
-  }
-}
-
-// extend this keyrange by choosing the leftmost and rightmost
-// endpoints between this range and the given. replaced keys
-// in this range are freed and inherited keys are copied.
-void keyrange::extend(const comparator &cmp, const keyrange &range) {
-  const DBT *range_left = range.get_left_key();
-  const DBT *range_right = range.get_right_key();
-  if (cmp(range_left, get_left_key()) < 0) {
-    replace_left_key(range_left);
-  }
-  if (cmp(range_right, get_right_key()) > 0) {
-    replace_right_key(range_right);
-  }
-}
-
-// how much memory does this keyrange take?
-// - the size of the left and right keys
-// --- ignore the fact that we may have optimized the point case.
-//     it complicates things for little gain.
-// - the size of the keyrange class itself
-uint64_t keyrange::get_memory_size(void) const {
-  const DBT *left_key = get_left_key();
-  const DBT *right_key = get_right_key();
-  return left_key->size + right_key->size + sizeof(keyrange);
-}
-
-// compare ranges.
-keyrange::comparison keyrange::compare(const comparator &cmp,
-                                       const keyrange &range) const {
-  if (cmp(get_right_key(), range.get_left_key()) < 0) {
-    return comparison::LESS_THAN;
-  } else if (cmp(get_left_key(), range.get_right_key()) > 0) {
-    return comparison::GREATER_THAN;
-  } else if (cmp(get_left_key(), range.get_left_key()) == 0 &&
-             cmp(get_right_key(), range.get_right_key()) == 0) {
-    return comparison::EQUALS;
-  } else {
-    return comparison::OVERLAPS;
-  }
-}
-
-bool keyrange::overlaps(const comparator &cmp, const keyrange &range) const {
-  // equality is a stronger form of overlapping.
-  // so two ranges "overlap" if they're either equal or just overlapping.
-  comparison c = compare(cmp, range);
-  return c == comparison::EQUALS || c == comparison::OVERLAPS;
-}
-
-keyrange keyrange::get_infinite_range(void) {
-  keyrange range;
-  range.create(toku_dbt_negative_infinity(), toku_dbt_positive_infinity());
-  return range;
-}
-
-void keyrange::init_empty(void) {
-  m_left_key = nullptr;
-  m_right_key = nullptr;
-  toku_init_dbt(&m_left_key_copy);
-  toku_init_dbt(&m_right_key_copy);
-  m_point_range = false;
-}
-
-const DBT *keyrange::get_left_key(void) const {
-  if (m_left_key) {
-    return m_left_key;
-  } else {
-    return &m_left_key_copy;
-  }
-}
-
-const DBT *keyrange::get_right_key(void) const {
-  if (m_right_key) {
-    return m_right_key;
-  } else {
-    return &m_right_key_copy;
-  }
-}
-
-// copy the given once and set both the left and right pointers.
-// optimization for point ranges, so the left and right ranges
-// are not copied twice.
-void keyrange::set_both_keys(const DBT *key) {
-  if (toku_dbt_is_infinite(key)) {
-    m_left_key = key;
-    m_right_key = key;
-  } else {
-    toku_clone_dbt(&m_left_key_copy, *key);
-    toku_copyref_dbt(&m_right_key_copy, m_left_key_copy);
-  }
-  m_point_range = true;
-}
-
-// destroy the current left key. set and possibly copy the new one
-void keyrange::replace_left_key(const DBT *key) {
-  // a little magic:
-  //
-  // if this is a point range, then the left and right keys share
-  // one copy of the data, and it lives in the left key copy. so
-  // if we're replacing the left key, move the real data to the
-  // right key copy instead of destroying it. now, the memory is
-  // owned by the right key and the left key may be replaced.
-  if (m_point_range) {
-    m_right_key_copy = m_left_key_copy;
-  } else {
-    toku_destroy_dbt(&m_left_key_copy);
-  }
-
-  if (toku_dbt_is_infinite(key)) {
-    m_left_key = key;
-  } else {
-    toku_clone_dbt(&m_left_key_copy, *key);
-    m_left_key = nullptr;
-  }
-  m_point_range = false;
-}
-
-// destroy the current right key. set and possibly copy the new one
-void keyrange::replace_right_key(const DBT *key) {
-  toku_destroy_dbt(&m_right_key_copy);
-  if (toku_dbt_is_infinite(key)) {
-    m_right_key = key;
-  } else {
-    toku_clone_dbt(&m_right_key_copy, *key);
-    m_right_key = nullptr;
-  }
-  m_point_range = false;
-}
-
-} /* namespace toku */
-#endif  // OS_WIN