foundationdb/fdbclient/KeyRangeMap.h

/*
 * KeyRangeMap.h
 *
 * This source file is part of the FoundationDB open source project
 *
 * Copyright 2013-2018 Apple Inc. and the FoundationDB project authors
 *
 * 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.
 */

#ifndef FLOW_KEYRANGEMAP_H
#define FLOW_KEYRANGEMAP_H
#pragma once

#include "flow/flow.h"
#include "fdbclient/FDBTypes.h"
#include "boost/range.hpp"
#include "flow/IndexedSet.h"
#include "fdbclient/SystemData.h"
#include "fdbrpc/RangeMap.h"
#include "fdbclient/Knobs.h"

using boost::iterator_range;

template <class Val, class Metric=int, class MetricFunc = ConstantMetric<Metric>>
class KeyRangeMap : public RangeMap<Key,Val,KeyRangeRef,Metric,MetricFunc>, NonCopyable, public ReferenceCounted<KeyRangeMap<Val>> {
public:
	explicit KeyRangeMap(Val v=Val(), Key endKey = allKeys.end) : RangeMap<Key,Val,KeyRangeRef,Metric,MetricFunc>(endKey, v), mapEnd(endKey) {}
	void operator=(KeyRangeMap&& r) BOOST_NOEXCEPT { mapEnd = std::move(r.mapEnd); RangeMap<Key,Val,KeyRangeRef,Metric,MetricFunc>::operator=(std::move(r)); }
	void insert( const KeyRangeRef& keys, const Val& value ) { RangeMap<Key,Val,KeyRangeRef,Metric,MetricFunc>::insert(keys, value); }
	void insert( const KeyRef& key, const Val& value ) { RangeMap<Key,Val,KeyRangeRef,Metric,MetricFunc>::insert( singleKeyRange(key), value); }
	std::vector<KeyRangeWith<Val>> getAffectedRangesAfterInsertion( const KeyRangeRef& keys, const Val &insertionValue = Val());
	typename RangeMap<Key,Val,KeyRangeRef,Metric,MetricFunc>::Ranges modify( const KeyRangeRef& keys ) // Returns ranges, the first of which begins at keys.begin and the last of which ends at keys.end
	{
		MapPair<Key,Val> valueBeforeRange(keys.begin, RangeMap<Key,Val,KeyRangeRef,Metric>::rangeContaining(keys.begin).value());
		MapPair<Key,Val> valueAfterRange(keys.end, RangeMap<Key,Val,KeyRangeRef,Metric>::rangeContaining(keys.end).value());

		RangeMap<Key,Val,KeyRangeRef,Metric,MetricFunc>::map.insert(std::move(valueBeforeRange));
		RangeMap<Key,Val,KeyRangeRef,Metric,MetricFunc>::map.insert(std::move(valueAfterRange));
		return RangeMap<Key,Val,KeyRangeRef,Metric,MetricFunc>::intersectingRanges( keys );
	}

	void rawErase( KeyRange const& range )  {
		RangeMap<Key,Val,KeyRangeRef,Metric,MetricFunc>::map.erase(RangeMap<Key,Val,KeyRangeRef,Metric,MetricFunc>::map.lower_bound(range.begin), RangeMap<Key,Val,KeyRangeRef,Metric,MetricFunc>::map.lower_bound(range.end));
	}
	void rawInsert( Key const& key, Val const& value )  {
		MapPair<Key,Val> pair(key, value);
		RangeMap<Key,Val,KeyRangeRef,Metric,MetricFunc>::map.insert(pair, true, RangeMap<Key,Val,KeyRangeRef,Metric,MetricFunc>::mf(pair));
	}
	void rawInsert( const std::vector<std::pair<MapPair<Key,Val>, Metric>>& pairs )  {
		RangeMap<Key,Val,KeyRangeRef,Metric,MetricFunc>::map.insert(pairs);
	}
	Key mapEnd;
};

