foedus::storage::masstree::MasstreeCursor Class Reference

Represents a cursor object for Masstree storage. More...

Detailed Description

Represents a cursor object for Masstree storage.

Cursor Example

Below is a typical usecase (from TPC-C) of this cursor class.

... (begin xct, etc)
MasstreeCursor cursor(orderlines, context);
CHECK_ERROR_CODE(cursor.open_normalized(low, high, true, true));
while (cursor.is_valid_record()) {
 const char* key_be = cursor.get_key();
 const OrderlineData* payload = reinterpret_cast<const OrderlineData*>(cursor.get_payload());
 *ol_amount_total += payload->amount_;
 ++(*ol_count);
 CHECK_ERROR_CODE(cursor.overwrite_record(delivery_date, offset, delivery_date_len));
 CHECK_ERROR_CODE(cursor.next());
}
... (commit xct, etc)

Dynamic Memory

This cursor objects uses a few dymanically allocated memory for keys, route information, etc. However, we of course can't tolerate new/delete during transaction. We thus grab memory from the memory pool for snapshot pages (could be volatile page's, but probably volatile memory pool is more limiting, so let's grab it from snapshot memory pool). These memory are allocated via libnuma and using THP, so it's also faster. The only drawback is that we consume them in a little bit generous way, but shouldn't be a big issue. All of them are returned to the pool in destructor.

Definition at line 75 of file masstree_cursor.hpp.

#include <masstree_cursor.hpp>

Classes
struct	Route
	Represents one page in the current search path from layer0-root. More...

Public Types
enum	SearchType { kForwardInclusive = 0, kForwardExclusive, kBackwardInclusive, kBackwardExclusive }
enum	KeyCompareResult {   kCurKeySmaller, kCurKeyEquals, kCurKeyLarger, kCurKeyBeingsWith,   kCurKeyContains }
enum	Constants { kMaxRecords = kBorderPageMaxSlots, kMaxRoutes = kPageSize / sizeof(Route), kKeyLengthExtremum = 0 }

Public Member Functions
	MasstreeCursor (MasstreeStorage storage, thread::Thread *context)
thread::Thread *	get_context ()
MasstreeStorage &	get_storage ()
bool	is_for_writes () const
bool	is_forward_cursor () const
ErrorCode	open (const char *begin_key=nullptr, KeyLength begin_key_length=kKeyLengthExtremum, const char *end_key=nullptr, KeyLength end_key_length=kKeyLengthExtremum, bool forward_cursor=true, bool for_writes=false, bool begin_inclusive=true, bool end_inclusive=false)
ErrorCode	open_normalized (KeySlice begin_key, KeySlice end_key, bool forward_cursor=true, bool for_writes=false, bool begin_inclusive=true, bool end_inclusive=false)
bool	is_valid_record () const __attribute__((always_inline))
KeyLength	get_key_length () const __attribute__((always_inline))
	Returns the length of the whole key we are currently pointing to. More...
const KeySlice *	get_cur_route_prefix_slices () const __attribute__((always_inline))
	Returns the prefix slices upto the current page. More...
const char *	get_cur_route_prefix_be () const __attribute__((always_inline))
	Big-endian version. More...
KeySlice	get_key_in_layer_slice () const __attribute__((always_inline))
	Returns only the slice of the key in the layer of the current page. More...
const char *	get_key_suffix () const __attribute__((always_inline))
	Returns the suffix part of the key in the page. More...
KeySlice	get_normalized_key () const __attribute__((always_inline))
	This method assumes the key length is at most 8 bytes. More...
void	copy_combined_key (char *buffer) const
	Copies the entire big-endian key of the current record to the given buffer. More...
void	copy_combined_key_part (KeyLength offset, KeyLength len, char *buffer) const
	Another version to get a part of the key, from the offset for len bytes. More...
std::string	get_combined_key () const __attribute__((always_inline))
	For even handier use, it returns std::string. More...
