miracle091/dnscrypt-proxy
miracle091
/
dnscrypt-proxy
mirror of https://github.com/DNSCrypt/dnscrypt-proxy.git
1
0
Fork 0
Code Issues Releases Wiki Activity

Update golang-lru

This commit is contained in:
Frank Denis 2018-02-02 17:46:45 +01:00
parent 1fcb0acc77
commit a7ecb1a4a3
7 changed files with 52 additions and 44 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
Gopkg.lock generated
View File

@ -65,7 +65,7 @@
".", ".",
"simplelru" "simplelru"
] ]
revision = "0a025b7e63adc15a622f29b0b2c4c3848243bbf6" revision = "0fb14efe8c47ae851c0034ed7a448854d3d34cf3"
[[projects]] [[projects]]
name = "github.com/jedisct1/dlog" name = "github.com/jedisct1/dlog"
@ -127,7 +127,7 @@
"ipv4", "ipv4",
"ipv6" "ipv6"
] ]
revision = "0ed95abb35c445290478a5348a7b38bb154135fd" revision = "b417086c80e91bfa321ef761574721644b8b9f61"
[[projects]] [[projects]]
branch = "master" branch = "master"
@ -139,7 +139,7 @@
"windows/svc/eventlog", "windows/svc/eventlog",
"windows/svc/mgr" "windows/svc/mgr"
] ]
revision = "3dbebcf8efb6a5011a60c2b4591c1022a759af8a" revision = "37707fdb30a5b38865cfb95e5aab41707daec7fd"
[solve-meta] [solve-meta]
analyzer-name = "dep" analyzer-name = "dep"

21
vendor/github.com/hashicorp/golang-lru/2q.go generated vendored
View File

