X RangedMap - like RangedSet but for dict

This data structure will be used to implement concurrency in ΔBtail.

* t2+RangedMap: (45 commits)
  .
  .
  .
  X fixes for empty set/range
  .
  .
  .
  .
  X Tests for Get
  .
  X SetRange draftly works
  .
  .
  .
  .
  .
  .
  .
  X need to keep Value first so that sizeof(set-entry) = sizeof(KeyRange)
  .
  ...

wcfs/internal/xbtree/blib/gen-rangemap

+#!/bin/bash -e
+# rangemap.go.in -> specialized with concrete types
+# gen-rangemap TYPE VALUE out
+
+# Copyright (C) 2018-2021  Nexedi SA and Contributors.
+#                          Kirill Smelkov <kirr@nexedi.com>
+#
+# This program is free software: you can Use, Study, Modify and Redistribute
+# it under the terms of the GNU General Public License version 3, or (at your
+# option) any later version, as published by the Free Software Foundation.
+#
+# You can also Link and Combine this program with other software covered by
+# the terms of any of the Free Software licenses or any of the Open Source
+# Initiative approved licenses and Convey the resulting work. Corresponding
+# source of such a combination shall include the source code for all other
+# software used.
+#
+# This program is distributed WITHOUT ANY WARRANTY; without even the implied
+# warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+#
+# See COPYING file for full licensing terms.
+# See https://www.nexedi.com/licensing for rationale and options.
+
+TYPE=$1
+VALUE=$2
+out=$3
+
+input=$(dirname $0)/rangemap.go.in
+
+echo "// Code generated by gen-rangemap $TYPE $VALUE; DO NOT EDIT." >$out
+echo >>$out
+
+sed	\
+	-e "s/VALUE/$VALUE/g"		\
+	-e "s/\bRangedMap\b/${TYPE}/g"			\
+	-e "s/\bRangedMapEntry\b/${TYPE}Entry/g"		\
+	-e "s/\bvInsert\b/vInsert_${TYPE}/g"		\
+	-e "s/\bvDeleteSlice\b/vDeleteSlice_${TYPE}/g"	\
+	-e "s/\bvReplaceSlice\b/vReplaceSlice_${TYPE}/g"\
+	-e "s/\btraceRangeMap\b/trace${TYPE}/g"		\
+	-e "s/\bdebugRangeMap\b/debug${TYPE}/g"		\
+	-e "s/\bdebugfRMap\b/debugf${TYPE}/g"		\
+	$input >>$out

wcfs/internal/xbtree/blib/keyrange.go

+// Copyright (C) 2021  Nexedi SA and Contributors.
+//                     Kirill Smelkov <kirr@nexedi.com>
+//
+// This program is free software: you can Use, Study, Modify and Redistribute
+// it under the terms of the GNU General Public License version 3, or (at your
+// option) any later version, as published by the Free Software Foundation.
+//
+// You can also Link and Combine this program with other software covered by
+// the terms of any of the Free Software licenses or any of the Open Source
+// Initiative approved licenses and Convey the resulting work. Corresponding
+// source of such a combination shall include the source code for all other
+// software used.
+//
+// This program is distributed WITHOUT ANY WARRANTY; without even the implied
+// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+//
+// See COPYING file for full licensing terms.
+// See https://www.nexedi.com/licensing for rationale and options.
+
+package blib
+// range of keys.
+
+import (
+	"fmt"
+)
+
+
+// KeyRange represents [lo,hi) Key range.
+type KeyRange struct {
+	Lo  Key
+	Hi_ Key // NOTE _not_ hi) to avoid overflow at ∞;  hi = hi_ + 1
+}
+
+
+// Has returns whether key k belongs to the range.
+func (r *KeyRange) Has(k Key) bool {
+	return (r.Lo <= k && k <= r.Hi_)
+}
+
+// Empty returns whether key range is empty.
+func (r *KeyRange) Empty() bool {
+	hi := r.Hi_
+	if hi == KeyMax {
+		// [x,∞] cannot be empty because max x is ∞ and [∞,∞] has one element: ∞
+		return false
+	}
+	hi++ // no overflow
+	return r.Lo >= hi
+}
+
+
+func (r KeyRange) String() string {
+	var shi string
+	if r.Hi_ == KeyMax {
+		shi = KStr(r.Hi_) // ∞
+	} else {
+		shi = fmt.Sprintf("%d", r.Hi_+1)
+	}
+	return fmt.Sprintf("[%s,%s)", KStr(r.Lo), shi)
+}

wcfs/internal/xbtree/blib/rangemap.go.in

