Merge pull request #221 from filecoin-project/misc/rlecrash

Lazy RLE+

chain/actors/actor_miner.go

@@ -477,7 +477,10 @@ func (sma StorageMinerActor) SubmitFallbackPoSt(act *types.Actor, vmctx types.VM
 		return nil, aerrors.Absorb(err, 3, "could not decode sectorset")
 	}
 
-	faults := self.CurrentFaultSet.All()
+	faults, nerr := self.CurrentFaultSet.All()
+	if nerr != nil {
+		return nil, aerrors.Absorb(err, 5, "RLE+ invalid")
+	}
 	_ = faults
 
 	proverID := vmctx.Message().To // TODO: normalize to ID address

chain/types/bitfield.go

@@ -3,19 +3,27 @@ package types
 import (
 	"fmt"
 	"io"
-	"sort"
 
-	"github.com/filecoin-project/lotus/extern/rleplus"
+	rlepluslazy "github.com/filecoin-project/lotus/lib/rlepluslazy"
 	cbg "github.com/whyrusleeping/cbor-gen"
 	"golang.org/x/xerrors"
 )
 
 type BitField struct {
+	rle rlepluslazy.RLE
+
 	bits map[uint64]struct{}
 }
 
 func NewBitField() BitField {
-	return BitField{bits: make(map[uint64]struct{})}
+	rle, err := rlepluslazy.FromBuf([]byte{})
+	if err != nil {
+		panic(err)
+	}
+	return BitField{
+		rle:  rle,
+		bits: make(map[uint64]struct{}),
+	}
 }
 
 func BitFieldFromSet(setBits []uint64) BitField {
@@ -26,31 +34,59 @@ func BitFieldFromSet(setBits []uint64) BitField {
 	return res
 }
 
+func (bf BitField) sum() (rlepluslazy.RunIterator, error) {
+	if len(bf.bits) == 0 {
+		return bf.rle.RunIterator()
+	}
+
+	a, err := bf.rle.RunIterator()
+	if err != nil {
+		return nil, err
+	}
+	slc := make([]uint64, 0, len(bf.bits))
+	for b := range bf.bits {
+		slc = append(slc, b)
+	}
+
+	b, err := rlepluslazy.RunsFromSlice(slc)
+	if err != nil {
+		return nil, err
+	}
+
+	res, err := rlepluslazy.Sum(a, b)
+	if err != nil {
+		return nil, err
+	}
+	return res, nil
+}
+
 // Set ...s bit in the BitField
 func (bf BitField) Set(bit uint64) {
 	bf.bits[bit] = struct{}{}
 }
 
-// Clear ...s bit in the BitField
-func (bf BitField) Clear(bit uint64) {
-	delete(bf.bits, bit)
+func (bf BitField) Count() (uint64, error) {
+	s, err := bf.sum()
+	if err != nil {
+		return 0, err
+	}
+	return rlepluslazy.Count(s)
 }
 
-// Has checkes if bit is set in the BitField
-func (bf BitField) Has(bit uint64) bool {
-	_, ok := bf.bits[bit]
-	return ok
-}
+// All returns all set bits
+func (bf BitField) All() ([]uint64, error) {
 
-// All returns all set bits, in random order
-func (bf BitField) All() []uint64 {
-	res := make([]uint64, 0, len(bf.bits))
-	for i := range bf.bits {
-		res = append(res, i)
+	runs, err := bf.sum()
+	if err != nil {
+		return nil, err
 	}
 
-	sort.Slice(res, func(i, j int) bool { return res[i] < res[j] })
-	return res
+	res, err := rlepluslazy.SliceFromRuns(runs)
+	if err != nil {
+		return nil, err
+	}
+
+	return res, err
 }
 
 func (bf BitField) MarshalCBOR(w io.Writer) error {
@@ -59,7 +95,12 @@ func (bf BitField) MarshalCBOR(w io.Writer) error {
 		ints = append(ints, i)
 	}
 
-	rle, _, err := rleplus.Encode(ints) // Encode sorts internally
+	s, err := bf.sum()
+	if err != nil {
+		return err
+	}
+
+	rle, err := rlepluslazy.EncodeRuns(s, []byte{})
 	if err != nil {
 		return err
 	}
@@ -88,19 +129,17 @@ func (bf *BitField) UnmarshalCBOR(r io.Reader) error {
 		return fmt.Errorf("expected byte array")
 	}
 
-	rle := make([]byte, extra)
-	if _, err := io.ReadFull(br, rle); err != nil {
+	buf := make([]byte, extra)
+	if _, err := io.ReadFull(br, buf); err != nil {
 		return err
 	}
 
-	ints, err := rleplus.Decode(rle)
+	rle, err := rlepluslazy.FromBuf(buf)
 	if err != nil {
 		return xerrors.Errorf("could not decode rle+: %w", err)
 	}
+	bf.rle = rle
 	bf.bits = make(map[uint64]struct{})
-	for _, i := range ints {
-		bf.bits[i] = struct{}{}
-	}
 
 	return nil
 }

lib/rlepluslazy/bits.go

@@ -0,0 +1,160 @@
+package rlepluslazy
+
+import (
+	"sort"
+)
+
+type it2b struct {
+	source RunIterator
+	curIdx uint64
+
+	run Run
+}
+
+func (it *it2b) HasNext() bool {
+	return it.run.Valid()
+}
+
+func (it *it2b) Next() (uint64, error) {
+	it.run.Len--
+	res := it.curIdx
+	it.curIdx++
+	return res, it.prep()
+}
+
+func (it *it2b) prep() error {
+	for !it.run.Valid() && it.source.HasNext() {
+		var err error
+		it.run, err = it.source.NextRun()
+		if err != nil {
+			return err
+		}
+
+		if !it.run.Val {
+			it.curIdx += it.run.Len
+			it.run.Len = 0
+		}
+	}
+	return nil
+}
+
+func BitsFromRuns(source RunIterator) (BitIterator, error) {
+	it := &it2b{source: source}
+	if err := it.prep(); err != nil {
+		return nil, err
+	}
+	return it, nil
+}
+
+type sliceIt struct {
+	s []uint64
+}
+
+func (it sliceIt) HasNext() bool {
+	return len(it.s) != 0
+}
+
+func (it *sliceIt) Next() (uint64, error) {
+	res := it.s[0]
+	it.s = it.s[1:]
+	return res, nil
+}
+
+func BitsFromSlice(slice []uint64) BitIterator {
+	sort.Slice(slice, func(i, j int) bool { return slice[i] < slice[j] })
+	return &sliceIt{slice}
+}
+
+type it2r struct {
+	source BitIterator
+
+	runIdx uint64
+	run    [2]Run
+}
+
+func (it *it2r) HasNext() bool {
+	return it.run[0].Valid()
+}
+
+func (it *it2r) NextRun() (Run, error) {
+	res := it.run[0]
+	it.runIdx = it.runIdx + res.Len
+	it.run[0], it.run[1] = it.run[1], Run{}
+	return res, it.prep()
+}
+
+func (it *it2r) prep() error {
+	if !it.HasNext() {
+		return nil
+	}
+	if it.run[0].Val == false {
+		it.run[1].Val = true
+		it.run[1].Len = 1
+		return nil
+	}
+
+	for it.source.HasNext() && !it.run[1].Valid() {
+		nB, err := it.source.Next()
+		if err != nil {
+			return err
+		}
+
+		//fmt.Printf("runIdx: %d, run[0].Len: %d, nB: %d\n", it.runIdx, it.run[0].Len, nB)
+		if it.runIdx+it.run[0].Len == nB {
+			it.run[0].Len++
+		} else {
+			it.run[1].Len = nB - it.runIdx - it.run[0].Len
+			it.run[1].Val = false
+		}
+	}
+	return nil
+}
+
+func (it *it2r) init() error {
+	if it.source.HasNext() {
+		nB, err := it.source.Next()
+		if err != nil {
+			return err
+		}
+		it.run[0].Len = nB
+		it.run[0].Val = false
+		it.run[1].Len = 1
+		it.run[1].Val = true
+	}
+
+	if !it.run[0].Valid() {
+		it.run[0], it.run[1] = it.run[1], Run{}
+		return it.prep()
+	}
+	return nil
+}
+
+func SliceFromRuns(source RunIterator) ([]uint64, error) {
+	rit, err := BitsFromRuns(source)
+	if err != nil {
+		return nil, err
+	}
+
+	res := make([]uint64, 0)
+	for rit.HasNext() {
+		bit, err := rit.Next()
+		if err != nil {
+			return nil, err
+		}
+		res = append(res, bit)
+	}
+	return res, nil
+}
+
+func RunsFromBits(source BitIterator) (RunIterator, error) {
+	it := &it2r{source: source}
+
+	if err := it.init(); err != nil {
+		return nil, err
+	}
+	return it, nil
+}
+
+func RunsFromSlice(slice []uint64) (RunIterator, error) {
+	return RunsFromBits(BitsFromSlice(slice))
+}

lib/rlepluslazy/bits_test.go

@@ -0,0 +1,27 @@
+package rlepluslazy
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestRunsFromBits(t *testing.T) {
+	expected := []Run{Run{Val: false, Len: 0x1},
+		{Val: true, Len: 0x3},
+		{Val: false, Len: 0x2},
+		{Val: true, Len: 0x3},
+	}
+	rit, err := RunsFromBits(BitsFromSlice([]uint64{1, 2, 3, 6, 7, 8}))
+	assert.NoError(t, err)
+	i := 10
+	output := make([]Run, 0, 4)
+	for rit.HasNext() && i > 0 {
+		run, err := rit.NextRun()
+		assert.NoError(t, err)
+		i--
+		output = append(output, run)
+	}
+	assert.NotEqual(t, 0, i, "too many iterations")
+	assert.Equal(t, expected, output)
+}

lib/rlepluslazy/bitvec.go

@@ -0,0 +1,114 @@
+package rlepluslazy
+
+type rbitvec struct {
+	index int
+
+	bits   uint16
+	bitCap byte
+
+	vec []byte
+}
+
+func readBitvec(vec []byte) *rbitvec {
+	bv := &rbitvec{
+		vec:    vec,
+		index:  1,
+		bitCap: 8,
+	}
+	if len(vec) > 0 {
+		bv.bits = uint16(bv.vec[0])
+	}
+	return bv
+}
+
+// bitMasks is a mask for selecting N first bits out of a byte
+var bitMasks = [9]byte{
+	0x0,
+	0x1,
+	0x3,
+	0x7,
+	0xF,
+	0x1F,
+	0x3F,
+	0x7F,
+	0xFF,
+}
+
+func (bv *rbitvec) Get(count byte) byte {
+	res := byte(bv.bits) & bitMasks[count] // select count bits
+	bv.bits = bv.bits >> count             // remove those bits from storage
+	bv.bitCap = bv.bitCap - count          // decrease nuber of stored bits
+
+	if bv.index < len(bv.vec) { // if vector allows
+		// add bits onto the end of temporary storage
+		bv.bits = bv.bits | uint16(bv.vec[bv.index])<<bv.bitCap
+	}
+
+	// Here be dragons
+	// This is equivalent to
+	// if bv.bitCap < 8 {
+	//     bv.index++
+	//     bv.bitCap = bv.bitCap + 8
+	// }
+	// but implemented without branches because the branch here is unpredictable
+	// Why this is without branches and reading has branch?
+	//  Because branch above is predictable, in 99.99% of cases it will be true
+
+	// if bitCap < 8 it underflows, then high bits get set to 1s
+	// we shift by 7 so the highest bit is in place of the lowest
+	inc := (bv.bitCap - 8) >> 7    // inc == 1 iff bitcap<8 (+10% perf)
+	bv.index = bv.index + int(inc) // increase index if we need more bits
+	bv.bitCap = bv.bitCap + inc*8  // increase bitCap by 8
+
+	return res
+}
+
+func writeBitvec(buf []byte) *wbitvec {
+	// reslice to 0 length for consistent input but to keep capacity
+	return &wbitvec{buf: buf[:0]}
+}
+
+type wbitvec struct {
+	buf   []byte // buffer we will be saving to
+	index int    // index of at which the next byte will be saved
+
+	bits   uint16 // temporary storage for bits
+	bitCap byte   // number of bits stored in temporary storage
+}
+
+func (bv *wbitvec) Out() []byte {
+	if bv.bitCap != 0 {
+		// if there are some bits in temporary storage we need to save them
+		bv.buf = append(bv.buf, 0)[:bv.index+1]
+		bv.buf[bv.index] = byte(bv.bits)
+	}
+	if bv.bitCap > 8 {
+		// if we store some needed bits in second byte, save them also
+		bv.buf = append(bv.buf, byte(bv.bitCap>>8))
+		bv.index++
+		bv.bits = bv.bits - 8
+	}
+	return bv.buf
+}
+
+func (bv *wbitvec) Put(val byte, count byte) {
+	// put val into its place in bv.bits
+	bv.bits = bv.bits | uint16(val)<<bv.bitCap
+	// increase bitCap by the number of bits
+	bv.bitCap = bv.bitCap + count
+
+	// increase len of the buffer if it is needed
+	if bv.index+1 > cap(bv.buf) {
+		bv.buf = append(bv.buf, 0)
+	}
+	bv.buf = bv.buf[:bv.index+1]
+	// save the bits
+	bv.buf[bv.index] = byte(bv.bits)
+
+	// Warning, dragons again
+	// if bitCap is greater than 7 it underflows, same thing as in Put
+	inc := (7 - bv.bitCap) >> 7    // inc == 1 iff bitcap>=8
+	bv.index = bv.index + int(inc) // increase index for the next save
+	bv.bitCap = bv.bitCap - inc*8  // we store less bits now in temporary buffer
+	bv.bits = bv.bits >> (inc * 8) // we can discard those bits as they were saved
+}

lib/rlepluslazy/bitvec_test.go

@@ -0,0 +1,21 @@
+package rlepluslazy
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestReadBitVec(t *testing.T) {
+	buf := []byte{0x0, 0xff}
+	bv := readBitvec(buf)
+
+	o := bv.Get(1)
+	assert.EqualValues(t, 0, o)
+
+	o = bv.Get(8)
+	assert.EqualValues(t, 0x80, o)
+
+	o = bv.Get(7)
+	assert.EqualValues(t, 0x7f, o)
+}

lib/rlepluslazy/interface.go

@@ -0,0 +1,24 @@
+package rlepluslazy
+
+type Run struct {
+	Val bool
+	Len uint64
+}
+
+func (r Run) Valid() bool {
+	return r.Len != 0
+}
+
+type RunIterator interface {
+	NextRun() (Run, error)
+	HasNext() bool
+}
+
+type RunIterable interface {
+	RunIterator() (RunIterator, error)
+}
+
+type BitIterator interface {
+	Next() (uint64, error)
+	HasNext() bool
+}

lib/rlepluslazy/rleplus.go

@@ -0,0 +1,47 @@
+package rlepluslazy
+
+import (
+	"errors"
+	"fmt"
+
+	"golang.org/x/xerrors"
+)
+
+const Version = 0
+
+var (
+	ErrWrongVersion = errors.New("invalid RLE+ version")
+	ErrDecode       = fmt.Errorf("invalid encoding for RLE+ version %d", Version)
+)
+
+type RLE struct {
+	buf []byte
+}
+
+func FromBuf(buf []byte) (RLE, error) {
+	rle := RLE{buf: buf}
+
+	if len(buf) > 0 && buf[0]&3 != Version {
+		return RLE{}, xerrors.Errorf("could not create RLE+ for a buffer: %w", ErrWrongVersion)
+	}
+
+	_, err := rle.Count()
+	if err != nil {
+		return RLE{}, err
+	}
+
+	return rle, nil
+}
+
+func (rle *RLE) RunIterator() (RunIterator, error) {
+	source, err := DecodeRLE(rle.buf)
+	return source, err
+}
+
+func (rle *RLE) Count() (uint64, error) {
+	it, err := rle.RunIterator()
+	if err != nil {
+		return 0, err
+	}
+	return Count(it)
+}

lib/rlepluslazy/rleplus_reader.go

@@ -0,0 +1,77 @@
+package rlepluslazy
+
+import (
+	"github.com/multiformats/go-varint"
+	"golang.org/x/xerrors"
+)
+
+func DecodeRLE(buf []byte) (RunIterator, error) {
+	bv := readBitvec(buf)
+
+	ver := bv.Get(2) // Read version
+	if ver != Version {
+		return nil, ErrWrongVersion
+	}
+
+	it := &rleIterator{bv: bv}
+
+	// next run is previous in relation to prep
+	// so we invert the value
+	it.nextRun.Val = bv.Get(1) != 1
+	if err := it.prep(); err != nil {
+		return nil, err
+	}
+	return it, nil
+}
+
+type rleIterator struct {
+	bv *rbitvec
+
+	nextRun Run
+}
+
+func (it *rleIterator) HasNext() bool {
+	return it.nextRun.Valid()
+}
+
+func (it *rleIterator) NextRun() (Run, error) {
+	ret := it.nextRun
+	return ret, it.prep()
+}
+
+func (it *rleIterator) prep() error {
+	x := it.bv.Get(1)
+
+	switch x {
+	case 1:
+		it.nextRun.Len = 1
+
+	case 0:
+		y := it.bv.Get(1)
+		switch y {
+		case 1:
+			it.nextRun.Len = uint64(it.bv.Get(4))
+		case 0:
+			var buf = make([]byte, 0, 10)
+			for {
+				b := it.bv.Get(8)
+				buf = append(buf, b)
+				if b&0x80 == 0 {
+					break
+				}
+				if len(buf) > 10 {
+					return xerrors.Errorf("run too long: %w", ErrDecode)
+				}
+			}
+			var err error
+			it.nextRun.Len, _, err = varint.FromUvarint(buf)
+			if err != nil {
+				return err
+			}
+
+		}
+	}
+
+	it.nextRun.Val = !it.nextRun.Val
+	return nil
+}

lib/rlepluslazy/rleplus_test.go

@@ -0,0 +1,170 @@
+package rlepluslazy
+
+import (
+	"math/rand"
+	"testing"
+
+	"github.com/filecoin-project/lotus/extern/rleplus"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestDecode(t *testing.T) {
+	// Encoding bitvec![LittleEndian; 1, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
+	// in the Rust reference implementation gives an encoding of [223, 145, 136, 0] (without version field)
+	// The bit vector is equivalent to the integer set { 0, 2, 4, 5, 6, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27 }
+
+	// This is the above reference output with a version header "00" manually added
+	referenceEncoding := []byte{124, 71, 34, 2}
+
+	expectedNumbers := []uint64{0, 2, 4, 5, 6, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27}
+
+	runs, err := RunsFromBits(BitsFromSlice(expectedNumbers))
+	assert.NoError(t, err)
+	encoded, err := EncodeRuns(runs, []byte{})
+	assert.NoError(t, err)
+
+	// Our encoded bytes are the same as the ref bytes
+	assert.Equal(t, len(referenceEncoding), len(encoded))
+	assert.Equal(t, referenceEncoding, encoded)
+
+	rle, err := FromBuf(encoded)
+	assert.NoError(t, err)
+	decoded := make([]uint64, 0, len(expectedNumbers))
+
+	rit, err := rle.RunIterator()
+	assert.NoError(t, err)
+
+	it, err := BitsFromRuns(rit)
+	assert.NoError(t, err)
+	for it.HasNext() {
+		bit, err := it.Next()
+		assert.NoError(t, err)
+		decoded = append(decoded, bit)
+	}
+
+	// Our decoded integers are the same as expected
+	assert.Equal(t, expectedNumbers, decoded)
+}
+
+func TestGoldenGen(t *testing.T) {
+	t.SkipNow()
+	N := 10000
+	mod := uint32(1) << 20
+	runExProp := float32(0.93)
+
+	bits := make([]uint64, N)
+
+	for i := 0; i < N; i++ {
+		x := rand.Uint32() % mod
+		bits[i] = uint64(x)
+		for rand.Float32() < runExProp && i+1 < N {
+			i++
+			x = (x + 1) % mod
+			bits[i] = uint64(x)
+		}
+	}
+
+	out, _, err := rleplus.Encode(bits)
+	assert.NoError(t, err)
+	t.Logf("%#v", out)
+	_, runs := rleplus.RunLengths(bits)
+	t.Logf("runs: %v", runs)
+	t.Logf("len: %d", len(out))
+}
+
+func TestGolden(t *testing.T) {
+	expected, _ := rleplus.Decode(goldenRLE)
+	res := make([]uint64, 0, len(expected))
+
+	rle, err := FromBuf(goldenRLE)
+	assert.NoError(t, err)
+	rit, err := rle.RunIterator()
+	assert.NoError(t, err)
+	it, err := BitsFromRuns(rit)
+	assert.NoError(t, err)
+	for it.HasNext() {
+		bit, err := it.Next()
+		assert.NoError(t, err)
+		res = append(res, bit)
+	}
+	assert.Equal(t, expected, res)
+}
+
+func TestGoldenLoop(t *testing.T) {
+	rle, err := FromBuf(goldenRLE)
+	assert.NoError(t, err)
+
+	rit, err := rle.RunIterator()
+	assert.NoError(t, err)
+
+	buf, err := EncodeRuns(rit, nil)
+	assert.NoError(t, err)
+
+	assert.Equal(t, goldenRLE, buf)
+}
+
+var Res uint64 = 0
+
+func BenchmarkRunIterator(b *testing.B) {
+	b.ReportAllocs()
+	var r uint64
+	for i := 0; i < b.N; i++ {
+		rle, _ := FromBuf(goldenRLE)
+		rit, _ := rle.RunIterator()
+		for rit.HasNext() {
+			run, _ := rit.NextRun()
+			if run.Val {
+				r = r + run.Len
+			}
+		}
+	}
+	Res = Res + r
+}
+
+func BenchmarkRunsToBits(b *testing.B) {
+	b.ReportAllocs()
+	var r uint64
+	for i := 0; i < b.N; i++ {
+		rle, _ := FromBuf(goldenRLE)
+		rit, _ := rle.RunIterator()
+		it, _ := BitsFromRuns(rit)
+		for it.HasNext() {
+			bit, _ := it.Next()
+			if bit < 1<<63 {
+				r++
+			}
+		}
+	}
+	Res = Res + r
+}
+
+func BenchmarkOldRLE(b *testing.B) {
+	b.ReportAllocs()
+	var r uint64
+	for i := 0; i < b.N; i++ {
+		rle, _ := rleplus.Decode(goldenRLE)
+		r = r + uint64(len(rle))
+	}
+	Res = Res + r
+}
+
+func BenchmarkDecodeEncode(b *testing.B) {
+	b.ReportAllocs()
+	var r uint64
+	out := make([]byte, 0, len(goldenRLE))
+	for i := 0; i < b.N; i++ {
+		rle, _ := FromBuf(goldenRLE)
+		rit, _ := rle.RunIterator()
+		out, _ = EncodeRuns(rit, out)
+		r = r + uint64(len(out))
+	}
+
+	/*
+		for i := 0; i < b.N; i++ {
+			rle, _ := rleplus.Decode(goldenRLE)
+			out, _, _ := rleplus.Encode(rle)
+			r = r + uint64(len(out))
+		}
+	*/
+	Res = Res + r
+}

lib/rlepluslazy/rleplus_writer.go

@@ -0,0 +1,51 @@
+package rlepluslazy
+
+import (
+	"encoding/binary"
+)
+
+func EncodeRuns(rit RunIterator, buf []byte) ([]byte, error) {
+	bv := writeBitvec(buf)
+	bv.Put(0, 2)
+
+	first := true
+	varBuf := make([]byte, binary.MaxVarintLen64)
+
+	for rit.HasNext() {
+		run, err := rit.NextRun()
+		if err != nil {
+			return nil, err
+		}
+
+		if first {
+			if run.Val {
+				bv.Put(1, 1)
+			} else {
+				bv.Put(0, 1)
+			}
+			first = false
+		}
+
+		switch {
+		case run.Len == 1:
+			bv.Put(1, 1)
+		case run.Len < 16:
+			bv.Put(2, 2)
+			bv.Put(byte(run.Len), 4)
+		case run.Len >= 16:
+			bv.Put(0, 2)
+			numBytes := binary.PutUvarint(varBuf, run.Len)
+			for i := 0; i < numBytes; i++ {
+				bv.Put(varBuf[i], 8)
+			}
+		}
+
+	}
+
+	if first {
+		bv.Put(0, 1)
+	}
+
+	return bv.Out(), nil
+
+}

lib/rlepluslazy/runs.go

@@ -0,0 +1,120 @@
+package rlepluslazy
+
+import (
+	"math"
+
+	"golang.org/x/xerrors"
+)
+
+func Sum(a, b RunIterator) (RunIterator, error) {
+	it := addIt{a: a, b: b}
+	it.prep()
+	return &it, nil
+}
+
+type addIt struct {
+	a RunIterator
+	b RunIterator
+
+	next Run
+
+	arun Run
+	brun Run
+}
+
+func (it *addIt) prep() error {
+	var err error
+
+	fetch := func() error {
+		if !it.arun.Valid() && it.a.HasNext() {
+			it.arun, err = it.a.NextRun()
+			if err != nil {
+				return err
+			}
+		}
+
+		if !it.brun.Valid() && it.b.HasNext() {
+			it.brun, err = it.b.NextRun()
+			if err != nil {
+				return err
+			}
+		}
+		return nil
+	}
+
+	if err := fetch(); err != nil {
+		return err
+	}
+
+	// one is not valid
+	if !it.arun.Valid() {
+		it.next = it.brun
+		it.brun.Len = 0
+		return nil
+	}
+
+	if !it.brun.Valid() {
+		it.next = it.arun
+		it.arun.Len = 0
+		return nil
+	}
+
+	if !(it.arun.Val || it.brun.Val) {
+		min := it.arun.Len
+		if it.brun.Len < min {
+			min = it.brun.Len
+		}
+		it.next = Run{Val: it.arun.Val, Len: min}
+		it.arun.Len -= it.next.Len
+		it.brun.Len -= it.next.Len
+		return nil
+	}
+
+	it.next = Run{Val: true}
+	// different vals, 'true' wins
+	for (it.arun.Val && it.arun.Valid()) || (it.brun.Val && it.brun.Valid()) {
+		min := it.arun.Len
+		if it.brun.Len < min && it.brun.Valid() || !it.arun.Valid() {
+			min = it.brun.Len
+		}
+		it.next.Len += min
+		if it.arun.Valid() {
+			it.arun.Len -= min
+		}
+		if it.brun.Valid() {
+			it.brun.Len -= min
+		}
+		if err := fetch(); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (it *addIt) HasNext() bool {
+	return it.next.Valid()
+}
+
+func (it *addIt) NextRun() (Run, error) {
+	next := it.next
+	return next, it.prep()
+}
+
+func Count(ri RunIterator) (uint64, error) {
+	var count uint64
+
+	for ri.HasNext() {
+		r, err := ri.NextRun()
+		if err != nil {
+			return 0, err
+		}
+		if r.Val {
+			if math.MaxUint64-r.Len < count {
+				return 0, xerrors.New("RLE+ overflows")
+			}
+			count += r.Len
+		}
+	}
+	return count, nil
+}

lib/rlepluslazy/runs_test.go

@@ -0,0 +1,94 @@
+package rlepluslazy
+
+import (
+	"math/rand"
+	"sort"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestSumRuns(t *testing.T) {
+	{
+		a, err := RunsFromSlice([]uint64{0, 1, 2, 3, 4, 5, 6, 7, 8, 11, 12, 13, 14})
+		assert.NoError(t, err)
+		b, err := RunsFromSlice([]uint64{0, 1, 2, 3, 9, 10, 16, 17, 18, 50, 51, 70})
+		assert.NoError(t, err)
+
+		s, err := Sum(a, b)
+		assert.NoError(t, err)
+		bis, err := SliceFromRuns(s)
+		assert.Equal(t, []uint64{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 16, 17, 18, 50, 51, 70}, bis)
+		assert.NoError(t, err)
+	}
+
+	{
+		a, err := RunsFromSlice([]uint64{0, 1, 2, 3, 4, 5, 6, 7, 8, 11, 12, 13, 14})
+		assert.NoError(t, err)
+		b, err := RunsFromSlice([]uint64{0, 1, 2, 3, 9, 10, 16, 17, 18, 50, 51, 70})
+		assert.NoError(t, err)
+
+		s, err := Sum(b, a)
+		assert.NoError(t, err)
+		bis, err := SliceFromRuns(s)
+		assert.Equal(t, []uint64{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 16, 17, 18, 50, 51, 70}, bis)
+		assert.NoError(t, err)
+	}
+}
+
+func randomBits(N int, max uint64) []uint64 {
+	all := make(map[uint64]struct{})
+	for len(all) <= N {
+		x := rand.Uint64() % max
+		if _, has := all[x]; has {
+			continue
+		}
+		all[x] = struct{}{}
+	}
+
+	res := make([]uint64, 0, N)
+	for x := range all {
+		res = append(res, x)
+	}
+	sort.Slice(res, func(i, j int) bool { return res[i] < res[j] })
+
+	return res
+}
+
+func sum(a, b []uint64) []uint64 {
+	all := make(map[uint64]struct{})
+	for _, x := range a {
+		all[x] = struct{}{}
+	}
+	for _, x := range b {
+		all[x] = struct{}{}
+	}
+	res := make([]uint64, 0, len(all))
+	for x := range all {
+		res = append(res, x)
+	}
+	sort.Slice(res, func(i, j int) bool { return res[i] < res[j] })
+
+	return res
+}
+
+func TestSumRandom(t *testing.T) {
+	N := 100
+
+	for i := 0; i < N; i++ {
+		abits := randomBits(1000, 1500)
+		bbits := randomBits(1000, 1500)
+		sumbits := sum(abits, bbits)
+
+		a, err := RunsFromSlice(abits)
+		assert.NoError(t, err)
+		b, err := RunsFromSlice(bbits)
+		assert.NoError(t, err)
+
+		s, err := Sum(b, a)
+		assert.NoError(t, err)
+		bis, err := SliceFromRuns(s)
+		assert.NoError(t, err)
+		assert.Equal(t, sumbits, bis)
+	}
+}