template <class Val, class Metric=int, class MetricFunc = ConstantMetric<Metric>>
class CoalescedKeyRefRangeMap : public RangeMap<KeyRef,Val,KeyRangeRef,Metric,MetricFunc>, NonCopyable {
public:
	explicit CoalescedKeyRefRangeMap(Val v=Val(), Key endKey = allKeys.end) : RangeMap<KeyRef,Val,KeyRangeRef,Metric,MetricFunc>(endKey, v), mapEnd(endKey) {}
	void operator=(CoalescedKeyRefRangeMap&& r) BOOST_NOEXCEPT { mapEnd = std::move(r.mapEnd); RangeMap<KeyRef, Val, KeyRangeRef,Metric,MetricFunc>::operator=(std::move(r)); }
	void insert( const KeyRangeRef& keys, const Val& value );
	void insert( const KeyRef& key, const Val& value, Arena& arena );
	Key mapEnd;
};

template <class Val, class Metric=int, class MetricFunc = ConstantMetric<Metric>>
class CoalescedKeyRangeMap : public RangeMap<Key,Val,KeyRangeRef,Metric,MetricFunc>, NonCopyable {
public:
	explicit CoalescedKeyRangeMap(Val v=Val(), Key endKey = allKeys.end) : RangeMap<Key,Val,KeyRangeRef,Metric,MetricFunc>(endKey, v), mapEnd(endKey) {}
	void operator=(CoalescedKeyRangeMap&& r) BOOST_NOEXCEPT { mapEnd = std::move(r.mapEnd); RangeMap<Key,Val,KeyRangeRef,Metric,MetricFunc>::operator=(std::move(r)); }
	void insert( const KeyRangeRef& keys, const Val& value );
	void insert( const KeyRef& key, const Val& value );
	Key mapEnd;
};

class KeyRangeActorMap {
public:
	void getRangesAffectedByInsertion( const KeyRangeRef& keys, vector< KeyRange >& affectedRanges );
	void insert( const KeyRangeRef& keys, const Future<Void>& value ) { map.insert( keys, value ); }
	void cancel( const KeyRangeRef& keys ) { insert( keys, Future<Void>() ); }
	bool liveActorAt( const KeyRef& key ) { Future<Void> actorAt = map[key]; return actorAt.isValid() && !actorAt.isReady(); }
private:
	KeyRangeMap< Future<Void> > map;
};

// krm*(): KeyRangeMap-like abstraction stored in the database, accessed through Transactions
class Transaction;
class ReadYourWritesTransaction;
Future<Standalone<RangeResultRef>> krmGetRanges( Transaction* const& tr, Key const& mapPrefix, KeyRange const& keys, int const& limit = CLIENT_KNOBS->KRM_GET_RANGE_LIMIT, int const& limitBytes = CLIENT_KNOBS->KRM_GET_RANGE_LIMIT_BYTES );
Future<Standalone<RangeResultRef>> krmGetRanges( Reference<ReadYourWritesTransaction> const& tr, Key const& mapPrefix, KeyRange const& keys, int const& limit = CLIENT_KNOBS->KRM_GET_RANGE_LIMIT, int const& limitBytes = CLIENT_KNOBS->KRM_GET_RANGE_LIMIT_BYTES );
void krmSetPreviouslyEmptyRange( Transaction* tr, const KeyRef& mapPrefix, const KeyRangeRef& keys, const ValueRef& newValue, const ValueRef& oldEndValue );
void krmSetPreviouslyEmptyRange( struct CommitTransactionRef& tr, Arena& trArena, const KeyRef& mapPrefix, const KeyRangeRef& keys, const ValueRef& newValue, const ValueRef& oldEndValue );
Future<Void> krmSetRange( Transaction* const& tr, Key const& mapPrefix, KeyRange const& range, Value const& value );
Future<Void> krmSetRange( Reference<ReadYourWritesTransaction> const& tr, Key const& mapPrefix, KeyRange const& range, Value const& value );
Future<Void> krmSetRangeCoalescing( Transaction* const& tr, Key const& mapPrefix, KeyRange const& range, KeyRange const& maxRange, Value const& value );
Future<Void> krmSetRangeCoalescing(Reference<ReadYourWritesTransaction> const& tr, Key const& mapPrefix,
                                   KeyRange const& range, KeyRange const& maxRange, Value const& value);
Standalone<RangeResultRef> krmDecodeRanges( KeyRef mapPrefix, KeyRange keys, Standalone<RangeResultRef> kv );