+// Copyright (C) 2021  Nexedi SA and Contributors.
+//                     Kirill Smelkov <kirr@nexedi.com>
+//
+// This program is free software: you can Use, Study, Modify and Redistribute
+// it under the terms of the GNU General Public License version 3, or (at your
+// option) any later version, as published by the Free Software Foundation.
+//
+// You can also Link and Combine this program with other software covered by
+// the terms of any of the Free Software licenses or any of the Open Source
+// Initiative approved licenses and Convey the resulting work. Corresponding
+// source of such a combination shall include the source code for all other
+// software used.
+//
+// This program is distributed WITHOUT ANY WARRANTY; without even the implied
+// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+//
+// See COPYING file for full licensing terms.
+// See https://www.nexedi.com/licensing for rationale and options.
+
+package blib
+// map [lo,hi) Key ranges to values.
+
+import (
+	"fmt"
+	"sort"
+)
+
+const traceRangeMap = false
+const debugRangeMap = false
+
+// RangedMap is Key->VALUE map with adjacent keys mapped to the same value coalesced into Ranges.
+//
+// Zero value represents empty map.
+type RangedMap struct {
+	// TODO rework to use BTree lo->hi_ instead if in practice in treediff,
+	// and other usage places, N(ranges) turns out to be not small
+	// (i.e. performance turns out to be not acceptable)
+	entryv []RangedMapEntry // lo↑
+}
+
+// RangedMapEntry represents one entry in RangedMap.
+type RangedMapEntry struct {
+	Value    VALUE
+	KeyRange
+}
+
+
+// Get returns value associated with key k.
+func (M *RangedMap) Get(k Key) VALUE {
+	v, _ := M.Get_(k)
+	return v
+}
+
+// Set changes M to map key k to value v.
+func (M *RangedMap) Set(k Key, v VALUE) {
+	M.SetRange(KeyRange{Lo: k, Hi_: k}, v)
+}
+
+// Del removes key k.
+func (M *RangedMap) Del(k Key) {
+	M.DelRange(KeyRange{Lo: k, Hi_: k})
+}
+
+// Has returns whether key k is present in the map.
+func (M *RangedMap) Has(k Key) bool {
+	_, ok := M.Get_(k)
+	return ok
+}
+
+
+
+// Get_ is comma-ok version of Get.
+func (M *RangedMap) Get_(k Key) (v VALUE, ok bool) {
+	if traceRangeMap {
+		fmt.Printf("\n\nGet_:\n")
+		fmt.Printf("  M: %s\n", M)
+		fmt.Printf("  k: %s\n", KStr(k))
+		defer func() {
+			fmt.Printf("->·: %v, %t\n", v, ok)
+		}()
+	}
+
+	M.verify()
+
+	// find first ilo: k < [ilo].hi
+	l := len(M.entryv)
+	ilo := sort.Search(l, func(i int) bool {
+		return k <= M.entryv[i].Hi_
+	})
+	debugfRMap("\tilo: %d\n", ilo)
+
+	if ilo == l { // not found
+		return
+	}
+
+	e := M.entryv[ilo]
+	if !(e.Lo <= k) { // not found
+		return
+	}
+
+	// found
+	return e.Value, true
+}
+
+// SetRange changes M to map key range r to value v.
+func (M *RangedMap) SetRange(r KeyRange, v VALUE) {
+	e := RangedMapEntry{v,r}
+	if traceRangeMap {
+		fmt.Printf("\n\nSetRange:\n")
+		fmt.Printf("  M: %s\n", M)
+		fmt.Printf("  e: %s\n", e)
+		defer fmt.Printf("->·: %s\n", M)
+	}
+
+	M.verify()
+	defer M.verify()
+
+	if r.Empty() {
+		return
+	}
+
+	// clear range for r and insert new entry
+	// TODO optimize for same-value/set case (just merge all covered
+	// entries into one - see commented AddRange from set vvv)
+	i := M.delRange(r)
+	vInsert(&M.entryv, i, e)
+	debugfRMap("\tinsert %s\t-> %s\n", e, M)
+
+	// check if we should merge inserted entry with right/left neighbours
+	if i+1 < len(M.entryv) { // right
+		x     := M.entryv[i]
+		right := M.entryv[i+1]
+		if (x.Hi_+1 == right.Lo) && (v == right.Value) {
+			vReplaceSlice(&M.entryv, i,i+2,
+				RangedMapEntry{v, KeyRange{x.Lo, right.Hi_}})
+			debugfRMap("\tmerge right\t-> %s\n", M)
+		}
+	}
+
+	if i > 0 { // left
+		left := M.entryv[i-1]
+		x    := M.entryv[i]
+		if (left.Hi_+1 == x.Lo) && (left.Value == v) {
+			vReplaceSlice(&M.entryv, i-1,i+1,
+				RangedMapEntry{v, KeyRange{left.Lo, x.Hi_}})
+			debugfRMap("\tmerge left\t-> %s\n", M)
+		}
+	}
+
+	// done
+
+/* how it was for just set:
+	// find first ilo: r.Lo < [ilo].hi
+	l := len(S.rangev)
+	ilo := sort.Search(l, func(i int) bool {
+		 return r.Lo <= S.rangev[i].Hi_
+	})
+	debugfRSet("\tilo: %d\n", ilo)
+
+	if ilo == l { // not found
+		S.rangev = append(S.rangev, r)
+		l++
+		debugfRSet("\tappend %s\t-> %s\n", r, S)
+	}
+
+	// find last jhi: [jhi].Lo < r.hi
+	jhi := ilo
+	for ;; jhi++ {
+		if jhi == l {
+			break
+		}
+		if S.rangev[jhi].Lo <= r.Hi_ {
+			continue
+		}
+		break
+	}
+	debugfRSet("\tjhi: %d\n", jhi)
+
+	// entries in [ilo:jhi) ∈ [r.Lo,r.hi) and should be merged into one
+	if (jhi - ilo) > 1 {
+		lo  := S.rangev[ilo].Lo
+		hi_ := S.rangev[jhi-1].Hi_
+		vReplaceSlice(&S.rangev, ilo,jhi, KeyRange{lo,hi_})
+		debugfRSet("\tmerge S[%d:%d]\t-> %s\n", ilo, jhi, S)
+	}
+	jhi = -1 // no longer valid
+
+	// if [r.lo,r.hi) was outside of any entry - create new entry
+	if r.Hi_ < S.rangev[ilo].Lo {
+		vInsert(&S.rangev, ilo, r)
+		debugfRSet("\tinsert %s\t-> %s\n", r, S)
+	}
+
+	// now we have covered entries merged as needed into [ilo]
+	// extend this entry if r coverage is wider
+	if r.Lo < S.rangev[ilo].Lo {
+		S.rangev[ilo].Lo = r.Lo
+		debugfRSet("\textend left\t-> %s\n", S)
+	}
+	if r.Hi_ > S.rangev[ilo].Hi_ {
+		S.rangev[ilo].Hi_ = r.Hi_
+		debugfRSet("\textend right\t-> %s\n", S)
+	}
+
+	// and check if we should merge it with right/left neighbours
+	if ilo+1 < len(S.rangev) { // right
+		if S.rangev[ilo].Hi_+1 == S.rangev[ilo+1].Lo {
+			vReplaceSlice(&S.rangev, ilo,ilo+2,
+				KeyRange{S.rangev[ilo].Lo, S.rangev[ilo+1].Hi_})
+			debugfRSet("\tmerge right\t-> %s\n", S)
+		}
+	}
+
+	if ilo > 0 { // left
+		if S.rangev[ilo-1].Hi_+1 == S.rangev[ilo].Lo {
+			vReplaceSlice(&S.rangev, ilo-1,ilo+1,
+				KeyRange{S.rangev[ilo-1].Lo, S.rangev[ilo].Hi_})
+			debugfRSet("\tmerge left\t-> %s\n", S)
+		}
+	}
+
+	// done
+*/
+}
+
+// DelRange removes range r from the map.
+func (M *RangedMap) DelRange(r KeyRange) {
+	if traceRangeMap {
+		fmt.Printf("\n\nDelRange:\n")
+		fmt.Printf("  M: %s\n", M)
+		fmt.Printf("  r: %s\n", r)
+		defer fmt.Printf("->·: %s\n", M)
+	}
+
+	M.verify()
+	defer M.verify()
+
+	if r.Empty() {
+		return
+	}
+
+	M.delRange(r)
+}
+
+// delRange deletes range r from the map and returns .entryv index where r
+// should be inserted/appended if needed.
+//
+// r must be !empty.
+func (M *RangedMap) delRange(r KeyRange) (i int) {
+	// find first ilo: r.Lo < [ilo].hi
+	l := len(M.entryv)
+	ilo := sort.Search(l, func(i int) bool {
+		 return r.Lo <= M.entryv[i].Hi_
+	})
+	debugfRMap("\tilo: %d\n", ilo)
+
+	if ilo == l { // not found
+		debugfRMap("\tnon-overlap right\n")
+		return l
+	}
+
+	// find last jhi: [jhi].Lo < r.hi
+	jhi := ilo
+	for ;; jhi++ {
+		if jhi == l {
+			break
+		}
+		if M.entryv[jhi].Lo <= r.Hi_ {
+			continue
+		}
+		break
+	}
+	debugfRMap("\tjhi: %d\n", jhi)
+
+	if jhi == 0 {
+		debugfRMap("\tnon-overlap left\n")
+		return 0
+	}
+
+	// [ilo+1:jhi-1] should be deleted
+	// [ilo] and [jhi-1] overlap with [r.lo,r.hi) - they should be deleted, or shrinked,
+	// or split+shrinked if ilo==jhi-1 and r is inside [ilo]
+	if jhi-ilo == 1 && M.entryv[ilo].Lo < r.Lo && r.Hi_ < M.entryv[ilo].Hi_ {
+		x := M.entryv[ilo]
+		vInsert(&M.entryv, ilo, x)
+		jhi++
+		debugfRMap("\tpresplit copy %s\t-> %s\n", x, M)
+	}
+	if M.entryv[ilo].Lo < r.Lo { // shrink left
+		M.entryv[ilo].Hi_ = r.Lo-1
+		debugfRMap("\tshrink [%d] left \t-> %s\n", ilo, M)
+		ilo++
+	}
+	if r.Hi_ < M.entryv[jhi-1].Hi_ { // shrink right
+		M.entryv[jhi-1].Lo = r.Hi_+1
+		debugfRMap("\tshrink [%d] right\t-> %s\n", jhi-1, M)
+		jhi--
+	}
+
+	if (jhi - ilo) > 0 {
+		vDeleteSlice(&M.entryv, ilo,jhi)
+		debugfRMap("\tdelete M[%d:%d]\t-> %s\n", ilo, jhi, M)
+	}
+
+	// done
+	return ilo
+}
+
+// HasRange returns whether all keys from range r belong to the map.
+func (M *RangedMap) HasRange(r KeyRange) (yes bool) {
+	if traceRangeMap {
+		fmt.Printf("\n\nHasRange:\n")
+		fmt.Printf("  M: %s\n", M)
+		fmt.Printf("  r: %s\n", r)
+		defer func() {
+			fmt.Printf("->·: %v\n", yes)
+		}()
+	}
+
+	M.verify()
+
+	if r.Empty() {
+		return true
+	}
+
+	// find first ilo: r.lo < [ilo].hi
+	l := len(M.entryv)
+	ilo := sort.Search(l, func(i int) bool {
+		 return r.Lo <= M.entryv[i].Hi_
+	})
+	debugfRMap("\tilo: %d\n", ilo)
+
+	if ilo == l { // not found
+		return false
+	}
+
+	// scan right and verify that whole r is covered
+	lo := r.Lo
+	for {
+		e := M.entryv[ilo]
+		debugfRMap("\te: %s\ttocheck: %s\n", e, KeyRange{lo, r.Hi_})
+
+		if lo < e.Lo {
+			return false // hole in coverage
+		}
+		if r.Hi_ <= e.Hi_ {
+			return true  // reached full coverage
+		}
+
+		lo = e.Hi_
+		if lo < KeyMax {
+			lo++
+		}
+
+		ilo++
+		if ilo == l {
+			return false // r's right not fully covered
+		}
+	}
+}
+
+
+
+// --------
+
+// verify checks RangedMap for internal consistency:
+// - ranges must be not overlapping and ↑
+// - adjacent ranges must map to different values
+func (M *RangedMap) verify() {
+	// TODO !debug -> return
+
+	var badv []string
+	badf := func(format string, argv ...interface{}) {
+		badv = append(badv, fmt.Sprintf(format, argv...))
+	}
+	defer func() {
+		if badv != nil {
+			emsg := "M.verify: fail:\n\n"
+			for _, bad := range badv {
+				emsg += fmt.Sprintf("- %s\n", bad)
+			}
+			emsg += fmt.Sprintf("\nM: %s\n", M)
+			panic(emsg)
+		}
+	}()
+
+	hi_Prev := KeyMin
+	var v_Prev VALUE
+	for i, e := range M.entryv {
+		hiPrev := hi_Prev + 1
+		if i > 0 {
+			if (e.Value == v_Prev) {
+				if !(hiPrev < e.Lo) { // NOTE not ≤ - adjacent ranges must be merged
+					badf("[%d]: same value: !(hiPrev < e.lo)", i)
+				}
+			} else {
+				if !(hi_Prev <= e.Lo) {
+					badf("[%d]: different value: !(hiPrev ≤ e.lo)", i)
+				}
+			}
+		}
+		if !(e.Lo <= e.Hi_) {
+			badf("[%d]: !(e.lo ≤ e.hi_)", i)
+		}
+		hi_Prev = e.Hi_
+		v_Prev  = e.Value
+	}
+}
+
+// Clone returns copy of the map.
+//
+// NOTE values are _not_ cloned.
+func (orig *RangedMap) Clone() *RangedMap {
+	klon := &RangedMap{}
+	klon.entryv = append(klon.entryv, orig.entryv...)
+	return klon
+}
+
+// Empty returns whether the map is empty.
+func (M *RangedMap) Empty() bool {
+	return len(M.entryv) == 0
+}
+
+// Equal returns whether A == B.
+func (A *RangedMap) Equal(B *RangedMap) bool {
+	if len(A.entryv) != len(B.entryv) {
+		return false
+	}
+	for i, ea := range A.entryv {
+		eb := B.entryv[i]
+		if ea != eb {
+			return false
+		}
+	}
+	return true
+}
+
+// Clear removes all elements from the map.
+func (M *RangedMap) Clear() {
+	M.entryv = nil
+}
+
+// AllRanges returns slice of all key ranges in the set.
+//
+// TODO -> iter?
+func (M *RangedMap) AllRanges() /*readonly*/[]RangedMapEntry {
+	return M.entryv
+}
+
+func (M RangedMap) String() string {
+	s := "{"
+	for i, e := range M.entryv {
+		if i > 0 {
+			s += " "
+		}
+		s += e.String()
+	}
+	s += "}"
+	return s
+}
+
+func (e RangedMapEntry) String() string {
+	s := e.KeyRange.String()
+	v := fmt.Sprintf("%v", e.Value)
+	if v != "" { // omit ":<v>" in the case of set
+		s += ":" + v
+	}
+	return s
+}
+
+
+func debugfRMap(format string, argv ...interface{}) {
+	if !debugRangeMap {
+		return
+	}
+	fmt.Printf(format, argv...)
+}
+
+
+// ---- slice ops ----
+
+// vInsert inserts e into *pv[i].
+func vInsert(pv *[]RangedMapEntry, i int, e RangedMapEntry) {
+	v := *pv
+	v = append(v, RangedMapEntry{})
+	copy(v[i+1:], v[i:])
+	v[i] = e
+	*pv = v
+}
+
+// vDeleteSlice deletes *pv[lo:hi].
+func vDeleteSlice(pv *[]RangedMapEntry, lo,hi int) {
+	v := *pv
+	n := copy(v[lo:], v[hi:])
+	v = v[:lo+n]
+	*pv = v
+}
+
+// vReplaceSlice replaces *pv[lo:hi] with e.
+func vReplaceSlice(pv *[]RangedMapEntry, lo,hi int, e RangedMapEntry) {
+	v := *pv
+	n := copy(v[lo+1:], v[hi:])
+	v[lo] = e
+	v = v[:lo+1+n]
+	*pv = v
+}

wcfs/internal/xbtree/blib/rangemap_test.go

