New cache implementation and prefetch handing in mw/cache (#731)

* cache: add sharded cache implementation

Add Cache impl and a few tests. This cache is 256-way sharded, mainly
so each shard has it's own lock. The main cache structure is a readonly
jump plane into the right shard.

This should remove the single lock contention on the main lock and
provide more concurrent throughput - Obviously this hasn't been tested
or measured.

The key into the cache was made a uint32 (hash.fnv) and the hashing op
is not using strings.ToLower anymore remove any GC in that code path.

* here too

* Minimum shard size

* typos

* blurp

* small cleanups no defer

* typo

* Add freq based on Johns idea

* cherry-pick conflict resolv

* typo

* update from early code review from john

* add prefetch to the cache

* mw/cache: add prefetch

* remove println

* remove comment

* Fix tests

* Test prefetch in setup

* Add start of cache

* try add diff cache options

* Add hacky testcase

* not needed

* allow the use of a percentage for prefetch

If the TTL falls below xx% do a prefetch, if the record was popular.
Some other fixes and correctly prefetch only popular records.

1 files changed, 6 insertions, 5 deletions

diff --git a/middleware/cache/cache_test.go b/middleware/cache/cache_test.go
index 18aa05fe5..adac7d67b 100644
--- a/middleware/cache/cache_test.go
+++ b/middleware/cache/cache_test.go
@@ -7,10 +7,10 @@ import (
 	"time"
 
 	"github.com/coredns/coredns/middleware"
+	"github.com/coredns/coredns/middleware/pkg/cache"
 	"github.com/coredns/coredns/middleware/pkg/response"
 	"github.com/coredns/coredns/middleware/test"
 
-	lru "github.com/hashicorp/golang-lru"
 	"github.com/miekg/dns"
 )
 
@@ -148,10 +148,10 @@ func cacheMsg(m *dns.Msg, tc cacheTestCase) *dns.Msg {
 
 func newTestCache(ttl time.Duration) (*Cache, *ResponseWriter) {
 	c := &Cache{Zones: []string{"."}, pcap: defaultCap, ncap: defaultCap, pttl: ttl, nttl: ttl}
-	c.pcache, _ = lru.New(c.pcap)
-	c.ncache, _ = lru.New(c.ncap)
+	c.pcache = cache.New(c.pcap)
+	c.ncache = cache.New(c.ncap)
 
-	crr := &ResponseWriter{nil, c}
+	crr := &ResponseWriter{ResponseWriter: nil, Cache: c}
 	return c, crr
 }
 
@@ -176,7 +176,8 @@ func TestCache(t *testing.T) {
 		name := middleware.Name(m.Question[0].Name).Normalize()
 		qtype := m.Question[0].Qtype
 
-		i, ok, _ := c.get(name, qtype, do)
+		i, _ := c.get(time.Now().UTC(), name, qtype, do)
+		ok := i != nil
 
 		if ok != tc.shouldCache {
 			t.Errorf("cached message that should not have been cached: %s", name)