template <class Val, class Metric, class MetricFunc>
std::vector<KeyRangeWith<Val>> KeyRangeMap<Val,Metric,MetricFunc>::getAffectedRangesAfterInsertion( const KeyRangeRef& keys, const Val &insertionValue) {
	std::vector<KeyRangeWith<Val>> affectedRanges;

	{ // possible first range if no exact alignment
		auto r = RangeMap<Key,Val,KeyRangeRef,Metric,MetricFunc>::rangeContaining( keys.begin );
		if (r->begin() != keys.begin)
			affectedRanges.push_back(
				KeyRangeWith<Val>( 
					KeyRangeRef(r->begin(), keys.begin), r->value() ) );
	}

	affectedRanges.push_back( KeyRangeWith<Val>( keys, insertionValue) );

	{ // possible last range if no exact alignment
		auto r = RangeMap<Key,Val,KeyRangeRef,Metric,MetricFunc>::rangeContaining( keys.end );
		if (r->begin() != keys.end)
			affectedRanges.push_back(
				KeyRangeWith<Val>( 
					KeyRangeRef(keys.end, r->end()), r->value() ) );
	}

	return affectedRanges;
}

template <class Val, class Metric, class MetricFunc>
void CoalescedKeyRangeMap<Val,Metric,MetricFunc>::insert( const KeyRangeRef& keys, const Val& value ) {
	ASSERT(keys.end <= mapEnd);

	if( keys.empty() )
		return;

	auto begin = RangeMap<Key,Val,KeyRangeRef,Metric,MetricFunc>::map.lower_bound( keys.begin );
	auto end = RangeMap<Key,Val,KeyRangeRef,Metric,MetricFunc>::map.lower_bound( keys.end );
	bool insertEnd = false;
	bool insertBegin = false;
	Val endVal;

	if( keys.end != mapEnd ) {
		if( end->key != keys.end ) {
			auto before_end = end;
			before_end.decrementNonEnd();
			if( value != before_end->value ) {
				insertEnd = true;
				endVal = before_end->value;
			}
		}

		if( !insertEnd && end->value == value && end->key != mapEnd ) {
			++end;
		}
	}

	if( keys.begin == allKeys.begin ) {
		insertBegin = true;
	} else {
		auto before_begin = begin;
		before_begin.decrementNonEnd();
		if( before_begin->value != value )
			insertBegin = true;
	}
	
	RangeMap<Key,Val,KeyRangeRef,Metric,MetricFunc>::map.erase(begin, end);
	if(insertEnd) {
		MapPair<Key,Val> p(keys.end, endVal);
		RangeMap<Key,Val,KeyRangeRef,Metric,MetricFunc>::map.insert(p, true, RangeMap<Key,Val,KeyRangeRef,Metric,MetricFunc>::mf(p));
	}
	if(insertBegin) {
		MapPair<Key,Val> p(keys.begin, value);
		RangeMap<Key,Val,KeyRangeRef,Metric,MetricFunc>::map.insert(p, true, RangeMap<Key,Val,KeyRangeRef,Metric,MetricFunc>::mf(p));
	}
}

template <class Val, class Metric, class MetricFunc>
void CoalescedKeyRangeMap<Val,Metric,MetricFunc>::insert( const KeyRef& key, const Val& value ) {
	ASSERT(key < mapEnd);

	auto begin = RangeMap<Key,Val,KeyRangeRef,Metric,MetricFunc>::map.lower_bound( key );
	auto end = begin;
	if( end->key == key )
		++end;

	bool insertEnd = false;
	bool insertBegin = false;
	Val endVal;

	if( !equalsKeyAfter( key, end->key ) ) {
		auto before_end = end;
		before_end.decrementNonEnd();
		if( value != before_end->value ) {
			insertEnd = true;
			endVal = before_end->value;
		}
	}

	if( !insertEnd && end->value == value && end->key != mapEnd ) {
		++end;
	}

	if( key == allKeys.begin ) {
		insertBegin = true;
	} else {
		auto before_begin = begin;
		before_begin.decrementNonEnd();
		if( before_begin->value != value )
			insertBegin = true;
	}
	
	RangeMap<Key,Val,KeyRangeRef,Metric,MetricFunc>::map.erase(begin, end);
	if(insertEnd) {
		MapPair<Key,Val> p(keyAfter(key), endVal);
		RangeMap<Key,Val,KeyRangeRef,Metric,MetricFunc>::map.insert(p, true, RangeMap<Key,Val,KeyRangeRef,Metric,MetricFunc>::mf(p));
	}
	if(insertBegin) {
		MapPair<Key,Val> p(key, value);
		RangeMap<Key,Val,KeyRangeRef,Metric,MetricFunc>::map.insert(p, true, RangeMap<Key,Val,KeyRangeRef,Metric,MetricFunc>::mf(p));
	}
}