const char *	get_payload () const __attribute__((always_inline))
PayloadLength	get_payload_length () const __attribute__((always_inline))
ErrorCode	next ()
	Moves the cursor to next record. More...
ErrorCode	delete_record ()
ErrorCode	overwrite_record (const void *payload, PayloadLength payload_offset, PayloadLength payload_count)
template<typename PAYLOAD >
ErrorCode	overwrite_record_primitive (PAYLOAD payload, PayloadLength payload_offset)
template<typename PAYLOAD >
ErrorCode	increment_record (PAYLOAD *value, PayloadLength payload_offset)

Member Enumeration Documentation

enum foedus::storage::masstree::MasstreeCursor::Constants

Enumerator
kMaxRecords
kMaxRoutes
kKeyLengthExtremum

Definition at line 178 of file masstree_cursor.hpp.

                 {
    kMaxRecords = kBorderPageMaxSlots,
    kMaxRoutes = kPageSize / sizeof(Route),
    kKeyLengthExtremum = 0,
  };

enum foedus::storage::masstree::MasstreeCursor::KeyCompareResult

Enumerator
kCurKeySmaller
kCurKeyEquals
kCurKeyLarger
kCurKeyBeingsWith
kCurKeyContains

Definition at line 170 of file masstree_cursor.hpp.

                        {
    kCurKeySmaller,
    kCurKeyEquals,
    kCurKeyLarger,
    // the following two are only when cur key points to next layer. instead, no equals for layer
    kCurKeyBeingsWith,
    kCurKeyContains,
  };

enum foedus::storage::masstree::MasstreeCursor::SearchType

Enumerator
kForwardInclusive
kForwardExclusive
kBackwardInclusive
kBackwardExclusive

Definition at line 164 of file masstree_cursor.hpp.

                  {
    kForwardInclusive = 0,
    kForwardExclusive,
    kBackwardInclusive,
    kBackwardExclusive,
  };

Constructor & Destructor Documentation

foedus::storage::masstree::MasstreeCursor::MasstreeCursor	(	MasstreeStorage	storage,
		thread::Thread *	context
	)

Definition at line 41 of file masstree_cursor.cpp.

References foedus::storage::masstree::RecordLocation::clear().

  : engine_(storage.get_engine()),
    storage_(storage.get_engine(), storage.get_control_block()),
    context_(context),
    current_xct_(&context->get_current_xct()) {
  for_writes_ = false;
  forward_cursor_ = true;
  reached_end_ = false;

  route_count_ = 0;
  routes_ = nullptr;
  should_skip_cur_route_ = false;

  end_inclusive_ = false;
  end_key_length_ = 0;
  end_key_ = nullptr;
  end_key_slices_ = nullptr;

  cur_route_prefix_slices_ = nullptr;
  cur_route_prefix_be_ = nullptr;

  cur_key_length_ = 0;
  cur_key_owner_id_address = nullptr;
  cur_key_suffix_ = nullptr;
  cur_key_in_layer_slice_ = 0;
  cur_key_in_layer_remainder_ = 0;
  cur_key_next_layer_ = false;
  cur_key_location_.clear();

  cur_payload_length_ = 0;

  search_key_length_ = 0;
  search_key_ = nullptr;
  search_key_slices_ = nullptr;
}

Here is the call graph for this function:

Member Function Documentation

void foedus::storage::masstree::MasstreeCursor::copy_combined_key

(

char *

buffer

)

const

Copies the entire big-endian key of the current record to the given buffer.

Parameters

[out]

buffer

to receive the combined big-endian key. must be get_key_length() or longer.

In other words, this combines get_cur_route_prefixes(), get_key_in_layer_slice() and get_key_suffix(). This method is handy to get a whole key as one char array, but it must copy something, so remember that it's a bit costly.

Why we can't just return const char*