+// Copyright (C) 2021  Nexedi SA and Contributors.
+//                     Kirill Smelkov <kirr@nexedi.com>
+//
+// This program is free software: you can Use, Study, Modify and Redistribute
+// it under the terms of the GNU General Public License version 3, or (at your
+// option) any later version, as published by the Free Software Foundation.
+//
+// You can also Link and Combine this program with other software covered by
+// the terms of any of the Free Software licenses or any of the Open Source
+// Initiative approved licenses and Convey the resulting work. Corresponding
+// source of such a combination shall include the source code for all other
+// software used.
+//
+// This program is distributed WITHOUT ANY WARRANTY; without even the implied
+// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+//
+// See COPYING file for full licensing terms.
+// See https://www.nexedi.com/licensing for rationale and options.
+
+package blib
+
+//go:generate ./gen-rangemap _RangedMap_str string zrangemap_str.go
+
+import (
+	"reflect"
+	"testing"
+)
+
+type (
+	RangedMap      = _RangedMap_str
+	RangedMapEntry = _RangedMap_strEntry
+)
+
+const (
+	oo  = KeyMax
+	noo = KeyMin
+)
+
+func TestRangedMap(t *testing.T) {
+	type testEntry struct {
+		M   *RangedMap
+		X   RangedMapEntry
+		Set *RangedMap // M.SetRange(X.keycov, X.value)
+		Del *RangedMap // M.DelRange(X.keycov)
+		Has bool       // M.HasRange(X.keycov)
+	}
+	E := func(M *RangedMap, X RangedMapEntry, S, D *RangedMap, H bool) testEntry {
+		return testEntry{M, X, S, D, H}
+	}
+
+	// M is shorthand to create RangedMap, e.g. M(1,2,a, 3,4,b) will return {[1,2):a [3,4):b}.
+	M := func(argv ...interface{}) *RangedMap {
+		l := len(argv)
+		if l % 3 != 0 {
+			panic("non 3x number of arguments")
+		}
+		// asKey converts arg to Key
+		asKey := func(arg interface{}) Key {
+			// go through reflect to accept all int, int64, Key, ...
+			return Key(reflect.ValueOf(arg).Int())
+		}
+		M := &RangedMap{}
+		for i := 0; i < l/3; i++ {
+			// construct .entryv directly, not via SetRange
+			lo := asKey(argv[3*i])
+			hi := asKey(argv[3*i+1])
+			v  := argv[3*i+2].(string)
+			hi_ := hi
+			if hi_ != oo {
+				hi_--
+			}
+			M.entryv = append(M.entryv, RangedMapEntry{
+					v,
+					KeyRange{lo, hi_},
+			})
+		}
+		M.verify()
+		return M
+	}
+
+	// X creates RangedMapEntry{v, [lo,hi)}
+	X := func(lo,hi Key, v string) RangedMapEntry {
+		hi_ := hi
+		if hi_ != oo {
+			hi_--
+		}
+		return RangedMapEntry{v, KeyRange{lo, hi_}}
+	}
+
+	// y, n alias true/false
+	const y, n = true, false
+
+	// a, b, c, ... are shorthands for corresponding strings
+	const a, b, c, x = "a", "b", "c", "x"
+
+
+	testv := []testEntry{
+		// empty vs empty
+		E(
+			M(),			// M
+			X(0,0,x),		// X
+				M(),			// Set
+				M(),			// Del
+				y),			// Has
+
+		// empty vs !empty
+		E(
+			M(),			// M
+			X(1,2,x),		// X
+				M(1,2,x),		// Set
+				M(),			// Del
+				n),			// Has
+
+		// !empty vs empty
+		E(
+			M(1,2,a),		// M
+			X(0,0,x),		// X
+				M(1,2,a),		// Set
+				M(1,2,a),		// Del
+				y),			// Has
+
+		// basic change
+		E(
+			M(1,2,a),		// M
+			X(1,2,x),		// X
+				M(1,2,x),		// Set
+				M(),			// Del
+				y),			// Has
+
+		// adjacent [1,3) [3,5)
+		E(
+			M(1,3,a),		// M
+			X(3,5,x),		// X
+				M(1,3,a, 3,5,x),	// Set
+				M(1,3,a),		// Del
+				n),			// Has
+
+		// overlapping [1,3) [2,4)
+		E(
+			M(1,3,a),		// M
+			X(2,4,x),		// X
+				M(1,2,a, 2,4,x),	// Set
+				M(1,2,a),		// Del
+				n),			// Has
+
+		// [1,7) vs [3,5) -> split
+		E(
+			M(1,7,a),		// M
+			X(3,5,x),		// X
+				M(1,3,a, 3,5,x, 5,7,a),	// Set
+				M(1,3,a,        5,7,a),	// Del
+				y),			// Has
+
+		// several ranges vs [-∞,∞)
+		E(
+			M(1,3,a, 5,7,b, 8,9,c),	// M
+			X(noo,oo,x),		// X
+				M(noo,oo,x),		// Set
+				M(),			// Del
+				n),			// Has
+
+		E(
+			M(1,2,a, 2,3,b),	// M
+			X(1,3,x),		// X
+				M(1,3,x),		// Set
+				M(),			// Del
+				y),			// Has
+
+		// coalesce (same value, no overlap)
+		E(
+			M(1,2,a, 4,5,a),	// M
+			X(2,4,a),		// X
+				M(1,5,a),		// Set
+				M(1,2,a, 4,5,a),	// Del
+				n),			// Has
+
+		// coalesce (same value, overlap)
+		E(
+			M(1,4,a, 5,8,a),	// M
+			X(2,6,a),		// X
+				M(1,8,a),		// Set
+				M(1,2,a, 6,8,a),	// Del
+				n),			// Has
+
+		// - shrink left/right (value !same) + new entry
+		E(
+			M(1,4,a),		// M
+			X(2,6,x),		// X
+				M(1,2,a, 2,6,x),	// Set
+				M(1,2,a),		// Del
+				n),			// Has
+		E(
+			M(5,8,b),		// M
+			X(2,6,x),		// X
+				M(2,6,x, 6,8,b),	// Set
+				M(       6,8,b),	// Del
+				n),			// Has
+		E(
+			M(1,4,a, 5,8,b),	// M
+			X(2,6,x),		// X
+				M(1,2,a, 2,6,x, 6,8,b),	// Set
+				M(1,2,a,        6,8,b), // Del
+				n),                     // Has
+	}
+
+	for _, tt := range testv {
+		M := tt.M
+		X := tt.X
+		r := X.KeyRange
+		v := X.Value
+
+		assertMapHasRange(t, M, r, tt.Has)
+		Mset := M.Clone()
+		Mdel := M.Clone()
+		Mset.SetRange(r, v)
+		Mdel.DelRange(r)
+
+		if !Mset.Equal(tt.Set) {
+			t.Errorf("SetRange:\n  M:   %s\n  e:   %s\n  ->·: %s\n  ok·: %s\n", M, X, Mset, tt.Set)
+
+		}
+
+		if !Mdel.Equal(tt.Del) {
+			t.Errorf("DelRange:\n  M:   %s\n  r:   %s\n  ->·: %s\n  ok·: %s\n", M, r, Mdel, tt.Del)
+
+		}
+
+		assertMapHasRange(t, Mset, r, true)
+		rInMdel := false
+		if r.Empty() {
+			rInMdel = true
+		}
+		assertMapHasRange(t, Mdel, r, rInMdel)
+
+		verifyGet(t, M)
+		verifyGet(t, Mset)
+		verifyGet(t, Mdel)
+	}
+}
+
+// assertMapHasRange asserts that RangeMap M.HasRange(r) == hasOK.
+func assertMapHasRange(t *testing.T, M *RangedMap, r KeyRange, hasOK bool) {
+	t.Helper()
+	has := M.HasRange(r)
+	if !(has == hasOK) {
+		t.Errorf("HasRange:\n  M:   %s\n  r:   %s\n  ->·: %t\n  ok·: %t\n", M, r, has, hasOK)
+	}
+}
+
+// verifyGet verifies RangedMap.Get .
+func verifyGet(t *testing.T, M *RangedMap) {
+	t.Helper()
+
+	var Mranges []RangedMapEntry
+	Mranges = append(Mranges, M.AllRanges()...) // copy just in case it changes on Get
+
+	// verify "has-data"
+	Z := KeyRange{-100,+100} // models [-∞,∞)
+	for _, e := range Mranges {
+		lo  := kmax(e.Lo,  Z.Lo)
+		hi_ := kmin(e.Hi_, Z.Hi_)
+		for k := lo; k <= hi_; k++ {
+			v, ok := M.Get_(k)
+			if !(v == e.Value && ok) {
+				t.Errorf("%s\tGet(%s):\nhave: %q, %t\nwant: %q, true",
+					M, KStr(k), v, ok, e.Value)
+			}
+		}
+	}
+
+	// verify "no-data"
+	// NA = [-∞,∞) \ M
+	na := RangedKeySet{}
+	na.AddRange(Z)
+	for _, e := range Mranges {
+		na.DelRange(e.KeyRange)
+	}
+
+	for _, r := range na.AllRanges() {
+		lo  := kmax(r.Lo,  Z.Lo)
+		hi_ := kmin(r.Hi_, Z.Hi_)
+		for k := lo; k <= hi_; k++ {
+			v, ok := M.Get_(k)
+			if !(v == "" && !ok) {
+				t.Errorf("%s\tGet(%s):\nhave: %q, %t\nwant: %q, false",
+					M, KStr(k), v, ok, "")
+			}
+		}
+	}
+}
+
+
+// kmin returns min(a,b).
+func kmin(a, b Key) Key {
+	if a < b {
+		return a
+	} else {
+		return b
+	}
+}
+
+// kmax returns max(a,b).
+func kmax(a, b Key) Key {
+	if a > b {
+		return a
+	} else {
+		return b
+	}
+}

wcfs/internal/xbtree/blib/rangeset.go

@@ -20,35 +20,20 @@
 package blib
 // set of [lo,hi) Key ranges.
 
-import (
-	"fmt"
-	"sort"
-)
+//go:generate ./gen-rangemap _RangedMap_void void zrangemap_void.go
 
-const traceRangeSet = false
-const debugRangeSet = false
-
-// KeyRange represents [lo,hi) Key range.
-type KeyRange struct {
-	Lo  Key
-	Hi_ Key // NOTE _not_ hi) to avoid overflow at ∞;  hi = hi_ + 1
-}
 
 // RangedKeySet is set of Keys with adjacent keys coalesced into Ranges.
 //
 // Zero value represents empty set.
 type RangedKeySet struct {
-	// TODO rework to use BTree lo->hi_ instead if in practice in treediff,
-	// and other usage places, N(ranges) turns out to be not small
-	// (i.e. performance turns out to be not acceptable)
-	rangev []KeyRange // lo↑
+	m _RangedMap_void
 }
 
+// void is used as value type for RangedMap to be used as set.
+type void struct{}
+func (_ void) String() string { return "" }
 
-// Has returns whether key k belongs to the range.
-func (r *KeyRange) Has(k Key) bool {
-	return (r.Lo <= k && k <= r.Hi_)
-}
 
 
 // Add adds key k to the set.