template <class Val, class Metric, class MetricFunc>
void CoalescedKeyRefRangeMap<Val,Metric,MetricFunc>::insert( const KeyRangeRef& keys, const Val& value ) {
	ASSERT(keys.end <= mapEnd);

	if( keys.empty() )
		return;

	auto begin = RangeMap<KeyRef,Val,KeyRangeRef,Metric,MetricFunc>::map.lower_bound( keys.begin );
	auto end = RangeMap<KeyRef,Val,KeyRangeRef,Metric,MetricFunc>::map.lower_bound( keys.end );
	bool insertEnd = false;
	bool insertBegin = false;
	Val endVal;

	if( keys.end != mapEnd ) {
		if( end->key != keys.end ) {
			auto before_end = end;
			before_end.decrementNonEnd();
			if( value != before_end->value ) {
				insertEnd = true;
				endVal = before_end->value;
			}
		}

		if( !insertEnd && end->value == value && end->key != mapEnd ) {
			++end;
		}
	}

	if( keys.begin == allKeys.begin ) {
		insertBegin = true;
	} else {
		auto before_begin = begin;
		before_begin.decrementNonEnd();
		if( before_begin->value != value )
			insertBegin = true;
	}
	
	RangeMap<KeyRef,Val,KeyRangeRef,Metric,MetricFunc>::map.erase(begin, end);
	if(insertEnd) {
		MapPair<KeyRef,Val> p(keys.end, endVal);
		RangeMap<KeyRef,Val,KeyRangeRef,Metric,MetricFunc>::map.insert(p, true, RangeMap<KeyRef,Val,KeyRangeRef,Metric,MetricFunc>::mf(p));
	}
	if(insertBegin) {
		MapPair<KeyRef,Val> p(keys.begin, value);
		RangeMap<KeyRef,Val,KeyRangeRef,Metric,MetricFunc>::map.insert(p, true, RangeMap<KeyRef,Val,KeyRangeRef,Metric,MetricFunc>::mf(p));
	}
}

template <class Val, class Metric, class MetricFunc>
void CoalescedKeyRefRangeMap<Val,Metric,MetricFunc>::insert( const KeyRef& key, const Val& value, Arena& arena ) {
	ASSERT(key < mapEnd);

	auto begin = RangeMap<KeyRef,Val,KeyRangeRef,Metric,MetricFunc>::map.lower_bound( key );
	auto end = begin;
	if( end->key == key )
		++end;

	bool insertEnd = false;
	bool insertBegin = false;
	Val endVal;

	if( !equalsKeyAfter( key, end->key ) ) {
		auto before_end = end;
		before_end.decrementNonEnd();
		if( value != before_end->value ) {
			insertEnd = true;
			endVal = before_end->value;
		}
	}

	if( !insertEnd && end->value == value && end->key != mapEnd ) {
		++end;
	}

	if( key == allKeys.begin ) {
		insertBegin = true;
	} else {
		auto before_begin = begin;
		before_begin.decrementNonEnd();
		if( before_begin->value != value )
			insertBegin = true;
	}
	
	RangeMap<KeyRef,Val,KeyRangeRef,Metric,MetricFunc>::map.erase(begin, end);
	if(insertEnd) {
		MapPair<KeyRef,Val> p(keyAfter(key, arena), endVal);
		RangeMap<KeyRef,Val,KeyRangeRef,Metric,MetricFunc>::map.insert(p, true, RangeMap<KeyRef,Val,KeyRangeRef,Metric,MetricFunc>::mf(p));
	}
	if(insertBegin) {
		MapPair<KeyRef,Val> p(key,value);
		RangeMap<KeyRef,Val,KeyRangeRef,Metric,MetricFunc>::map.insert(p, true, RangeMap<KeyRef,Val,KeyRangeRef,Metric,MetricFunc>::mf(p));
	}
}

#endif