@ -30,9 +30,9 @@ type TwoQueueCache struct {
size int size int
recentSize int recentSize int
recent *simplelru.LRU recent simplelru.LRUCache
frequent *simplelru.LRU frequent simplelru.LRUCache
recentEvict *simplelru.LRU recentEvict simplelru.LRUCache
lock sync.RWMutex lock sync.RWMutex
} }
@ -84,7 +84,8 @@ func New2QParams(size int, recentRatio float64, ghostRatio float64) (*TwoQueueCa
return c, nil return c, nil
} }
func (c *TwoQueueCache) Get(key interface{}) (interface{}, bool) { // Get looks up a key's value from the cache.
func (c *TwoQueueCache) Get(key interface{}) (value interface{}, ok bool) {
c.lock.Lock() c.lock.Lock()
defer c.lock.Unlock() defer c.lock.Unlock()
@ -105,6 +106,7 @@ func (c *TwoQueueCache) Get(key interface{}) (interface{}, bool) {
return nil, false return nil, false
} }
// Add adds a value to the cache.
func (c *TwoQueueCache) Add(key, value interface{}) { func (c *TwoQueueCache) Add(key, value interface{}) {
c.lock.Lock() c.lock.Lock()
defer c.lock.Unlock() defer c.lock.Unlock()
@ -160,12 +162,15 @@ func (c *TwoQueueCache) ensureSpace(recentEvict bool) {
c.frequent.RemoveOldest() c.frequent.RemoveOldest()
} }
// Len returns the number of items in the cache.
func (c *TwoQueueCache) Len() int { func (c *TwoQueueCache) Len() int {
c.lock.RLock() c.lock.RLock()
defer c.lock.RUnlock() defer c.lock.RUnlock()
return c.recent.Len() + c.frequent.Len() return c.recent.Len() + c.frequent.Len()
} }
// Keys returns a slice of the keys in the cache.
// The frequently used keys are first in the returned slice.
func (c *TwoQueueCache) Keys() []interface{} { func (c *TwoQueueCache) Keys() []interface{} {
c.lock.RLock() c.lock.RLock()
defer c.lock.RUnlock() defer c.lock.RUnlock()
@ -174,6 +179,7 @@ func (c *TwoQueueCache) Keys() []interface{} {
return append(k1, k2...) return append(k1, k2...)
} }
// Remove removes the provided key from the cache.
func (c *TwoQueueCache) Remove(key interface{}) { func (c *TwoQueueCache) Remove(key interface{}) {
c.lock.Lock() c.lock.Lock()
defer c.lock.Unlock() defer c.lock.Unlock()
@ -188,6 +194,7 @@ func (c *TwoQueueCache) Remove(key interface{}) {
} }
} }
// Purge is used to completely clear the cache.
func (c *TwoQueueCache) Purge() { func (c *TwoQueueCache) Purge() {
c.lock.Lock() c.lock.Lock()
defer c.lock.Unlock() defer c.lock.Unlock()
@ -196,13 +203,17 @@ func (c *TwoQueueCache) Purge() {
c.recentEvict.Purge() c.recentEvict.Purge()
} }
// Contains is used to check if the cache contains a key
// without updating recency or frequency.
func (c *TwoQueueCache) Contains(key interface{}) bool { func (c *TwoQueueCache) Contains(key interface{}) bool {
c.lock.RLock() c.lock.RLock()
defer c.lock.RUnlock() defer c.lock.RUnlock()
return c.frequent.Contains(key) || c.recent.Contains(key) return c.frequent.Contains(key) || c.recent.Contains(key)
} }
func (c *TwoQueueCache) Peek(key interface{}) (interface{}, bool) { // Peek is used to inspect the cache value of a key
// without updating recency or frequency.
func (c *TwoQueueCache) Peek(key interface{}) (value interface{}, ok bool) {
c.lock.RLock() c.lock.RLock()
defer c.lock.RUnlock() defer c.lock.RUnlock()
if val, ok := c.frequent.Peek(key); ok { if val, ok := c.frequent.Peek(key); ok {

16
vendor/github.com/hashicorp/golang-lru/arc.go generated vendored
View File

@ -18,11 +18,11 @@ type ARCCache struct {
size int // Size is the total capacity of the cache size int // Size is the total capacity of the cache
p int // P is the dynamic preference towards T1 or T2 p int // P is the dynamic preference towards T1 or T2
t1 *simplelru.LRU // T1 is the LRU for recently accessed items t1 simplelru.LRUCache // T1 is the LRU for recently accessed items
b1 *simplelru.LRU // B1 is the LRU for evictions from t1 b1 simplelru.LRUCache // B1 is the LRU for evictions from t1
t2 *simplelru.LRU // T2 is the LRU for frequently accessed items t2 simplelru.LRUCache // T2 is the LRU for frequently accessed items
b2 *simplelru.LRU // B2 is the LRU for evictions from t2 b2 simplelru.LRUCache // B2 is the LRU for evictions from t2
lock sync.RWMutex lock sync.RWMutex
} }
@ -60,11 +60,11 @@ func NewARC(size int) (*ARCCache, error) {
} }
// Get looks up a key's value from the cache. // Get looks up a key's value from the cache.
func (c *ARCCache) Get(key interface{}) (interface{}, bool) { func (c *ARCCache) Get(key interface{}) (value interface{}, ok bool) {
c.lock.Lock() c.lock.Lock()
defer c.lock.Unlock() defer c.lock.Unlock()
// Ff the value is contained in T1 (recent), then // If the value is contained in T1 (recent), then
// promote it to T2 (frequent) // promote it to T2 (frequent)
if val, ok := c.t1.Peek(key); ok { if val, ok := c.t1.Peek(key); ok {
c.t1.Remove(key) c.t1.Remove(key)
@ -153,7 +153,7 @@ func (c *ARCCache) Add(key, value interface{}) {
// Remove from B2 // Remove from B2
c.b2.Remove(key) c.b2.Remove(key)
// Add the key to the frequntly used list // Add the key to the frequently used list
c.t2.Add(key, value) c.t2.Add(key, value)
return return
} }
@ -247,7 +247,7 @@ func (c *ARCCache) Contains(key interface{}) bool {
// Peek is used to inspect the cache value of a key // Peek is used to inspect the cache value of a key
// without updating recency or frequency. // without updating recency or frequency.
func (c *ARCCache) Peek(key interface{}) (interface{}, bool) { func (c *ARCCache) Peek(key interface{}) (value interface{}, ok bool) {
c.lock.RLock() c.lock.RLock()
defer c.lock.RUnlock() defer c.lock.RUnlock()
if val, ok := c.t1.Peek(key); ok { if val, ok := c.t1.Peek(key); ok {

28
vendor/github.com/hashicorp/golang-lru/lru.go generated vendored
View File

@ -1,6 +1,3 @@
// This package provides a simple LRU cache. It is based on the
// LRU implementation in groupcache:
// https://github.com/golang/groupcache/tree/master/lru
package lru package lru
import ( import (
@ -11,11 +8,11 @@ import (
// Cache is a thread-safe fixed size LRU cache. // Cache is a thread-safe fixed size LRU cache.
type Cache struct { type Cache struct {
lru *simplelru.LRU lru simplelru.LRUCache
lock sync.RWMutex lock sync.RWMutex
} }
// New creates an LRU of the given size // New creates an LRU of the given size.
func New(size int) (*Cache, error) { func New(size int) (*Cache, error) {
return NewWithEvict(size, nil) return NewWithEvict(size, nil)
} }
@ -33,7 +30,7 @@ func NewWithEvict(size int, onEvicted func(key interface{}, value interface{}))
return c, nil return c, nil
} }
// Purge is used to completely clear the cache // Purge is used to completely clear the cache.
func (c *Cache) Purge() { func (c *Cache) Purge() {
c.lock.Lock() c.lock.Lock()
c.lru.Purge() c.lru.Purge()
@ -41,30 +38,30 @@ func (c *Cache) Purge() {
} }
// Add adds a value to the cache. Returns true if an eviction occurred. // Add adds a value to the cache. Returns true if an eviction occurred.
func (c *Cache) Add(key, value interface{}) bool { func (c *Cache) Add(key, value interface{}) (evicted bool) {
c.lock.Lock() c.lock.Lock()
defer c.lock.Unlock() defer c.lock.Unlock()
return c.lru.Add(key, value) return c.lru.Add(key, value)
} }
// Get looks up a key's value from the cache. // Get looks up a key's value from the cache.
func (c *Cache) Get(key interface{}) (interface{}, bool) { func (c *Cache) Get(key interface{}) (value interface{}, ok bool) {
c.lock.Lock() c.lock.Lock()
defer c.lock.Unlock() defer c.lock.Unlock()
return c.lru.Get(key) return c.lru.Get(key)
} }
// Check if a key is in the cache, without updating the recent-ness // Contains checks if a key is in the cache, without updating the
// or deleting it for being stale. // recent-ness or deleting it for being stale.
func (c *Cache) Contains(key interface{}) bool { func (c *Cache) Contains(key interface{}) bool {
c.lock.RLock() c.lock.RLock()
defer c.lock.RUnlock() defer c.lock.RUnlock()
return c.lru.Contains(key) return c.lru.Contains(key)
} }
// Returns the key value (or undefined if not found) without updating // Peek returns the key value (or undefined if not found) without updating
// the "recently used"-ness of the key. // the "recently used"-ness of the key.
func (c *Cache) Peek(key interface{}) (interface{}, bool) { func (c *Cache) Peek(key interface{}) (value interface{}, ok bool) {
c.lock.RLock() c.lock.RLock()
defer c.lock.RUnlock() defer c.lock.RUnlock()
return c.lru.Peek(key) return c.lru.Peek(key)
@ -73,16 +70,15 @@ func (c *Cache) Peek(key interface{}) (interface{}, bool) {
// ContainsOrAdd checks if a key is in the cache without updating the // ContainsOrAdd checks if a key is in the cache without updating the
// recent-ness or deleting it for being stale, and if not, adds the value. // recent-ness or deleting it for being stale, and if not, adds the value.
// Returns whether found and whether an eviction occurred. // Returns whether found and whether an eviction occurred.
func (c *Cache) ContainsOrAdd(key, value interface{}) (ok, evict bool) { func (c *Cache) ContainsOrAdd(key, value interface{}) (ok, evicted bool) {
c.lock.Lock() c.lock.Lock()
defer c.lock.Unlock() defer c.lock.Unlock()
if c.lru.Contains(key) { if c.lru.Contains(key) {
return true, false return true, false
} else {
evict := c.lru.Add(key, value)
return false, evict
} }
evicted = c.lru.Add(key, value)
return false, evicted
} }
// Remove removes the provided key from the cache. // Remove removes the provided key from the cache.

4
vendor/github.com/hashicorp/golang-lru/lru_test.go generated vendored
View File

@ -72,7 +72,7 @@ func TestLRU(t *testing.T) {
if k != v { if k != v {
t.Fatalf("Evict values not equal (%v!=%v)", k, v) t.Fatalf("Evict values not equal (%v!=%v)", k, v)
} }
evictCounter += 1 evictCounter++
} }
l, err := NewWithEvict(128, onEvicted) l, err := NewWithEvict(128, onEvicted)
if err != nil { if err != nil {
@ -136,7 +136,7 @@ func TestLRU(t *testing.T) {
func TestLRUAdd(t *testing.T) { func TestLRUAdd(t *testing.T) {
evictCounter := 0 evictCounter := 0
onEvicted := func(k interface{}, v interface{}) { onEvicted := func(k interface{}, v interface{}) {
evictCounter += 1 evictCounter++
} }
l, err := NewWithEvict(1, onEvicted) l, err := NewWithEvict(1, onEvicted)

17
vendor/github.com/hashicorp/golang-lru/simplelru/lru.go generated vendored
View File

@ -36,7 +36,7 @@ func NewLRU(size int, onEvict EvictCallback) (*LRU, error) {
return c, nil return c, nil
} }
// Purge is used to completely clear the cache // Purge is used to completely clear the cache.
func (c *LRU) Purge() { func (c *LRU) Purge() {
for k, v := range c.items { for k, v := range c.items {
if c.onEvict != nil { if c.onEvict != nil {
@ -48,7 +48,7 @@ func (c *LRU) Purge() {
} }
// Add adds a value to the cache. Returns true if an eviction occurred. // Add adds a value to the cache. Returns true if an eviction occurred.
func (c *LRU) Add(key, value interface{}) bool { func (c *LRU) Add(key, value interface{}) (evicted bool) {
// Check for existing item // Check for existing item
if ent, ok := c.items[key]; ok { if ent, ok := c.items[key]; ok {
c.evictList.MoveToFront(ent) c.evictList.MoveToFront(ent)
@ -78,17 +78,18 @@ func (c *LRU) Get(key interface{}) (value interface{}, ok bool) {
return return
} }
// Check if a key is in the cache, without updating the recent-ness // Contains checks if a key is in the cache, without updating the recent-ness
// or deleting it for being stale. // or deleting it for being stale.
func (c *LRU) Contains(key interface{}) (ok bool) { func (c *LRU) Contains(key interface{}) (ok bool) {
_, ok = c.items[key] _, ok = c.items[key]
return ok return ok
} }
// Returns the key value (or undefined if not found) without updating // Peek returns the key value (or undefined if not found) without updating
// the "recently used"-ness of the key. // the "recently used"-ness of the key.
func (c *LRU) Peek(key interface{}) (value interface{}, ok bool) { func (c *LRU) Peek(key interface{}) (value interface{}, ok bool) {
if ent, ok := c.items[key]; ok { var ent *list.Element
if ent, ok = c.items[key]; ok {
return ent.Value.(*entry).value, true return ent.Value.(*entry).value, true
} }
return nil, ok return nil, ok
@ -96,7 +97,7 @@ func (c *LRU) Peek(key interface{}) (value interface{}, ok bool) {
// Remove removes the provided key from the cache, returning if the // Remove removes the provided key from the cache, returning if the
// key was contained. // key was contained.
func (c *LRU) Remove(key interface{}) bool { func (c *LRU) Remove(key interface{}) (present bool) {
if ent, ok := c.items[key]; ok { if ent, ok := c.items[key]; ok {
c.removeElement(ent) c.removeElement(ent)
return true return true
@ -105,7 +106,7 @@ func (c *LRU) Remove(key interface{}) bool {
} }
// RemoveOldest removes the oldest item from the cache. // RemoveOldest removes the oldest item from the cache.
func (c *LRU) RemoveOldest() (interface{}, interface{}, bool) { func (c *LRU) RemoveOldest() (key interface{}, value interface{}, ok bool) {
ent := c.evictList.Back() ent := c.evictList.Back()
if ent != nil { if ent != nil {
c.removeElement(ent) c.removeElement(ent)
@ -116,7 +117,7 @@ func (c *LRU) RemoveOldest() (interface{}, interface{}, bool) {
} }
// GetOldest returns the oldest entry // GetOldest returns the oldest entry
func (c *LRU) GetOldest() (interface{}, interface{}, bool) { func (c *LRU) GetOldest() (key interface{}, value interface{}, ok bool) {
ent := c.evictList.Back() ent := c.evictList.Back()
if ent != nil { if ent != nil {
kv := ent.Value.(*entry) kv := ent.Value.(*entry)

4
vendor/github.com/hashicorp/golang-lru/simplelru/lru_test.go generated vendored
View File

@ -8,7 +8,7 @@ func TestLRU(t *testing.T) {
if k != v { if k != v {
t.Fatalf("Evict values not equal (%v!=%v)", k, v) t.Fatalf("Evict values not equal (%v!=%v)", k, v)
} }
evictCounter += 1 evictCounter++
} }
l, err := NewLRU(128, onEvicted) l, err := NewLRU(128, onEvicted)
if err != nil { if err != nil {
@ -112,7 +112,7 @@ func TestLRU_GetOldest_RemoveOldest(t *testing.T) {
func TestLRU_Add(t *testing.T) { func TestLRU_Add(t *testing.T) {
evictCounter := 0 evictCounter := 0
onEvicted := func(k interface{}, v interface{}) { onEvicted := func(k interface{}, v interface{}) {
evictCounter += 1 evictCounter++
} }
l, err := NewLRU(1, onEvicted) l, err := NewLRU(1, onEvicted)