@@ -69,184 +54,17 @@ func (S *RangedKeySet) Has(k Key) bool {
 
 // AddRange adds range r to the set.
 func (S *RangedKeySet) AddRange(r KeyRange) {
-	if traceRangeSet {
-		fmt.Printf("\n\nAddRange:\n")
-		fmt.Printf("  S: %s\n", S)
-		fmt.Printf("  r: %s\n", r)
-		defer fmt.Printf("->u: %s\n", S)
-	}
-
-	S.verify()
-	defer S.verify()
-
-	// find first ilo: r.Lo < [ilo].hi
-	l := len(S.rangev)
-	ilo := sort.Search(l, func(i int) bool {
-		 return r.Lo <= S.rangev[i].Hi_
-	})
-	debugfRSet("\tilo: %d\n", ilo)
-
-	if ilo == l { // not found
-		S.rangev = append(S.rangev, r)
-		l++
-		debugfRSet("\tappend %s\t-> %s\n", r, S)
-	}
-
-	// find last jhi: [jhi].Lo < r.hi
-	jhi := ilo
-	for ;; jhi++ {
-		if jhi == l {
-			break
-		}
-		if S.rangev[jhi].Lo <= r.Hi_ {
-			continue
-		}
-		break
-	}
-	debugfRSet("\tjhi: %d\n", jhi)
-
-	// entries in [ilo:jhi) ∈ [r.Lo,r.hi) and should be merged into one
-	if (jhi - ilo) > 1 {
-		lo  := S.rangev[ilo].Lo
-		hi_ := S.rangev[jhi-1].Hi_
-		vReplaceSlice(&S.rangev, ilo,jhi, KeyRange{lo,hi_})
-		debugfRSet("\tmerge S[%d:%d]\t-> %s\n", ilo, jhi, S)
-	}
-	jhi = -1 // no longer valid
-
-	// if [r.lo,r.hi) was outside of any entry - create new entry
-	if r.Hi_ < S.rangev[ilo].Lo {
-		vInsert(&S.rangev, ilo, r)
-		debugfRSet("\tinsert %s\t-> %s\n", r, S)
-	}
-
-	// now we have covered entries merged as needed into [ilo]
-	// extend this entry if r coverage is wider
-	if r.Lo < S.rangev[ilo].Lo {
-		S.rangev[ilo].Lo = r.Lo
-		debugfRSet("\textend left\t-> %s\n", S)
-	}
-	if r.Hi_ > S.rangev[ilo].Hi_ {
-		S.rangev[ilo].Hi_ = r.Hi_
-		debugfRSet("\textend right\t-> %s\n", S)
-	}
-
-	// and check if we should merge it with right/left neighbours
-	if ilo+1 < len(S.rangev) { // right
-		if S.rangev[ilo].Hi_+1 == S.rangev[ilo+1].Lo {
-			vReplaceSlice(&S.rangev, ilo,ilo+2,
-				KeyRange{S.rangev[ilo].Lo, S.rangev[ilo+1].Hi_})
-			debugfRSet("\tmerge right\t-> %s\n", S)
-		}
-	}
-
-	if ilo > 0 { // left
-		if S.rangev[ilo-1].Hi_+1 == S.rangev[ilo].Lo {
-			vReplaceSlice(&S.rangev, ilo-1,ilo+1,
-				KeyRange{S.rangev[ilo-1].Lo, S.rangev[ilo].Hi_})
-			debugfRSet("\tmerge left\t-> %s\n", S)
-		}
-	}
-
-	// done
+	S.m.SetRange(r, void{})
 }
 
 // DelRange removes range r from the set.
 func (S *RangedKeySet) DelRange(r KeyRange) {
-	if traceRangeSet {
-		fmt.Printf("\n\nDelRange:\n")
-		fmt.Printf("  S: %s\n", S)
-		fmt.Printf("  r: %s\n", r)
-		defer fmt.Printf("->d: %s\n", S)
-	}
-
-	S.verify()
-	defer S.verify()
-
-	// find first ilo: r.Lo < [ilo].hi
-	l := len(S.rangev)
-	ilo := sort.Search(l, func(i int) bool {
-		 return r.Lo <= S.rangev[i].Hi_
-	})
-	debugfRSet("\tilo: %d\n", ilo)
-
-	if ilo == l { // not found
-		debugfRSet("\tnon-overlap right\n")
-		return
-	}
-
-	// find last jhi: [jhi].Lo < r.hi
-	jhi := ilo
-	for ;; jhi++ {
-		if jhi == l {
-			break
-		}
-		if S.rangev[jhi].Lo <= r.Hi_ {
-			continue
-		}
-		break
-	}
-	debugfRSet("\tjhi: %d\n", jhi)
-
-	if jhi == 0 {
-		debugfRSet("\tnon-overlap left\n")
-		return
-	}
-
-	// [ilo+1:jhi-1] should be deleted
-	// [ilo] and [jhi-1] overlap with [r.lo,r.hi) - they should be deleted, or shrinked,
-	// or split+shrinked if ilo==jhi-1 and r is inside [ilo]
-	if jhi-ilo == 1 && S.rangev[ilo].Lo < r.Lo && r.Hi_ < S.rangev[ilo].Hi_ {
-		x := S.rangev[ilo]
-		vInsert(&S.rangev, ilo, x)
-		jhi++
-		debugfRSet("\tpresplit copy %s\t-> %s\n", x, S)
-	}
-	if S.rangev[ilo].Lo < r.Lo { // shrink left
-		S.rangev[ilo] = KeyRange{S.rangev[ilo].Lo, r.Lo-1}
-		ilo++
-		debugfRSet("\tshrink [%d] left\t-> %s\n", ilo, S)
-	}
-	if r.Hi_ < S.rangev[jhi-1].Hi_ { // shrink right
-		S.rangev[jhi-1] = KeyRange{r.Hi_+1, S.rangev[jhi-1].Hi_}
-		jhi--
-		debugfRSet("\tshrink [%d] right\t-> %s\n", jhi-1, S)
-	}
-
-	if (jhi - ilo) > 0 {
-		vDeleteSlice(&S.rangev, ilo,jhi)
-		debugfRSet("\tdelete S[%d:%d]\t-> %s\n", ilo, jhi, S)
-	}
-
-	// done
+	S.m.DelRange(r)
 }
 
 // HasRange returns whether all keys from range r belong to the set.
 func (S *RangedKeySet) HasRange(r KeyRange) (yes bool) {
-	if traceRangeSet {
-		fmt.Printf("\n\nHasRange:\n")
-		fmt.Printf("  S: %s\n", S)
-		fmt.Printf("  r: %s\n", r)
-		defer func() {
-			fmt.Printf("->·: %v\n", yes)
-		}()
-	}
-
-	S.verify()
-
-	// find first ilo: r.lo < [ilo].hi
-	l := len(S.rangev)
-	ilo := sort.Search(l, func(i int) bool {
-		 return r.Lo <= S.rangev[i].Hi_
-	})
-	debugfRSet("\tilo: %d\n", ilo)
-
-	if ilo == l { // not found
-		return false
-	}
-
-	// all keys from r are in S if r ∈ [ilo]
-	return (S.rangev[ilo].Lo <= r.Lo && r.Hi_ <= S.rangev[ilo].Hi_)
+	return S.m.HasRange(r)
 }
 
 
@@ -264,7 +82,7 @@ func (A *RangedKeySet) Difference(B *RangedKeySet) *RangedKeySet {
 	return D
 }
 
-// XXX Intersection
+// TODO Intersection
 
 func (A *RangedKeySet) UnionInplace(B *RangedKeySet) {
 	A.verify()
@@ -272,8 +90,8 @@ func (A *RangedKeySet) UnionInplace(B *RangedKeySet) {
 	defer A.verify()
 
 	// XXX dumb
-	for _, r := range B.rangev {
-		A.AddRange(r)
+	for _, e := range B.m.entryv {
+		A.AddRange(e.KeyRange)
 	}
 }
 
@@ -283,143 +101,57 @@ func (A *RangedKeySet) DifferenceInplace(B *RangedKeySet) {
 	defer A.verify()
 
 	// XXX dumb
-	for _, r := range B.rangev {
-		if len(A.rangev) == 0 {
+	for _, e := range B.m.entryv {
+		if A.Empty() {
 			break
 		}
-		A.DelRange(r)
+		A.DelRange(e.KeyRange)
 	}
 }
 
 
 // --------
 
-// verify check RangedKeySet for internal consistency:
-// - ranges must be not overlapping nor adjacent and ↑
+// verify checks RangedKeySet for internal consistency.
 func (S *RangedKeySet) verify() {
-	// TODO !debug -> return
-
-	var badv []string
-	badf := func(format string, argv ...interface{}) {
-		badv = append(badv, fmt.Sprintf(format, argv...))
-	}
-	defer func() {
-		if badv != nil {
-			emsg := "S.verify: fail:\n\n"
-			for _, bad := range badv {
-				emsg += fmt.Sprintf("- %s\n", bad)
-			}
-			emsg += fmt.Sprintf("\nS: %s\n", S)
-			panic(emsg)
-		}
-	}()
-
-	hi_Prev := KeyMin
-	for i, r := range S.rangev {
-		hiPrev := hi_Prev + 1
-		if i > 0 && !(hiPrev < r.Lo) { // NOTE not ≤ - adjacent ranges must be merged
-			badf("[%d]: !(hiPrev < r.lo)", i)
-		}
-		if !(r.Lo <= r.Hi_) {
-			badf("[%d]: !(r.lo <= r.hi_)", i)
-		}
-		hi_Prev = r.Hi_
-	}
+	S.m.verify()
 }
 
 // Clone returns copy of the set.
 func (orig *RangedKeySet) Clone() *RangedKeySet {
-	klon := &RangedKeySet{}
-	klon.rangev = append(klon.rangev, orig.rangev...)
-	return klon
+	return &RangedKeySet{*orig.m.Clone()}
 }
 
 // Empty returns whether the set is empty.
 func (S *RangedKeySet) Empty() bool {
-	return len(S.rangev) == 0
+	return S.m.Empty()
 }
 
 // Equal returns whether A == B.
 func (A *RangedKeySet) Equal(B *RangedKeySet) bool {
-	if len(A.rangev) != len(B.rangev) {
-		return false
-	}
-	for i, ra := range A.rangev {
-		rb := B.rangev[i]
-		if ra != rb {
-			return false
-		}
-	}
-	return true
+	return A.m.Equal(&B.m)
 }
 
 // Clear removes all elements from the set.
 func (S *RangedKeySet) Clear() {
-	S.rangev = nil
+	S.m.Clear()
 }
 
 // AllRanges returns slice of all key ranges in the set.
 //
 // TODO -> iter?
 func (S *RangedKeySet) AllRanges() /*readonly*/[]KeyRange {
-	return S.rangev
-}
-
-func (S RangedKeySet) String() string {
-	s := "{"
-	for i, r := range S.rangev {
-		if i > 0 {
-			s += " "
-		}
-		s += r.String()
-	}
-	s += "}"
-	return s
-}
-
-func (r KeyRange) String() string {
-	var shi string
-	if r.Hi_ == KeyMax {
-		shi = KStr(r.Hi_) // ∞
-	} else {
-		shi = fmt.Sprintf("%d", r.Hi_+1)
-	}
-	return fmt.Sprintf("[%s,%s)", KStr(r.Lo), shi)
-}
-
-
-func debugfRSet(format string, argv ...interface{}) {
-	if !debugRangeSet {
-		return
+	// TODO we could use unsafe and cast .m.AllRanges to []KeyRange to avoid extra alloc/copy
+	// return []KeyRange(S.m.AllRanges())
+	ev := S.m.AllRanges()
+	rv := make([]KeyRange, len(ev))
+	for i := range ev {
+		rv[i] = ev[i].KeyRange
 	}
-	fmt.Printf(format, argv...)
-}
-
-
-// ---- slice ops ----
-
-// vInsert inserts r into *pv[i].
-func vInsert(pv *[]KeyRange, i int, r KeyRange) {
-	v := *pv
-	v = append(v, KeyRange{})
-	copy(v[i+1:], v[i:])
-	v[i] = r
-	*pv = v
+	return rv
 }
 
-// vDeleteSlice deletes *pv[lo:hi].
-func vDeleteSlice(pv *[]KeyRange, lo,hi int) {
-	v := *pv
-	n := copy(v[lo:], v[hi:])
-	v = v[:lo+n]
-	*pv = v
-}
-
-// vReplaceSlice replaces *pv[lo:hi] with r.
-func vReplaceSlice(pv *[]KeyRange, lo,hi int, r KeyRange) {
-	v := *pv
-	n := copy(v[lo+1:], v[hi:])
-	v[lo] = r
-	v = v[:lo+1+n]
-	*pv = v
+func (S RangedKeySet) String() string {
+	// RangeMap<void> supports formatting for set out of the box
+	return S.m.String()
 }

wcfs/internal/xbtree/blib/rangeset_test.go

@@ -21,14 +21,28 @@ package blib
 
 import (
 	"testing"
+	"unsafe"
 )
 
-func TestRangedKeySet(t *testing.T) {
-	const (
-		oo  = KeyMax
-		noo = KeyMin
-	)
+func TestRangedKeySetTypes(t *testing.T) {
+	// verify that size(void) == 0  and  that _RangedMap_voidEntry has the same layout as KeyRange
+	sizeVoid := unsafe.Sizeof(void{})
+	if sizeVoid != 0 {
+		t.Errorf("sizeof(void) = %d  ; want 0", sizeVoid)
+	}
+
+	// verify that sizeof(set-entry) = sizeof(KeyRange)
+	// NOTE for this to be true Value needs to come first in RangedMapEntry
+	// (see github.com/golang/go/issues/48651)
+	sizeKeyRange := unsafe.Sizeof(KeyRange{})
+	sizeRangedMap_voidEntry := unsafe.Sizeof(_RangedMap_voidEntry{})
+	if sizeRangedMap_voidEntry != sizeKeyRange {
+		t.Errorf("sizeof(RangeMap_voidEntry)(%d)  !=  sizeof(KeyRange)(%d)",
+			sizeRangedMap_voidEntry, sizeKeyRange)
+	}
+}
 
+func TestRangedKeySet(t *testing.T) {
 	type testEntry struct {
 		A, B       *RangedKeySet
 		Union      *RangedKeySet
@@ -46,14 +60,17 @@ func TestRangedKeySet(t *testing.T) {
 		}
 		S := &RangedKeySet{}
 		for i := 0; i < l/2; i++ {
-			// construct .rangev directly, not via AddRange
+			// construct .entryv directly, not via AddRange
 			lo := kv[2*i]
 			hi := kv[2*i+1]
 			hi_ := hi
 			if hi_ != oo {
 				hi_--
 			}
-			S.rangev = append(S.rangev, KeyRange{lo, hi_})
+			S.m.entryv = append(S.m.entryv, _RangedMap_voidEntry{
+					void{},
+					KeyRange{lo, hi_},
+			})
 		}
 		S.verify()
 		return S
@@ -66,6 +83,18 @@ func TestRangedKeySet(t *testing.T) {
 				S(),	// U
 				S()),	// D
 
+		E(
+			S(),	// A
+			S(1,2),	// B
+				S(1,2),	// U
+				S()),	// D
+
+		E(
+			S(1,2),	// A
+			S(),	// B
+				S(1,2),	// U
+				S(1,2)),// D
+
 		E(
 			S(1,2),	// A
 			S(1,2),	// B
@@ -93,7 +122,7 @@ func TestRangedKeySet(t *testing.T) {
 				S(1,7),
 				S(1,3, 5,7)),
 
-		// several ranges \ [-∞, ∞) -> ø
+		// several ranges \ [-∞,∞) -> ø
 		E(
 			S(1,3, 5,7, 11,100), // A
 			S(noo, oo),          // B
@@ -123,29 +152,29 @@ func TestRangedKeySet(t *testing.T) {
 		D := A.Difference(B)
 
 		if !U.Equal(tt.Union) {
-			t.Errorf("Union:\n  A:   %s\n  B:   %s\n  ->u: %s\n  okU: %s\n", tt.A, tt.B, U, tt.Union)
+			t.Errorf("Union:\n  A:   %s\n  B:   %s\n  ->u: %s\n  okU: %s\n", A, B, U, tt.Union)
 		}
 		if !D.Equal(tt.Difference) {
-			t.Errorf("Difference:\n  A:   %s\n  B:   %s\n  ->d: %s\n  okD: %s\n", tt.A, tt.B, D, tt.Difference)
+			t.Errorf("Difference:\n  A:   %s\n  B:   %s\n  ->d: %s\n  okD: %s\n", A, B, D, tt.Difference)
 		}
 
 		// HasRange
-		assertHasRange(t, A.AllRanges(), A, true)
-		assertHasRange(t, B.AllRanges(), B, true)
-		assertHasRange(t, A.AllRanges(), U, true)
-		assertHasRange(t, B.AllRanges(), U, true)
+		assertSetHasRanges(t, A, A.AllRanges(), true)
+		assertSetHasRanges(t, B, B.AllRanges(), true)
+		assertSetHasRanges(t, U, A.AllRanges(), true)
+		assertSetHasRanges(t, U, B.AllRanges(), true)
 
 		Dab := D
 		Dba := B.Difference(A)
-		assertHasRange(t, Dab.AllRanges(), A, true)
-		assertHasRange(t, Dab.AllRanges(), B, false)
-		assertHasRange(t, Dba.AllRanges(), B, true)
-		assertHasRange(t, Dba.AllRanges(), A, false)
+		assertSetHasRanges(t, A, Dab.AllRanges(), true)
+		assertSetHasRanges(t, B, Dab.AllRanges(), false)
+		assertSetHasRanges(t, B, Dba.AllRanges(), true)
+		assertSetHasRanges(t, A, Dba.AllRanges(), false)
 	}
 }
 
-// assertHasRange asserts for all ranges from rangev that S.HasRange(r) == hasOK
-func assertHasRange(t *testing.T, rangev []KeyRange, S *RangedKeySet, hasOK bool) {
+// assertSetHasRanges asserts for all ranges from rangev that RangedSet S.HasRange(r) == hasOK.
+func assertSetHasRanges(t *testing.T, S *RangedKeySet, rangev []KeyRange, hasOK bool) {
 	t.Helper()
 	for _, r := range rangev {
 		has := S.HasRange(r)

wcfs/internal/xbtree/blib/zrangemap_str.go

+// Code generated by gen-rangemap _RangedMap_str string; DO NOT EDIT.
+
+// Copyright (C) 2021  Nexedi SA and Contributors.
+//                     Kirill Smelkov <kirr@nexedi.com>
+//
+// This program is free software: you can Use, Study, Modify and Redistribute
+// it under the terms of the GNU General Public License version 3, or (at your
+// option) any later version, as published by the Free Software Foundation.
+//
+// You can also Link and Combine this program with other software covered by
+// the terms of any of the Free Software licenses or any of the Open Source
+// Initiative approved licenses and Convey the resulting work. Corresponding
+// source of such a combination shall include the source code for all other
+// software used.
+//
+// This program is distributed WITHOUT ANY WARRANTY; without even the implied
+// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+//
+// See COPYING file for full licensing terms.
+// See https://www.nexedi.com/licensing for rationale and options.
+
+package blib
+// map [lo,hi) Key ranges to values.
+
+import (
+	"fmt"
+	"sort"
+)
+
+const trace_RangedMap_str = false
+const debug_RangedMap_str = false
+
+// _RangedMap_str is Key->string map with adjacent keys mapped to the same value coalesced into Ranges.
+//
+// Zero value represents empty map.
+type _RangedMap_str struct {
+	// TODO rework to use BTree lo->hi_ instead if in practice in treediff,
+	// and other usage places, N(ranges) turns out to be not small
+	// (i.e. performance turns out to be not acceptable)
+	entryv []_RangedMap_strEntry // lo↑
+}
+
+// _RangedMap_strEntry represents one entry in _RangedMap_str.
+type _RangedMap_strEntry struct {
+	Value    string
+	KeyRange
+}
+
+
+// Get returns value associated with key k.
+func (M *_RangedMap_str) Get(k Key) string {
+	v, _ := M.Get_(k)
+	return v
+}
+
+// Set changes M to map key k to value v.
+func (M *_RangedMap_str) Set(k Key, v string) {
+	M.SetRange(KeyRange{Lo: k, Hi_: k}, v)
+}
+
+// Del removes key k.
+func (M *_RangedMap_str) Del(k Key) {
+	M.DelRange(KeyRange{Lo: k, Hi_: k})
+}
+
+// Has returns whether key k is present in the map.
+func (M *_RangedMap_str) Has(k Key) bool {
+	_, ok := M.Get_(k)
+	return ok
+}
+
+
+
+// Get_ is comma-ok version of Get.
+func (M *_RangedMap_str) Get_(k Key) (v string, ok bool) {
+	if trace_RangedMap_str {
+		fmt.Printf("\n\nGet_:\n")
+		fmt.Printf("  M: %s\n", M)
+		fmt.Printf("  k: %s\n", KStr(k))
+		defer func() {
+			fmt.Printf("->·: %v, %t\n", v, ok)
+		}()
+	}
+
+	M.verify()
+
+	// find first ilo: k < [ilo].hi
+	l := len(M.entryv)
+	ilo := sort.Search(l, func(i int) bool {
+		return k <= M.entryv[i].Hi_
+	})
+	debugf_RangedMap_str("\tilo: %d\n", ilo)
+
+	if ilo == l { // not found
+		return
+	}
+
+	e := M.entryv[ilo]
+	if !(e.Lo <= k) { // not found
+		return
+	}
+
+	// found
+	return e.Value, true
+}
+
+// SetRange changes M to map key range r to value v.
+func (M *_RangedMap_str) SetRange(r KeyRange, v string) {
+	e := _RangedMap_strEntry{v,r}
+	if trace_RangedMap_str {
+		fmt.Printf("\n\nSetRange:\n")
+		fmt.Printf("  M: %s\n", M)
+		fmt.Printf("  e: %s\n", e)
+		defer fmt.Printf("->·: %s\n", M)
+	}
+
+	M.verify()
+	defer M.verify()
+
+	if r.Empty() {
+		return
+	}
+
+	// clear range for r and insert new entry
+	// TODO optimize for same-value/set case (just merge all covered
+	// entries into one - see commented AddRange from set vvv)
+	i := M.delRange(r)
+	vInsert__RangedMap_str(&M.entryv, i, e)
+	debugf_RangedMap_str("\tinsert %s\t-> %s\n", e, M)
+
+	// check if we should merge inserted entry with right/left neighbours
+	if i+1 < len(M.entryv) { // right
+		x     := M.entryv[i]
+		right := M.entryv[i+1]
+		if (x.Hi_+1 == right.Lo) && (v == right.Value) {
+			vReplaceSlice__RangedMap_str(&M.entryv, i,i+2,
+				_RangedMap_strEntry{v, KeyRange{x.Lo, right.Hi_}})
+			debugf_RangedMap_str("\tmerge right\t-> %s\n", M)
+		}
+	}
+
+	if i > 0 { // left
+		left := M.entryv[i-1]
+		x    := M.entryv[i]
+		if (left.Hi_+1 == x.Lo) && (left.Value == v) {
+			vReplaceSlice__RangedMap_str(&M.entryv, i-1,i+1,
+				_RangedMap_strEntry{v, KeyRange{left.Lo, x.Hi_}})
+			debugf_RangedMap_str("\tmerge left\t-> %s\n", M)
+		}
+	}
+
+	// done
+
+/* how it was for just set:
+	// find first ilo: r.Lo < [ilo].hi
+	l := len(S.rangev)
+	ilo := sort.Search(l, func(i int) bool {
+		 return r.Lo <= S.rangev[i].Hi_
+	})
+	debugfRSet("\tilo: %d\n", ilo)
+
+	if ilo == l { // not found
+		S.rangev = append(S.rangev, r)
+		l++
+		debugfRSet("\tappend %s\t-> %s\n", r, S)
+	}
+
+	// find last jhi: [jhi].Lo < r.hi
+	jhi := ilo
+	for ;; jhi++ {
+		if jhi == l {
+			break
+		}
+		if S.rangev[jhi].Lo <= r.Hi_ {
+			continue
+		}
+		break
+	}
+	debugfRSet("\tjhi: %d\n", jhi)
+
+	// entries in [ilo:jhi) ∈ [r.Lo,r.hi) and should be merged into one
+	if (jhi - ilo) > 1 {
+		lo  := S.rangev[ilo].Lo
+		hi_ := S.rangev[jhi-1].Hi_
+		vReplaceSlice__RangedMap_str(&S.rangev, ilo,jhi, KeyRange{lo,hi_})
+		debugfRSet("\tmerge S[%d:%d]\t-> %s\n", ilo, jhi, S)
+	}
+	jhi = -1 // no longer valid
+
+	// if [r.lo,r.hi) was outside of any entry - create new entry
+	if r.Hi_ < S.rangev[ilo].Lo {
+		vInsert__RangedMap_str(&S.rangev, ilo, r)
+		debugfRSet("\tinsert %s\t-> %s\n", r, S)
+	}
+
+	// now we have covered entries merged as needed into [ilo]
+	// extend this entry if r coverage is wider
+	if r.Lo < S.rangev[ilo].Lo {
+		S.rangev[ilo].Lo = r.Lo
+		debugfRSet("\textend left\t-> %s\n", S)
+	}
+	if r.Hi_ > S.rangev[ilo].Hi_ {
+		S.rangev[ilo].Hi_ = r.Hi_
+		debugfRSet("\textend right\t-> %s\n", S)
+	}
+
+	// and check if we should merge it with right/left neighbours
+	if ilo+1 < len(S.rangev) { // right
+		if S.rangev[ilo].Hi_+1 == S.rangev[ilo+1].Lo {
+			vReplaceSlice__RangedMap_str(&S.rangev, ilo,ilo+2,
+				KeyRange{S.rangev[ilo].Lo, S.rangev[ilo+1].Hi_})
+			debugfRSet("\tmerge right\t-> %s\n", S)
+		}
+	}
+
+	if ilo > 0 { // left
+		if S.rangev[ilo-1].Hi_+1 == S.rangev[ilo].Lo {
+			vReplaceSlice__RangedMap_str(&S.rangev, ilo-1,ilo+1,
+				KeyRange{S.rangev[ilo-1].Lo, S.rangev[ilo].Hi_})
+			debugfRSet("\tmerge left\t-> %s\n", S)
+		}
+	}
+
+	// done
+*/
+}
+
+// DelRange removes range r from the map.
+func (M *_RangedMap_str) DelRange(r KeyRange) {
+	if trace_RangedMap_str {
+		fmt.Printf("\n\nDelRange:\n")
+		fmt.Printf("  M: %s\n", M)
+		fmt.Printf("  r: %s\n", r)
+		defer fmt.Printf("->·: %s\n", M)
+	}
+
+	M.verify()
+	defer M.verify()
+
+	if r.Empty() {
+		return
+	}
+
+	M.delRange(r)
+}
+
+// delRange deletes range r from the map and returns .entryv index where r
+// should be inserted/appended if needed.
+//
+// r must be !empty.
+func (M *_RangedMap_str) delRange(r KeyRange) (i int) {
+	// find first ilo: r.Lo < [ilo].hi
+	l := len(M.entryv)
+	ilo := sort.Search(l, func(i int) bool {
+		 return r.Lo <= M.entryv[i].Hi_
+	})
+	debugf_RangedMap_str("\tilo: %d\n", ilo)
+
+	if ilo == l { // not found
+		debugf_RangedMap_str("\tnon-overlap right\n")
+		return l
+	}
+
+	// find last jhi: [jhi].Lo < r.hi
+	jhi := ilo
+	for ;; jhi++ {
+		if jhi == l {
+			break
+		}
+		if M.entryv[jhi].Lo <= r.Hi_ {
+			continue
+		}
+		break
+	}
+	debugf_RangedMap_str("\tjhi: %d\n", jhi)
+
+	if jhi == 0 {
+		debugf_RangedMap_str("\tnon-overlap left\n")
+		return 0
+	}
+
+	// [ilo+1:jhi-1] should be deleted
+	// [ilo] and [jhi-1] overlap with [r.lo,r.hi) - they should be deleted, or shrinked,
+	// or split+shrinked if ilo==jhi-1 and r is inside [ilo]
+	if jhi-ilo == 1 && M.entryv[ilo].Lo < r.Lo && r.Hi_ < M.entryv[ilo].Hi_ {
+		x := M.entryv[ilo]
+		vInsert__RangedMap_str(&M.entryv, ilo, x)
+		jhi++
+		debugf_RangedMap_str("\tpresplit copy %s\t-> %s\n", x, M)
+	}
+	if M.entryv[ilo].Lo < r.Lo { // shrink left
+		M.entryv[ilo].Hi_ = r.Lo-1
+		debugf_RangedMap_str("\tshrink [%d] left \t-> %s\n", ilo, M)
+		ilo++
+	}
+	if r.Hi_ < M.entryv[jhi-1].Hi_ { // shrink right
+		M.entryv[jhi-1].Lo = r.Hi_+1
+		debugf_RangedMap_str("\tshrink [%d] right\t-> %s\n", jhi-1, M)
+		jhi--
+	}
+
+	if (jhi - ilo) > 0 {
+		vDeleteSlice__RangedMap_str(&M.entryv, ilo,jhi)
+		debugf_RangedMap_str("\tdelete M[%d:%d]\t-> %s\n", ilo, jhi, M)
+	}
+
+	// done
+	return ilo
+}
+
+// HasRange returns whether all keys from range r belong to the map.
+func (M *_RangedMap_str) HasRange(r KeyRange) (yes bool) {
+	if trace_RangedMap_str {
+		fmt.Printf("\n\nHasRange:\n")
+		fmt.Printf("  M: %s\n", M)
+		fmt.Printf("  r: %s\n", r)
+		defer func() {
+			fmt.Printf("->·: %v\n", yes)
+		}()
+	}
+
+	M.verify()
+
+	if r.Empty() {
+		return true
+	}
+
+	// find first ilo: r.lo < [ilo].hi
+	l := len(M.entryv)
+	ilo := sort.Search(l, func(i int) bool {
+		 return r.Lo <= M.entryv[i].Hi_
+	})
+	debugf_RangedMap_str("\tilo: %d\n", ilo)
+
+	if ilo == l { // not found
+		return false
+	}
+
+	// scan right and verify that whole r is covered
+	lo := r.Lo
+	for {
+		e := M.entryv[ilo]
+		debugf_RangedMap_str("\te: %s\ttocheck: %s\n", e, KeyRange{lo, r.Hi_})
+
+		if lo < e.Lo {
+			return false // hole in coverage
+		}
+		if r.Hi_ <= e.Hi_ {
+			return true  // reached full coverage
+		}
+
+		lo = e.Hi_
+		if lo < KeyMax {
+			lo++
+		}
+
+		ilo++
+		if ilo == l {
+			return false // r's right not fully covered
+		}
+	}
+}
+
+
+
+// --------
+
+// verify checks _RangedMap_str for internal consistency:
+// - ranges must be not overlapping and ↑
+// - adjacent ranges must map to different values
+func (M *_RangedMap_str) verify() {
+	// TODO !debug -> return
+
+	var badv []string
+	badf := func(format string, argv ...interface{}) {
+		badv = append(badv, fmt.Sprintf(format, argv...))
+	}
+	defer func() {
+		if badv != nil {
+			emsg := "M.verify: fail:\n\n"
+			for _, bad := range badv {
+				emsg += fmt.Sprintf("- %s\n", bad)
+			}
+			emsg += fmt.Sprintf("\nM: %s\n", M)
+			panic(emsg)
+		}
+	}()
+
+	hi_Prev := KeyMin
+	var v_Prev string
+	for i, e := range M.entryv {
+		hiPrev := hi_Prev + 1
+		if i > 0 {
+			if (e.Value == v_Prev) {
+				if !(hiPrev < e.Lo) { // NOTE not ≤ - adjacent ranges must be merged
+					badf("[%d]: same value: !(hiPrev < e.lo)", i)
+				}
+			} else {
+				if !(hi_Prev <= e.Lo) {
+					badf("[%d]: different value: !(hiPrev ≤ e.lo)", i)
+				}
+			}
+		}
+		if !(e.Lo <= e.Hi_) {
+			badf("[%d]: !(e.lo ≤ e.hi_)", i)
+		}
+		hi_Prev = e.Hi_
+		v_Prev  = e.Value
+	}
+}
+
+// Clone returns copy of the map.
+//
+// NOTE values are _not_ cloned.
+func (orig *_RangedMap_str) Clone() *_RangedMap_str {
+	klon := &_RangedMap_str{}
+	klon.entryv = append(klon.entryv, orig.entryv...)
+	return klon
+}
+
+// Empty returns whether the map is empty.
+func (M *_RangedMap_str) Empty() bool {
+	return len(M.entryv) == 0
+}
+
+// Equal returns whether A == B.
+func (A *_RangedMap_str) Equal(B *_RangedMap_str) bool {
+	if len(A.entryv) != len(B.entryv) {
+		return false
+	}
+	for i, ea := range A.entryv {
+		eb := B.entryv[i]
+		if ea != eb {
+			return false
+		}
+	}
+	return true
+}
+
+// Clear removes all elements from the map.
+func (M *_RangedMap_str) Clear() {
+	M.entryv = nil
+}
+
+// AllRanges returns slice of all key ranges in the set.
+//
+// TODO -> iter?
+func (M *_RangedMap_str) AllRanges() /*readonly*/[]_RangedMap_strEntry {
+	return M.entryv
+}
+
+func (M _RangedMap_str) String() string {
+	s := "{"
+	for i, e := range M.entryv {
+		if i > 0 {
+			s += " "
+		}
+		s += e.String()
+	}
+	s += "}"
+	return s
+}
+
+func (e _RangedMap_strEntry) String() string {
+	s := e.KeyRange.String()
+	v := fmt.Sprintf("%v", e.Value)
+	if v != "" { // omit ":<v>" in the case of set
+		s += ":" + v
+	}
+	return s
+}
+
+
+func debugf_RangedMap_str(format string, argv ...interface{}) {
+	if !debug_RangedMap_str {
+		return
+	}
+	fmt.Printf(format, argv...)
+}
+
+
+// ---- slice ops ----
+
+// vInsert__RangedMap_str inserts e into *pv[i].
+func vInsert__RangedMap_str(pv *[]_RangedMap_strEntry, i int, e _RangedMap_strEntry) {
+	v := *pv
+	v = append(v, _RangedMap_strEntry{})
+	copy(v[i+1:], v[i:])
+	v[i] = e
+	*pv = v
+}
+
+// vDeleteSlice__RangedMap_str deletes *pv[lo:hi].
+func vDeleteSlice__RangedMap_str(pv *[]_RangedMap_strEntry, lo,hi int) {
+	v := *pv
+	n := copy(v[lo:], v[hi:])
+	v = v[:lo+n]
+	*pv = v
+}
+
+// vReplaceSlice__RangedMap_str replaces *pv[lo:hi] with e.
+func vReplaceSlice__RangedMap_str(pv *[]_RangedMap_strEntry, lo,hi int, e _RangedMap_strEntry) {
+	v := *pv
+	n := copy(v[lo+1:], v[hi:])
+	v[lo] = e
+	v = v[:lo+1+n]
+	*pv = v
+}

wcfs/internal/xbtree/blib/zrangemap_void.go

+// Code generated by gen-rangemap _RangedMap_void void; DO NOT EDIT.
+
+// Copyright (C) 2021  Nexedi SA and Contributors.
+//                     Kirill Smelkov <kirr@nexedi.com>
+//
+// This program is free software: you can Use, Study, Modify and Redistribute
+// it under the terms of the GNU General Public License version 3, or (at your
+// option) any later version, as published by the Free Software Foundation.
+//
+// You can also Link and Combine this program with other software covered by
+// the terms of any of the Free Software licenses or any of the Open Source
+// Initiative approved licenses and Convey the resulting work. Corresponding
+// source of such a combination shall include the source code for all other
+// software used.
+//
+// This program is distributed WITHOUT ANY WARRANTY; without even the implied
+// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+//
+// See COPYING file for full licensing terms.
+// See https://www.nexedi.com/licensing for rationale and options.
+
+package blib
+// map [lo,hi) Key ranges to values.
+
+import (
+	"fmt"
+	"sort"
+)
+
+const trace_RangedMap_void = false
+const debug_RangedMap_void = false
+
+// _RangedMap_void is Key->void map with adjacent keys mapped to the same value coalesced into Ranges.
+//
+// Zero value represents empty map.
+type _RangedMap_void struct {
+	// TODO rework to use BTree lo->hi_ instead if in practice in treediff,
+	// and other usage places, N(ranges) turns out to be not small
+	// (i.e. performance turns out to be not acceptable)
+	entryv []_RangedMap_voidEntry // lo↑
+}
+
+// _RangedMap_voidEntry represents one entry in _RangedMap_void.
+type _RangedMap_voidEntry struct {
+	Value    void
+	KeyRange
+}
+
+
+// Get returns value associated with key k.
+func (M *_RangedMap_void) Get(k Key) void {
+	v, _ := M.Get_(k)
+	return v
+}
+
+// Set changes M to map key k to value v.
+func (M *_RangedMap_void) Set(k Key, v void) {
+	M.SetRange(KeyRange{Lo: k, Hi_: k}, v)
+}
+
+// Del removes key k.
+func (M *_RangedMap_void) Del(k Key) {
+	M.DelRange(KeyRange{Lo: k, Hi_: k})
+}
+
+// Has returns whether key k is present in the map.
+func (M *_RangedMap_void) Has(k Key) bool {
+	_, ok := M.Get_(k)
+	return ok
+}
+
+
+
+// Get_ is comma-ok version of Get.
+func (M *_RangedMap_void) Get_(k Key) (v void, ok bool) {
+	if trace_RangedMap_void {
+		fmt.Printf("\n\nGet_:\n")
+		fmt.Printf("  M: %s\n", M)
+		fmt.Printf("  k: %s\n", KStr(k))
+		defer func() {
+			fmt.Printf("->·: %v, %t\n", v, ok)
+		}()
+	}
+
+	M.verify()
+
+	// find first ilo: k < [ilo].hi
+	l := len(M.entryv)
+	ilo := sort.Search(l, func(i int) bool {
+		return k <= M.entryv[i].Hi_
+	})
+	debugf_RangedMap_void("\tilo: %d\n", ilo)
+
+	if ilo == l { // not found
+		return
+	}
+
+	e := M.entryv[ilo]
+	if !(e.Lo <= k) { // not found
+		return
+	}
+
+	// found
+	return e.Value, true
+}
+
+// SetRange changes M to map key range r to value v.
+func (M *_RangedMap_void) SetRange(r KeyRange, v void) {
+	e := _RangedMap_voidEntry{v,r}
+	if trace_RangedMap_void {
+		fmt.Printf("\n\nSetRange:\n")
+		fmt.Printf("  M: %s\n", M)
+		fmt.Printf("  e: %s\n", e)
+		defer fmt.Printf("->·: %s\n", M)
+	}
+
+	M.verify()
+	defer M.verify()
+
+	if r.Empty() {
+		return
+	}
+
+	// clear range for r and insert new entry
+	// TODO optimize for same-value/set case (just merge all covered
+	// entries into one - see commented AddRange from set vvv)
+	i := M.delRange(r)
+	vInsert__RangedMap_void(&M.entryv, i, e)
+	debugf_RangedMap_void("\tinsert %s\t-> %s\n", e, M)
+
+	// check if we should merge inserted entry with right/left neighbours
+	if i+1 < len(M.entryv) { // right
+		x     := M.entryv[i]
+		right := M.entryv[i+1]
+		if (x.Hi_+1 == right.Lo) && (v == right.Value) {
+			vReplaceSlice__RangedMap_void(&M.entryv, i,i+2,
+				_RangedMap_voidEntry{v, KeyRange{x.Lo, right.Hi_}})
+			debugf_RangedMap_void("\tmerge right\t-> %s\n", M)
+		}
+	}
+
+	if i > 0 { // left
+		left := M.entryv[i-1]
+		x    := M.entryv[i]
+		if (left.Hi_+1 == x.Lo) && (left.Value == v) {
+			vReplaceSlice__RangedMap_void(&M.entryv, i-1,i+1,
+				_RangedMap_voidEntry{v, KeyRange{left.Lo, x.Hi_}})
+			debugf_RangedMap_void("\tmerge left\t-> %s\n", M)
+		}
+	}
+
+	// done
+
+/* how it was for just set:
+	// find first ilo: r.Lo < [ilo].hi
+	l := len(S.rangev)
+	ilo := sort.Search(l, func(i int) bool {
+		 return r.Lo <= S.rangev[i].Hi_
+	})
+	debugfRSet("\tilo: %d\n", ilo)
+
+	if ilo == l { // not found
+		S.rangev = append(S.rangev, r)
+		l++
+		debugfRSet("\tappend %s\t-> %s\n", r, S)
+	}
+
+	// find last jhi: [jhi].Lo < r.hi
+	jhi := ilo
+	for ;; jhi++ {
+		if jhi == l {
+			break
+		}
+		if S.rangev[jhi].Lo <= r.Hi_ {
+			continue
+		}
+		break
+	}
+	debugfRSet("\tjhi: %d\n", jhi)
+
+	// entries in [ilo:jhi) ∈ [r.Lo,r.hi) and should be merged into one
+	if (jhi - ilo) > 1 {
+		lo  := S.rangev[ilo].Lo
+		hi_ := S.rangev[jhi-1].Hi_
+		vReplaceSlice__RangedMap_void(&S.rangev, ilo,jhi, KeyRange{lo,hi_})
+		debugfRSet("\tmerge S[%d:%d]\t-> %s\n", ilo, jhi, S)
+	}
+	jhi = -1 // no longer valid
+
+	// if [r.lo,r.hi) was outside of any entry - create new entry
+	if r.Hi_ < S.rangev[ilo].Lo {
+		vInsert__RangedMap_void(&S.rangev, ilo, r)
+		debugfRSet("\tinsert %s\t-> %s\n", r, S)
+	}
+
+	// now we have covered entries merged as needed into [ilo]
+	// extend this entry if r coverage is wider
+	if r.Lo < S.rangev[ilo].Lo {
+		S.rangev[ilo].Lo = r.Lo
+		debugfRSet("\textend left\t-> %s\n", S)
+	}
+	if r.Hi_ > S.rangev[ilo].Hi_ {
+		S.rangev[ilo].Hi_ = r.Hi_
+		debugfRSet("\textend right\t-> %s\n", S)
+	}
+
+	// and check if we should merge it with right/left neighbours
+	if ilo+1 < len(S.rangev) { // right
+		if S.rangev[ilo].Hi_+1 == S.rangev[ilo+1].Lo {
+			vReplaceSlice__RangedMap_void(&S.rangev, ilo,ilo+2,
+				KeyRange{S.rangev[ilo].Lo, S.rangev[ilo+1].Hi_})
+			debugfRSet("\tmerge right\t-> %s\n", S)
+		}
+	}
+
+	if ilo > 0 { // left
+		if S.rangev[ilo-1].Hi_+1 == S.rangev[ilo].Lo {
+			vReplaceSlice__RangedMap_void(&S.rangev, ilo-1,ilo+1,
+				KeyRange{S.rangev[ilo-1].Lo, S.rangev[ilo].Hi_})
+			debugfRSet("\tmerge left\t-> %s\n", S)
+		}
+	}
+
+	// done
+*/
+}
+
+// DelRange removes range r from the map.
+func (M *_RangedMap_void) DelRange(r KeyRange) {
+	if trace_RangedMap_void {
+		fmt.Printf("\n\nDelRange:\n")
+		fmt.Printf("  M: %s\n", M)
+		fmt.Printf("  r: %s\n", r)
+		defer fmt.Printf("->·: %s\n", M)
+	}
+
+	M.verify()
+	defer M.verify()
+
+	if r.Empty() {
+		return
+	}
+
+	M.delRange(r)
+}
+
+// delRange deletes range r from the map and returns .entryv index where r
+// should be inserted/appended if needed.
+//
+// r must be !empty.
+func (M *_RangedMap_void) delRange(r KeyRange) (i int) {
+	// find first ilo: r.Lo < [ilo].hi
+	l := len(M.entryv)
+	ilo := sort.Search(l, func(i int) bool {
+		 return r.Lo <= M.entryv[i].Hi_
+	})
+	debugf_RangedMap_void("\tilo: %d\n", ilo)
+
+	if ilo == l { // not found
+		debugf_RangedMap_void("\tnon-overlap right\n")
+		return l
+	}
+
+	// find last jhi: [jhi].Lo < r.hi
+	jhi := ilo
+	for ;; jhi++ {
+		if jhi == l {
+			break
+		}
+		if M.entryv[jhi].Lo <= r.Hi_ {
+			continue
+		}
+		break
+	}
+	debugf_RangedMap_void("\tjhi: %d\n", jhi)
+
+	if jhi == 0 {
+		debugf_RangedMap_void("\tnon-overlap left\n")
+		return 0
+	}
+
+	// [ilo+1:jhi-1] should be deleted
+	// [ilo] and [jhi-1] overlap with [r.lo,r.hi) - they should be deleted, or shrinked,
+	// or split+shrinked if ilo==jhi-1 and r is inside [ilo]
+	if jhi-ilo == 1 && M.entryv[ilo].Lo < r.Lo && r.Hi_ < M.entryv[ilo].Hi_ {
+		x := M.entryv[ilo]
+		vInsert__RangedMap_void(&M.entryv, ilo, x)
+		jhi++
+		debugf_RangedMap_void("\tpresplit copy %s\t-> %s\n", x, M)
+	}
+	if M.entryv[ilo].Lo < r.Lo { // shrink left
+		M.entryv[ilo].Hi_ = r.Lo-1
+		debugf_RangedMap_void("\tshrink [%d] left \t-> %s\n", ilo, M)
+		ilo++
+	}
+	if r.Hi_ < M.entryv[jhi-1].Hi_ { // shrink right
+		M.entryv[jhi-1].Lo = r.Hi_+1
+		debugf_RangedMap_void("\tshrink [%d] right\t-> %s\n", jhi-1, M)
+		jhi--
+	}
+
+	if (jhi - ilo) > 0 {
+		vDeleteSlice__RangedMap_void(&M.entryv, ilo,jhi)
+		debugf_RangedMap_void("\tdelete M[%d:%d]\t-> %s\n", ilo, jhi, M)
+	}
+
+	// done
+	return ilo
+}
+
+// HasRange returns whether all keys from range r belong to the map.
+func (M *_RangedMap_void) HasRange(r KeyRange) (yes bool) {
+	if trace_RangedMap_void {
+		fmt.Printf("\n\nHasRange:\n")
+		fmt.Printf("  M: %s\n", M)
+		fmt.Printf("  r: %s\n", r)
+		defer func() {
+			fmt.Printf("->·: %v\n", yes)
+		}()
+	}
+
+	M.verify()
+
+	if r.Empty() {
+		return true
+	}
+
+	// find first ilo: r.lo < [ilo].hi
+	l := len(M.entryv)
+	ilo := sort.Search(l, func(i int) bool {
+		 return r.Lo <= M.entryv[i].Hi_
+	})
+	debugf_RangedMap_void("\tilo: %d\n", ilo)
+
+	if ilo == l { // not found
+		return false
+	}
+
+	// scan right and verify that whole r is covered
+	lo := r.Lo
+	for {
+		e := M.entryv[ilo]
+		debugf_RangedMap_void("\te: %s\ttocheck: %s\n", e, KeyRange{lo, r.Hi_})
+
+		if lo < e.Lo {
+			return false // hole in coverage
+		}
+		if r.Hi_ <= e.Hi_ {
+			return true  // reached full coverage
+		}
+
+		lo = e.Hi_
+		if lo < KeyMax {
+			lo++
+		}
+
+		ilo++
+		if ilo == l {
+			return false // r's right not fully covered
+		}
+	}
+}
+
+
+
+// --------
+
+// verify checks _RangedMap_void for internal consistency:
+// - ranges must be not overlapping and ↑
+// - adjacent ranges must map to different values
+func (M *_RangedMap_void) verify() {
+	// TODO !debug -> return
+
+	var badv []string
+	badf := func(format string, argv ...interface{}) {
+		badv = append(badv, fmt.Sprintf(format, argv...))
+	}
+	defer func() {
+		if badv != nil {
+			emsg := "M.verify: fail:\n\n"
+			for _, bad := range badv {
+				emsg += fmt.Sprintf("- %s\n", bad)
+			}
+			emsg += fmt.Sprintf("\nM: %s\n", M)
+			panic(emsg)
+		}
+	}()
+
+	hi_Prev := KeyMin
+	var v_Prev void
+	for i, e := range M.entryv {
+		hiPrev := hi_Prev + 1
+		if i > 0 {
+			if (e.Value == v_Prev) {
+				if !(hiPrev < e.Lo) { // NOTE not ≤ - adjacent ranges must be merged
+					badf("[%d]: same value: !(hiPrev < e.lo)", i)
+				}
+			} else {
+				if !(hi_Prev <= e.Lo) {
+					badf("[%d]: different value: !(hiPrev ≤ e.lo)", i)
+				}
+			}
+		}
+		if !(e.Lo <= e.Hi_) {
+			badf("[%d]: !(e.lo ≤ e.hi_)", i)
+		}
+		hi_Prev = e.Hi_
+		v_Prev  = e.Value
+	}
+}
+
+// Clone returns copy of the map.
+//
+// NOTE values are _not_ cloned.
+func (orig *_RangedMap_void) Clone() *_RangedMap_void {
+	klon := &_RangedMap_void{}
+	klon.entryv = append(klon.entryv, orig.entryv...)
+	return klon
+}
+
+// Empty returns whether the map is empty.
+func (M *_RangedMap_void) Empty() bool {
+	return len(M.entryv) == 0
+}
+
+// Equal returns whether A == B.
+func (A *_RangedMap_void) Equal(B *_RangedMap_void) bool {
+	if len(A.entryv) != len(B.entryv) {
+		return false
+	}
+	for i, ea := range A.entryv {
+		eb := B.entryv[i]
+		if ea != eb {
+			return false
+		}
+	}
+	return true
+}
+
+// Clear removes all elements from the map.
+func (M *_RangedMap_void) Clear() {
+	M.entryv = nil
+}
+
+// AllRanges returns slice of all key ranges in the set.
+//
+// TODO -> iter?
+func (M *_RangedMap_void) AllRanges() /*readonly*/[]_RangedMap_voidEntry {
+	return M.entryv
+}
+
+func (M _RangedMap_void) String() string {
+	s := "{"
+	for i, e := range M.entryv {
+		if i > 0 {
+			s += " "
+		}
+		s += e.String()
+	}
+	s += "}"
+	return s
+}
+
+func (e _RangedMap_voidEntry) String() string {
+	s := e.KeyRange.String()
+	v := fmt.Sprintf("%v", e.Value)
+	if v != "" { // omit ":<v>" in the case of set
+		s += ":" + v
+	}
+	return s
+}
+
+
+func debugf_RangedMap_void(format string, argv ...interface{}) {
+	if !debug_RangedMap_void {
+		return
+	}
+	fmt.Printf(format, argv...)
+}
+
+
+// ---- slice ops ----
+
+// vInsert__RangedMap_void inserts e into *pv[i].
+func vInsert__RangedMap_void(pv *[]_RangedMap_voidEntry, i int, e _RangedMap_voidEntry) {
+	v := *pv
+	v = append(v, _RangedMap_voidEntry{})
+	copy(v[i+1:], v[i:])
+	v[i] = e
+	*pv = v
+}
+
+// vDeleteSlice__RangedMap_void deletes *pv[lo:hi].
+func vDeleteSlice__RangedMap_void(pv *[]_RangedMap_voidEntry, lo,hi int) {
+	v := *pv
+	n := copy(v[lo:], v[hi:])
+	v = v[:lo+n]
+	*pv = v
+}
+
+// vReplaceSlice__RangedMap_void replaces *pv[lo:hi] with e.
+func vReplaceSlice__RangedMap_void(pv *[]_RangedMap_voidEntry, lo,hi int, e _RangedMap_voidEntry) {
+	v := *pv
+	n := copy(v[lo+1:], v[hi:])
+	v[lo] = e
+	v = v[:lo+1+n]
+	*pv = v
+}

wcfs/internal/xbtree/δbtail.go

@@ -160,7 +160,9 @@ type _ΔTtail struct {
 	// set of nodes that were requested to be tracked in this tree, but for
 	// which vδT was not yet rebuilt
 	trackNew blib.PPTreeSubSet
+
 	// XXX + trackNewKeys RangedKeySet (concurrency)
+	// XXX + trackSetKeys RangedKeySet
 }
 
 // _ΔBroots represents roots-only part of ΔB.
@@ -882,6 +884,8 @@ func (δBtail *ΔBtail) GetAt(root zodb.Oid, key Key, at zodb.Tid) (value Value,
 	rev = tail
 	revExact = false
 
+	// XXX need to rebuild only if key was not rebuilt yet
+	// XXX need to rebuild only for key, not for whole trackNew
 	err = δBtail.rebuild1IfNeeded(root)
 	if err != nil {
 		return value, rev, valueExact, revExact, err