Merge pull request #81 from Workiva/hilbert_tree

Hilbert tree

Author: dustinhiatt-wf

augmentedtree/multidimensional_test.go

@@ -194,7 +194,7 @@ func TestAddLargeNumbersMultiDimensions(t *testing.T) {
 }
 
 func BenchmarkAddItemsMultiDimensions(b *testing.B) {
-	numItems := int64(1000)
+	numItems := int64(b.N)
 	intervals := make(Intervals, 0, numItems)
 
 	for i := int64(0); i < numItems; i++ {
@@ -204,11 +204,11 @@ func BenchmarkAddItemsMultiDimensions(b *testing.B) {
 		intervals = append(intervals, iv)
 	}
 
+	it := newTree(2)
 	b.ResetTimer()
 
 	for i := 0; i < b.N; i++ {
-		it := newTree(2)
-		it.Add(intervals...)
+		it.Add(intervals[int64(i)%numItems])
 	}
 }
 

rtree/hilbert/action.go

@@ -0,0 +1,187 @@
+/*
+Copyright 2014 Workiva, LLC
+
+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.
+*/
+
+package hilbert
+
+import (
+	"runtime"
+	"sync"
+	"sync/atomic"
+
+	"github.com/Workiva/go-datastructures/rtree"
+)
+
+type actions []action
+
+type action interface {
+	operation() operation
+	keys() hilberts
+	rects() []*hilbertBundle
+	complete()
+	addNode(int64, *node)
+	nodes() []*node
+}
+
+type getAction struct {
+	result    rtree.Rectangles
+	completer *sync.WaitGroup
+	lookup    *rectangle
+}
+
+func (ga *getAction) complete() {
+	ga.completer.Done()
+}
+
+func (ga *getAction) operation() operation {
+	return get
+}
+
+func (ga *getAction) keys() hilberts {
+	return nil
+}
+
+func (ga *getAction) addNode(i int64, n *node) {
+	return // not necessary for gets
+}
+
+func (ga *getAction) nodes() []*node {
+	return nil
+}
+
+func (ga *getAction) rects() []*hilbertBundle {
+	return nil
+}
+
+func newGetAction(rect rtree.Rectangle) *getAction {
+	r := newRectangeFromRect(rect)
+	ga := &getAction{
+		completer: new(sync.WaitGroup),
+		lookup:    r,
+	}
+	ga.completer.Add(1)
+	return ga
+}
+
+type insertAction struct {
+	rs        []*hilbertBundle
+	completer *sync.WaitGroup
+	ns        []*node
+}
+
+func (ia *insertAction) complete() {
+	ia.completer.Done()
+}
+
+func (ia *insertAction) operation() operation {
+	return add
+}
+
+func (ia *insertAction) keys() hilberts {
+	return nil
+}
+
+func (ia *insertAction) addNode(i int64, n *node) {
+	ia.ns[i] = n
+}
+
+func (ia *insertAction) nodes() []*node {
+	return ia.ns
+}
+
+func (ia *insertAction) rects() []*hilbertBundle {
+	return ia.rs
+}
+
+func newInsertAction(rects rtree.Rectangles) *insertAction {
+	ia := &insertAction{
+		rs:        bundlesFromRects(rects...),
+		completer: new(sync.WaitGroup),
+		ns:        make([]*node, len(rects)),
+	}
+	ia.completer.Add(1)
+	return ia
+}
+
+type removeAction struct {
+	*insertAction
+}
+
+func (ra *removeAction) operation() operation {
+	return remove
+}
+
+func newRemoveAction(rects rtree.Rectangles) *removeAction {
+	return &removeAction{
+		newInsertAction(rects),
+	}
+}
+
+func minUint64(choices ...uint64) uint64 {
+	min := choices[0]
+	for i := 1; i < len(choices); i++ {
+		if choices[i] < min {
+			min = choices[i]
+		}
+	}
+
+	return min
+}
+
+type interfaces []interface{}
+
+func executeInterfacesInParallel(ifs interfaces, fn func(interface{})) {
+	if len(ifs) == 0 {
+		return
+	}
+
+	done := int64(-1)
+	numCPU := uint64(runtime.NumCPU())
+	if numCPU > 1 {
+		numCPU--
+	}
+
+	numCPU = minUint64(numCPU, uint64(len(ifs)))
+
+	var wg sync.WaitGroup
+	wg.Add(int(numCPU))
+
+	for i := uint64(0); i < numCPU; i++ {
+		go func() {
+			defer wg.Done()
+
+			for {
+				i := atomic.AddInt64(&done, 1)
+				if i >= int64(len(ifs)) {
+					return
+				}
+
+				fn(ifs[i])
+			}
+		}()
+	}
+
+	wg.Wait()
+}
+
+func executeInterfacesInSerial(ifs interfaces, fn func(interface{})) {
+	if len(ifs) == 0 {
+		return
+	}
+
+	for _, ifc := range ifs {
+		fn(ifc)
+	}
+}

rtree/hilbert/cpu.prof

@@ -0,0 +1,79 @@
+/*
+Copyright 2014 Workiva, LLC
+
+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.
+*/
+
+package hilbert
+
+import (
+	"runtime"
+	"sync"
+
+	h "github.com/Workiva/go-datastructures/numerics/hilbert"
+	"github.com/Workiva/go-datastructures/rtree"
+)
+
+func getCenter(rect rtree.Rectangle) (int32, int32) {
+	xlow, ylow := rect.LowerLeft()
+	xhigh, yhigh := rect.UpperRight()
+
+	return (xhigh + xlow) / 2, (yhigh + ylow) / 2
+}
+
+type hilbertBundle struct {
+	hilbert hilbert
+	rect    rtree.Rectangle
+}
+
+func bundlesFromRects(rects ...rtree.Rectangle) []*hilbertBundle {
+	chunks := chunkRectangles(rects, int64(runtime.NumCPU()))
+	bundleChunks := make([][]*hilbertBundle, len(chunks))
+	var wg sync.WaitGroup
+	wg.Add(len(chunks))
+
+	for i := 0; i < runtime.NumCPU(); i++ {
+		if len(chunks[i]) == 0 {
+			bundleChunks[i] = []*hilbertBundle{}
+			wg.Done()
+			continue
+		}
+		go func(i int) {
+			bundles := make([]*hilbertBundle, 0, len(chunks[i]))
+			for _, r := range chunks[i] {
+				h := h.Encode(getCenter(r))
+				bundles = append(bundles, &hilbertBundle{hilbert(h), r})
+			}
+			bundleChunks[i] = bundles
+			wg.Done()
+		}(i)
+	}
+
+	wg.Wait()
+
+	bundles := make([]*hilbertBundle, 0, len(rects))
+	for _, bc := range bundleChunks {
+		bundles = append(bundles, bc...)
+	}
+
+	return bundles
+}
+
+// chunkRectangles takes a slice of rtree.Rectangle values and chunks it into `numParts` subslices.
+func chunkRectangles(slice rtree.Rectangles, numParts int64) []rtree.Rectangles {
+	parts := make([]rtree.Rectangles, numParts)
+	for i := int64(0); i < numParts; i++ {
+		parts[i] = slice[i*int64(len(slice))/numParts : (i+1)*int64(len(slice))/numParts]
+	}
+	return parts
+}

rtree/hilbert/hilbert.go

@@ -0,0 +1,38 @@
+/*
+Copyright 2014 Workiva, LLC
+
+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.
+*/
+
+package hilbert
+
+type mockRectangle struct {
+	xlow, ylow, xhigh, yhigh int32
+}
+
+func (mr *mockRectangle) LowerLeft() (int32, int32) {
+	return mr.xlow, mr.ylow
+}
+
+func (mr *mockRectangle) UpperRight() (int32, int32) {
+	return mr.xhigh, mr.yhigh
+}
+
+func newMockRectangle(xlow, ylow, xhigh, yhigh int32) *mockRectangle {
+	return &mockRectangle{
+		xlow:  xlow,
+		ylow:  ylow,
+		xhigh: xhigh,
+		yhigh: yhigh,
+	}
+}