wcfs: xbtree: blib += PPTreeSubSet, ΔPPTreeSubSet

This data structures will be used in ΔBtail to maintain sef of tracked
BTree nodes, and to represent δ to such set.

Some preliminary history:

kirr/wendelin.core@78f2f88b    X wcfs/xbtree: Fix treediff(a, ø)
kirr/wendelin.core@5324547c    X wcfs/xbtree: root(a) must stay in trackSet even after treediff(a,ø)
kirr/wendelin.core@f65f775b    X wcfs/xbtree: treediff(ø, b)
kirr/wendelin.core@66bc41ce    X Fix bug in PPTreeSubSet.Difference  - it was always leaving root node alive
kirr/wendelin.core@ddb28043    X rebuild: Don't return nil for empty ΔPPTreeSubSet - that leads to SIGSEGV
kirr/wendelin.core@a87cc6de    X rebuild: tests: Don't recompute trackSet(keys1R2) several times

Quoting PPTreeSubSet and ΔPPTreeSubSet documentation:

---- 8< ----

PPTreeSubSet represents PP-connected subset of tree node objects.

It is

    PP(xleafs)

where PP(node) maps node to {node, node.parent, node.parent,parent, ...} up
to top root from where the node is reached.

The nodes in the set are represented by their Oid.

Usually PPTreeSubSet is built as PP(some-leafs), but in general the starting
nodes are arbitrary. PPTreeSubSet can also have many root nodes, thus not
necessarily representing a subset of a single tree.

Usual set operations are provided: Union, Difference and Intersection.

Nodes can be added into the set via AddPath. Path is reverse operation - it
returns path to tree node given its oid.

Every node in the set comes with .parent pointer.

~~~~

ΔPPTreeSubSet represents a change to PPTreeSubSet.

It can be applied via PPTreeSubSet.ApplyΔ .

The result B of applying δ to A is:

    B = A.xDifference(δ.Del).xUnion(δ.Add)		(*)

(*) NOTE δ.Del and δ.Add might have their leafs starting from non-leaf nodes in A/B.
    This situation arises when δ represents a change in path to particular
    node, but that node itself does not change, for example:

           c*             c
          / \            /
        41*  42         41
         |    |         | \
        22   43        46  43
              |         |   |
             44        22  44

    Here nodes {c, 41} are changed, node 42 is unlinked, and node 46 is added.
    Nodes 43 and 44 stay unchanged.

        δ.Del = c-42-43   | c-41-22
        δ.Add = c-41-43   | c-41-46-22

    The second component with "-22" builds from leaf, but the first
    component with "-43" builds from non-leaf node.

        ΔnchildNonLeafs = {43: +1}

    Only complete result of applying all

        - xfixup(-1, ΔnchildNonLeafs)
        - δ.Del,
        - δ.Add, and
        - xfixup(+1, ΔnchildNonLeafs)

    produces correctly PP-connected set.

wcfs/internal/xbtree/blib/blib.go

@@ -25,6 +25,8 @@ import (
 	"math"
 
 	"lab.nexedi.com/kirr/neo/go/zodb/btree"
+
+	"lab.nexedi.com/nexedi/wendelin.core/wcfs/internal/set"
 )
 
 // XXX instead of generics
@@ -39,6 +41,8 @@ type KeyRange    = btree.LKeyRange
 const KeyMax Key = math.MaxInt64
 const KeyMin Key = math.MinInt64
 
+type setOid = set.Oid
+
 
 // KStr formats key as string.
 func KStr(k Key) string {
@@ -50,3 +54,8 @@ func KStr(k Key) string {
 	}
 	return fmt.Sprintf("%d", k)
 }
+
+
+func panicf(format string, argv ...interface{}) {
+	panic(fmt.Sprintf(format, argv...))
+}

wcfs/internal/xbtree/blib/pptreesubset_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
+
+import (
+	"strings"
+	"testing"
+
+	"lab.nexedi.com/kirr/neo/go/zodb"
+)
+
+func TestPPTreeSubSetOps(t *testing.T) {
+	const (
+		a zodb.Oid = 0xa + iota
+		b
+		c
+		d
+		ø = zodb.InvalidOid
+	)
+	type S = PPTreeSubSet
+	type testEntry struct {
+		A, B       S
+		Union      S
+		Difference S
+	}
+	E := func(A, B, U, D S) testEntry {
+		return testEntry{A, B, U, D}
+	}
+
+	testv := []testEntry{
+		E(
+			S{},	// A
+			S{},	// B
+				S{},	// U
+				S{}),	// D
+
+		E(
+			S{a:{ø,0}},	// A
+			S{a:{ø,0}},	// B
+				S{a:{ø,0}},	// U
+				S{}),		// D
+
+		E(
+			S{a:{ø,0}},	// A
+			S{b:{ø,0}},	// B
+				S{a:{ø,0}, b:{ø,0}},	// U
+				S{a:{ø,0}}),		// D
+
+		E(
+			S{a:{ø,1}, b:{a,0}},	// A
+			S{a:{ø,1}, c:{a,0}},	// B
+				S{a:{ø,2}, b:{a,0}, c:{a,0}},	// U
+				S{a:{ø,1}, b:{a,0}}),		// D
+
+		E(
+			S{a:{ø,1}, b:{a,1}, c:{b,0}},	// A
+			S{a:{ø,1}, b:{a,1}, d:{b,0}},	// B
+				S{a:{ø,1}, b:{a,2}, c:{b,0}, d:{b,0}},	// U
+				S{a:{ø,1}, b:{a,1}, c:{b,0}}),		// D
+
+		E(
+			S{a:{ø,1}, b:{a,0}},	// A
+			S{a:{ø,1}, b:{a,0}},	// B
+				S{a:{ø,1}, b:{a,0}},	// U
+				S{}),			// D
+
+		E(
+			S{a:{ø,1}, b:{a,1}, c:{b,0}},	// A
+			S{a:{ø,1}, b:{a,1}, c:{b,0}},	// B (=A)
+				S{a:{ø,1}, b:{a,1}, c:{b,0}},	// U (=A)
+				S{}),				// D
+	}
+
+	// assert1 asserts that result of op(A,B) == resOK.
+	assert1 := func(op string, A, B, res, resOK S) {
+		t.Helper()
+		if res.Equal(resOK) {
+			return
+		}
+		op1 := op[0:1]
+		t.Errorf("%s:\n  A:   %s\n  B:   %s\n  ->%s: %s\n  ok%s: %s\n",
+			strings.Title(op), A, B, op1, res, strings.ToUpper(op1), resOK)
+	}
+
+	for _, tt := range testv {
+		Uab := tt.A.Union(tt.B)
+		Uba := tt.B.Union(tt.A)
+		Dab := tt.A.Difference(tt.B)
+
+		assert1("union",      tt.A, tt.B, Uab, tt.Union)
+		assert1("union",      tt.B, tt.A, Uba, tt.Union)
+		assert1("difference", tt.A, tt.B, Dab, tt.Difference)
+
+		Uaa := tt.A.Union(tt.A)
+		Ubb := tt.B.Union(tt.B)
+		Daa := tt.A.Difference(tt.A)
+		Dbb := tt.B.Difference(tt.B)
+
+		assert1("union",      tt.A, tt.A, Uaa, tt.A)
+		assert1("union",      tt.B, tt.B, Ubb, tt.B)
+		assert1("difference", tt.A, tt.A, Daa, S{})
+		assert1("difference", tt.B, tt.B, Dbb, S{})
+
+		// TODO also verify U/D properties like (A+B)\B + (A+B)\A + (A^B) == (A+B) ?
+	}
+}