We initially provided such a method "get_key()". However, to provide such a method, we have to keep memcpy-ing for each key because there is no single contiguous key string! A key in masstree is stored in at least 3 components; prefix slices, current slice, suffix. If we could just point to somewhere in the data page, it's a no-cost operation. What we can do is only get_key_suffix() in that regard. We removed the get_key() method and instead added this explicit copy-method so that the user can choose when to re-construct the entire key.

Definition at line 77 of file masstree_cursor.cpp.

References ASSERT_ND, ASSUME_ALIGNED, foedus::storage::masstree::calculate_suffix_length(), foedus::storage::masstree::MasstreePage::get_layer(), is_valid_record(), foedus::storage::masstree::kInitiallyNextLayer, foedus::storage::masstree::MasstreeCursor::Route::layer_, and foedus::storage::masstree::MasstreeCursor::Route::page_.

Referenced by delete_record(), get_combined_key(), increment_record(), overwrite_record(), and overwrite_record_primitive().

                                                         {
  ASSERT_ND(is_valid_record());
  const Route* route = cur_route();
  const Layer layer = route->layer_;
  ASSERT_ND(layer == route->page_->get_layer());
  ASSERT_ND(cur_key_in_layer_remainder_ != kInitiallyNextLayer);
  ASSERT_ND(cur_key_length_ == cur_key_in_layer_remainder_ + layer * sizeof(KeySlice));

  std::memcpy(buffer, ASSUME_ALIGNED(cur_route_prefix_be_, 256), layer * sizeof(KeySlice));
  assorted::write_bigendian<KeySlice>(cur_key_in_layer_slice_, buffer + layer * sizeof(KeySlice));
  KeyLength suffix_length = calculate_suffix_length(cur_key_in_layer_remainder_);
  if (suffix_length > 0) {
    std::memcpy(
      buffer + (layer + 1U) * sizeof(KeySlice),
      ASSUME_ALIGNED(cur_key_suffix_, 8),
      suffix_length);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void foedus::storage::masstree::MasstreeCursor::copy_combined_key_part	(	KeyLength	offset,
		KeyLength	len,
		char *	buffer
	)		const

Another version to get a part of the key, from the offset for len bytes.

Definition at line 95 of file masstree_cursor.cpp.

References ASSERT_ND, foedus::storage::masstree::calculate_suffix_length(), foedus::storage::masstree::MasstreePage::get_layer(), is_valid_record(), foedus::storage::masstree::kInitiallyNextLayer, foedus::storage::masstree::MasstreeCursor::Route::layer_, and foedus::storage::masstree::MasstreeCursor::Route::page_.

                                                                                               {
  ASSERT_ND(is_valid_record());
  ASSERT_ND(offset + len <= cur_key_length_);
  const Route* route = cur_route();
  const Layer layer = route->layer_;
  ASSERT_ND(layer == route->page_->get_layer());
  ASSERT_ND(cur_key_in_layer_remainder_ != kInitiallyNextLayer);
  ASSERT_ND(cur_key_length_ == cur_key_in_layer_remainder_ + layer * sizeof(KeySlice));

  const KeyLength prefix_len = layer * sizeof(KeySlice);
  KeyLength buffer_pos = 0;
  KeyLength len_remaining = len;
  if (offset < prefix_len) {
    KeyLength prefix_copy_len = std::min<KeyLength>(prefix_len - offset, len_remaining);
    std::memcpy(buffer, cur_route_prefix_be_ + offset, prefix_copy_len);
    buffer_pos += prefix_copy_len;
    len_remaining -= prefix_copy_len;
  }

  if (len_remaining > 0) {
    if (offset < prefix_len + sizeof(KeySlice)) {
      char cur_slice_be[sizeof(KeySlice)];
      assorted::write_bigendian<KeySlice>(cur_key_in_layer_slice_, cur_slice_be);

      KeyLength cur_slice_offset = offset - prefix_len;
      KeyLength cur_slice_copy_len
        = std::min<KeyLength>(sizeof(KeySlice) - cur_slice_offset, len_remaining);
      std::memcpy(buffer + buffer_pos, cur_slice_be + cur_slice_offset, cur_slice_copy_len);
      buffer_pos += cur_slice_copy_len;
      len_remaining -= cur_slice_copy_len;
    }

    if (len_remaining > 0) {
      KeyLength suffix_offset = offset - prefix_len - sizeof(KeySlice);
      KeyLength suffix_length = calculate_suffix_length(cur_key_in_layer_remainder_);
      KeyLength suffix_copy_len = std::min<KeyLength>(suffix_length - suffix_offset, len_remaining);
      std::memcpy(
        buffer + buffer_pos,
        cur_key_suffix_ + suffix_offset,
        suffix_copy_len);
      buffer_pos += suffix_copy_len;
      len_remaining -= suffix_copy_len;
    }
  }

  ASSERT_ND(buffer_pos == len);
  ASSERT_ND(len_remaining == 0);
}

Here is the call graph for this function:

ErrorCode foedus::storage::masstree::MasstreeCursor::delete_record

(

)

Definition at line 1305 of file masstree_cursor.cpp.

References copy_combined_key(), foedus::storage::masstree::MasstreeStoragePimpl::delete_general(), and foedus::storage::masstree::kMaxKeyLength.

                                        {
  assert_modify();
  char key[kMaxKeyLength];
  copy_combined_key(key);
  return MasstreeStoragePimpl(&storage_).delete_general(
    context_,
    cur_key_location_,
    key,
    cur_key_length_);
}

Here is the call graph for this function:

std::string foedus::storage::masstree::MasstreeCursor::get_combined_key ( ) const

inline

For even handier use, it returns std::string.

It's SLOOOW. So use it as such.

Definition at line 280 of file masstree_cursor.hpp.

References copy_combined_key(), and foedus::storage::masstree::kMaxKeyLength.

                                                   {
    char buf[kMaxKeyLength];
    copy_combined_key(buf);
    return std::string(buf, cur_key_length_);
  }

Here is the call graph for this function:

thread::Thread* foedus::storage::masstree::MasstreeCursor::get_context ( )

inline

Definition at line 186 of file masstree_cursor.hpp.

{ return context_; }

const char* foedus::storage::masstree::MasstreeCursor::get_cur_route_prefix_be ( ) const

inline

Big-endian version.

Definition at line 239 of file masstree_cursor.hpp.

                                                            {
    return cur_route_prefix_be_;
  }

const KeySlice* foedus::storage::masstree::MasstreeCursor::get_cur_route_prefix_slices ( ) const

inline

Returns the prefix slices upto the current page.

When the current page is in layer-n, first n slices are set.

Definition at line 235 of file masstree_cursor.hpp.

                                                                    {
    return cur_route_prefix_slices_;
  }

KeySlice foedus::storage::masstree::MasstreeCursor::get_key_in_layer_slice ( ) const

inline

Returns only the slice of the key in the layer of the current page.

Mostly internal use

Definition at line 243 of file masstree_cursor.hpp.

References ASSERT_ND, and is_valid_record().

                                                           {
    ASSERT_ND(is_valid_record());
    return cur_key_in_layer_slice_;
  }

Here is the call graph for this function:

KeyLength foedus::storage::masstree::MasstreeCursor::get_key_length ( ) const

inline

Returns the length of the whole key we are currently pointing to.

Definition at line 227 of file masstree_cursor.hpp.

References ASSERT_ND, and is_valid_record().

                                                   {
    ASSERT_ND(is_valid_record());
    return cur_key_length_;
  }

Here is the call graph for this function:

const char* foedus::storage::masstree::MasstreeCursor::get_key_suffix ( ) const

inline

Returns the suffix part of the key in the page.

Mostly internal use

Definition at line 248 of file masstree_cursor.hpp.

References ASSERT_ND, and is_valid_record().

                                                   {
    ASSERT_ND(is_valid_record());
    return cur_key_suffix_;
  }

Here is the call graph for this function:

KeySlice foedus::storage::masstree::MasstreeCursor::get_normalized_key ( ) const

inline

This method assumes the key length is at most 8 bytes.

Instead, it's fast and handy.

Definition at line 253 of file masstree_cursor.hpp.

References ASSERT_ND, and is_valid_record().

                                                       {
    ASSERT_ND(is_valid_record());
    ASSERT_ND(cur_key_length_ <= sizeof(KeySlice));
    return cur_key_in_layer_slice_;
  };

Here is the call graph for this function:

const char* foedus::storage::masstree::MasstreeCursor::get_payload ( ) const

inline

Definition at line 286 of file masstree_cursor.hpp.

References ASSERT_ND, and is_valid_record().

                                                {
    ASSERT_ND(is_valid_record());
    return cur_payload_;
  }

Here is the call graph for this function:

PayloadLength foedus::storage::masstree::MasstreeCursor::get_payload_length ( ) const

inline

Definition at line 290 of file masstree_cursor.hpp.

References ASSERT_ND, and is_valid_record().

                                                          {
    ASSERT_ND(is_valid_record());
    return cur_payload_length_;
  }

Here is the call graph for this function:

MasstreeStorage& foedus::storage::masstree::MasstreeCursor::get_storage ( )

inline

Definition at line 187 of file masstree_cursor.hpp.

{ return storage_; }

template<typename PAYLOAD >

ErrorCode foedus::storage::masstree::MasstreeCursor::increment_record	(	PAYLOAD *	value,
		PayloadLength	payload_offset
	)

Definition at line 1317 of file masstree_cursor.cpp.

References copy_combined_key(), foedus::storage::masstree::MasstreeStoragePimpl::increment_general(), and foedus::storage::masstree::kMaxKeyLength.

                                                                                       {
  assert_modify();
  char key[kMaxKeyLength];
  copy_combined_key(key);
  return MasstreeStoragePimpl(&storage_).increment_general<PAYLOAD>(
    context_,
    cur_key_location_,
    key,
    cur_key_length_,
    value,
    payload_offset);
}

Here is the call graph for this function:

bool foedus::storage::masstree::MasstreeCursor::is_for_writes ( ) const

inline

Definition at line 188 of file masstree_cursor.hpp.

{ return for_writes_; }

bool foedus::storage::masstree::MasstreeCursor::is_forward_cursor ( ) const

inline

Definition at line 189 of file masstree_cursor.hpp.

{ return forward_cursor_; }

bool foedus::storage::masstree::MasstreeCursor::is_valid_record ( ) const

inline

Definition at line 223 of file masstree_cursor.hpp.

References foedus::storage::masstree::MasstreeCursor::Route::is_valid_record().

Referenced by copy_combined_key(), copy_combined_key_part(), get_key_in_layer_slice(), get_key_length(), get_key_suffix(), get_normalized_key(), get_payload(), get_payload_length(), next(), and open().

                                                  {
    return route_count_ > 0 && !reached_end_ && cur_route()->is_valid_record();
  }

Here is the call graph for this function:

Here is the caller graph for this function:

ErrorCode foedus::storage::masstree::MasstreeCursor::next

(

)

Moves the cursor to next record.

When the cursor already reached the end, it does nothing.

Implementation note

This method changes a complete state of the cursor to a next complete status. In other words, this must NOT be called from other internal methods when this object is in interim state (such as should_skip_cur_route_==true). When this method returns, it is guaranteed that should_skip_cur_route_==false for this reason.

Definition at line 174 of file masstree_cursor.cpp.

References ASSERT_ND, CHECK_ERROR_CODE, foedus::xct::XctId::is_deleted(), is_valid_record(), foedus::kErrorCodeOk, and foedus::storage::masstree::RecordLocation::observed_.

                               {
  ASSERT_ND(!should_skip_cur_route_);
  if (!is_valid_record()) {
    return kErrorCodeOk;
  }

  assert_route();

  CHECK_ERROR_CODE(proceed_route());

  // After proceed_route(), it is still possible that we are at a deleted record or empty page.
  // Keep moving on in that case.
  while (should_skip_cur_route_
    || (is_valid_record() && cur_key_location_.observed_.is_deleted())) {
    DVLOG(0) << "Rare. next() needs to move on to find non-deleted records/pages";
    should_skip_cur_route_ = false;
    CHECK_ERROR_CODE(proceed_route());
    if (route_count_ == 0) {
      LOG(INFO) << "The empty page was the last page that might have had the record. we are done";
      ASSERT_ND(!is_valid_record());
      return kErrorCodeOk;
    }
  }
  ASSERT_ND(!should_skip_cur_route_);
  check_end_key();
  if (is_valid_record()) {
    assert_route();
    ASSERT_ND(!cur_key_location_.observed_.is_deleted());
  }
  return kErrorCodeOk;
}

Here is the call graph for this function:

ErrorCode foedus::storage::masstree::MasstreeCursor::open	(	const char *	begin_key = nullptr,
		KeyLength	begin_key_length = kKeyLengthExtremum,
		const char *	end_key = nullptr,
		KeyLength	end_key_length = kKeyLengthExtremum,
		bool	forward_cursor = true,
		bool	for_writes = false,
		bool	begin_inclusive = true,
		bool	end_inclusive = false
	)

Definition at line 932 of file masstree_cursor.cpp.

References ASSERT_ND, CHECK_ERROR_CODE, foedus::storage::masstree::copy_input_key(), foedus::storage::masstree::MasstreeStoragePimpl::get_first_root(), foedus::xct::Xct::is_active(), foedus::xct::XctId::is_deleted(), is_valid_record(), kBackwardExclusive, kBackwardInclusive, foedus::kErrorCodeOk, foedus::kErrorCodeXctNoXct, kForwardExclusive, kForwardInclusive, and foedus::storage::masstree::RecordLocation::observed_.

Referenced by open_normalized().

                      {
  CHECK_ERROR_CODE(allocate_if_not_exist(&routes_));
  CHECK_ERROR_CODE(allocate_if_not_exist(&search_key_));
  CHECK_ERROR_CODE(allocate_if_not_exist(&search_key_slices_));
  CHECK_ERROR_CODE(allocate_if_not_exist(&cur_route_prefix_slices_));
  CHECK_ERROR_CODE(allocate_if_not_exist(&cur_route_prefix_be_));
  CHECK_ERROR_CODE(allocate_if_not_exist(&end_key_));
  CHECK_ERROR_CODE(allocate_if_not_exist(&end_key_slices_));

  if (!current_xct_->is_active()) {
    return kErrorCodeXctNoXct;
  }

  forward_cursor_ = forward_cursor;
  reached_end_ = false;
  for_writes_ = for_writes;
  end_inclusive_ = end_inclusive;
  end_key_length_ = end_key_length;
  route_count_ = 0;
  if (!is_end_key_supremum()) {
    copy_input_key(end_key, end_key_length, end_key_, end_key_slices_);
  }

  search_key_length_ = begin_key_length;
  search_type_ = forward_cursor ? (begin_inclusive ? kForwardInclusive : kForwardExclusive)
                  : (begin_inclusive ? kBackwardInclusive : kBackwardExclusive);
  if (!is_search_key_extremum()) {
    copy_input_key(begin_key, begin_key_length, search_key_, search_key_slices_);
  }

  MasstreeIntermediatePage* root;
  MasstreeStoragePimpl pimpl(&storage_);
  CHECK_ERROR_CODE(pimpl.get_first_root(context_, for_writes, &root));
  CHECK_ERROR_CODE(push_route(root));
  CHECK_ERROR_CODE(locate_layer(0));
  ASSERT_ND(route_count_ != 0);
  ASSERT_ND(cur_route()->page_->is_border());
  ASSERT_ND(should_skip_cur_route_ || (!should_skip_cur_route_ && is_valid_record()));

  // In a few cases, open() must move on to next page/key.
  // 1. locate_xxx doesn't take care of deleted record as it can't proceed to another page.
  //  so, if the initially located record is a deleted record, we need to move on to next key.
  // 2. unluckily we hit an empty page or the page boundary in initial locate().
  //  Let's go on to next page by proceed_route() and find a next page.
  // Note, it's a while, not if. It's very unlikely but possible that proceed_route again
  // results in the same state.
  while (should_skip_cur_route_
      || (is_valid_record() && cur_key_location_.observed_.is_deleted())) {
    DVLOG(0) << "Rare. open() needs to move on to find non-deleted records/pages";
    should_skip_cur_route_ = false;
    CHECK_ERROR_CODE(proceed_route());
    if (route_count_ == 0) {
      LOG(INFO) << "The empty page was the last page that might have had the record. we are done";
      ASSERT_ND(!is_valid_record());
      return kErrorCodeOk;
    }
  }
  ASSERT_ND(!should_skip_cur_route_);
  ASSERT_ND(!is_valid_record() || !cur_key_location_.observed_.is_deleted());
  check_end_key();
  if (is_valid_record()) {
    assert_route();
  }
  return kErrorCodeOk;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ErrorCode foedus::storage::masstree::MasstreeCursor::open_normalized ( KeySlice  begin_key, KeySlice  end_key, bool  forward_cursor = true, bool  for_writes = false, bool  begin_inclusive = true, bool  end_inclusive = false  )

inline

Definition at line 201 of file masstree_cursor.hpp.

References ASSERT_ND, and open().

                                {
    ASSERT_ND((forward_cursor && end_key >= begin_key) ||
      (!forward_cursor && end_key <= begin_key));
    KeySlice begin_key_be = assorted::htobe<KeySlice>(begin_key);
    KeySlice end_key_be = assorted::htobe<KeySlice>(end_key);
    return open(
      reinterpret_cast<const char*>(&begin_key_be),
      sizeof(KeySlice),
      reinterpret_cast<const char*>(&end_key_be),
      sizeof(KeySlice),
      forward_cursor,
      for_writes,
      begin_inclusive,
      end_inclusive);
  }

Here is the call graph for this function:

ErrorCode foedus::storage::masstree::MasstreeCursor::overwrite_record	(	const void *	payload,
		PayloadLength	payload_offset,
		PayloadLength	payload_count
	)

Definition at line 1271 of file masstree_cursor.cpp.

References copy_combined_key(), foedus::storage::masstree::kMaxKeyLength, and foedus::storage::masstree::MasstreeStoragePimpl::overwrite_general().

                               {
  assert_modify();
  char key[kMaxKeyLength];
  copy_combined_key(key);
  return MasstreeStoragePimpl(&storage_).overwrite_general(
    context_,
    cur_key_location_,
    key,
    cur_key_length_,
    payload,
    payload_offset,
    payload_count);
}

Here is the call graph for this function:

template<typename PAYLOAD >

ErrorCode foedus::storage::masstree::MasstreeCursor::overwrite_record_primitive	(	PAYLOAD	payload,
		PayloadLength	payload_offset
	)

Definition at line 1289 of file masstree_cursor.cpp.

References copy_combined_key(), foedus::storage::masstree::kMaxKeyLength, and foedus::storage::masstree::MasstreeStoragePimpl::overwrite_general().

                                {
  assert_modify();
  char key[kMaxKeyLength];
  copy_combined_key(key);
  return MasstreeStoragePimpl(&storage_).overwrite_general(
    context_,
    cur_key_location_,
    key,
    cur_key_length_,
    &payload,
    payload_offset,
    sizeof(PAYLOAD));
}

Here is the call graph for this function:

---

The documentation for this class was generated from the following files:

• /home/shino/foedus_code/foedus-core/include/foedus/storage/masstree/masstree_cursor.hpp
• /home/shino/foedus_code/foedus-core/src/foedus/storage/masstree/masstree_cursor.cpp