Remove the caching

app/collector.go

@@ -78,7 +78,7 @@ func NewCollector(window time.Duration) Collector {
 		waitableCondition: waitableCondition{
 			waiters: map[chan struct{}]struct{}{},
 		},
-		merger: NewSmartMerger(window),
+		merger: NewSmartMerger(),
 	}
 }
 

app/merger.go

@@ -4,7 +4,6 @@ import (
 	"fmt"
 	"math"
 	"sort"
-	"time"
 
 	"github.com/bluele/gcache"
 	"github.com/spaolacci/murmur3"
@@ -39,17 +38,11 @@ type smartMerger struct {
 	cache gcache.Cache
 }
 
-// NewSmartMerger makes a Merger which merges together reports, caching intermediate merges
-// to accelerate future merges. Idea is to cache pair-wise merged reports, forming a merge
-// tree.  Merging a new report into this tree should be log(N).
-func NewSmartMerger(window time.Duration) Merger {
-	return &smartMerger{
-		cache: gcache.New(200).
-			LRU().
-			Expiration(window).
-			EnableGC(2 * time.Second).
-			Build(),
-	}
+// NewSmartMerger makes a Merger which merges together reports as
+// a binary tree of reports.  Speed up comes from the fact that
+// most merges are between small reports.
+func NewSmartMerger() Merger {
+	return smartMerger{}
 }
 
 type node struct {
@@ -71,11 +64,7 @@ func hash(ids ...string) uint64 {
 	return id.Sum64()
 }
 
-func (s *smartMerger) ClearCache() {
-	s.cache.Purge()
-}
-
-func (s *smartMerger) Merge(reports []report.Report) report.Report {
+func (s smartMerger) Merge(reports []report.Report) report.Report {
 	// Start with a sorted list of leaves.
 	// Note we must dedupe reports with the same ID to ensure the
 	// algorithm below doesn't go into an infinite loop.  This is
@@ -98,16 +87,10 @@ func (s *smartMerger) Merge(reports []report.Report) report.Report {
 	// Define how to merge two nodes together.  The result of merging
 	// two reports is cached.
 	merge := func(left, right *node) *node {
-		id := hash(left.rpt.ID, right.rpt.ID)
-		if result, err := s.cache.Get(id); err == nil {
-			return result.(*node)
-		}
-		n := &node{
-			id:  id,
+		return &node{
+			id:  hash(left.rpt.ID, right.rpt.ID),
 			rpt: report.MakeReport().Merge(left.rpt).Merge(right.rpt),
 		}
-		s.cache.Set(id, n)
-		return n
 	}
 
 	// Define how to reduce n nodes to 1.

app/merger_test.go

@@ -4,7 +4,6 @@ import (
 	"fmt"
 	"math/rand"
 	"testing"
-	"time"
 
 	"github.com/weaveworks/scope/app"
 	"github.com/weaveworks/scope/report"
@@ -29,7 +28,7 @@ func TestMerger(t *testing.T) {
 		AddNode(report.MakeNode("bar")).
 		AddNode(report.MakeNode("baz"))
 
-	for _, merger := range []app.Merger{app.MakeDumbMerger(), app.NewSmartMerger(10 * time.Second)} {
+	for _, merger := range []app.Merger{app.MakeDumbMerger(), app.NewSmartMerger()} {
 		// Test the empty list case
 		if have := merger.Merge([]report.Report{}); !reflect.DeepEqual(have, report.MakeReport()) {
 			t.Errorf("Bad merge: %s", test.Diff(have, want))
@@ -63,27 +62,23 @@ func TestSmartMerger(t *testing.T) {
 	want := report.MakeReport()
 	want.Endpoint.AddNode(report.MakeNode("foo"))
 
-	merger := app.NewSmartMerger(10 * time.Second)
+	merger := app.NewSmartMerger()
 	if have := merger.Merge(reports); !reflect.DeepEqual(have, want) {
 		t.Errorf("Bad merge: %s", test.Diff(have, want))
 	}
 }
 
 func BenchmarkSmartMerger(b *testing.B) {
-	benchmarkMerger(b, app.NewSmartMerger(10*time.Second), false)
-}
-
-func BenchmarkSmartMergerWithoutCaching(b *testing.B) {
-	benchmarkMerger(b, app.NewSmartMerger(10*time.Second), true)
+	benchmarkMerger(b, app.NewSmartMerger())
 }
 
 func BenchmarkDumbMerger(b *testing.B) {
-	benchmarkMerger(b, app.MakeDumbMerger(), false)
+	benchmarkMerger(b, app.MakeDumbMerger())
 }
 
 const numHosts = 15
 
-func benchmarkMerger(b *testing.B, merger app.Merger, clearCache bool) {
+func benchmarkMerger(b *testing.B, merger app.Merger) {
 	makeReport := func() report.Report {
 		rpt := report.MakeReport()
 		for i := 0; i < 100; i++ {
@@ -96,12 +91,6 @@ func benchmarkMerger(b *testing.B, merger app.Merger, clearCache bool) {
 	for i := 0; i < numHosts*5; i++ {
 		reports = append(reports, makeReport())
 	}
-	merger.Merge(reports) // prime the cache
-	if clearable, ok := merger.(interface {
-		ClearCache()
-	}); ok && clearCache {
-		clearable.ClearCache()
-	}
 
 	b.ReportAllocs()
 	b.ResetTimer()
@@ -113,11 +102,5 @@ func benchmarkMerger(b *testing.B, merger app.Merger, clearCache bool) {
 		}
 
 		merger.Merge(reports)
-
-		if clearable, ok := merger.(interface {
-			ClearCache()
-		}); ok && clearCache {
-			clearable.ClearCache()
-		}
 	}
 }