diff --git a/old/cache.go b/old/cache.go deleted file mode 100644 index 54490f2..0000000 --- a/old/cache.go +++ /dev/null @@ -1,1161 +0,0 @@ -package old - -import ( - "encoding/gob" - "fmt" - "io" - "os" - "runtime" - "sync" - "time" -) - -type Item struct { - Object interface{} - Expiration int64 -} - -// Returns true if the item has expired. -func (item Item) Expired() bool { - if item.Expiration == 0 { - return false - } - return time.Now().UnixNano() > item.Expiration -} - -const ( - // For use with functions that take an expiration time. - NoExpiration time.Duration = -1 - // For use with functions that take an expiration time. Equivalent to - // passing in the same expiration duration as was given to New() or - // NewFrom() when the cache was created (e.g. 5 minutes.) - DefaultExpiration time.Duration = 0 -) - -type Cache struct { - *cache - // If this is confusing, see the comment at the bottom of New() -} - -type cache struct { - defaultExpiration time.Duration - items map[string]Item - mu sync.RWMutex - onEvicted func(string, interface{}) - janitor *janitor -} - -// Add an item to the cache, replacing any existing item. If the duration is 0 -// (DefaultExpiration), the cache's default expiration time is used. If it is -1 -// (NoExpiration), the item never expires. -func (c *cache) Set(k string, x interface{}, d time.Duration) { - // "Inlining" of set - var e int64 - if d == DefaultExpiration { - d = c.defaultExpiration - } - if d > 0 { - e = time.Now().Add(d).UnixNano() - } - c.mu.Lock() - c.items[k] = Item{ - Object: x, - Expiration: e, - } - // TODO: Calls to mu.Unlock are currently not deferred because defer - // adds ~200 ns (as of go1.) - c.mu.Unlock() -} - -func (c *cache) set(k string, x interface{}, d time.Duration) { - var e int64 - if d == DefaultExpiration { - d = c.defaultExpiration - } - if d > 0 { - e = time.Now().Add(d).UnixNano() - } - c.items[k] = Item{ - Object: x, - Expiration: e, - } -} - -// Add an item to the cache, replacing any existing item, using the default -// expiration. -func (c *cache) SetDefault(k string, x interface{}) { - c.Set(k, x, DefaultExpiration) -} - -// Add an item to the cache only if an item doesn't already exist for the given -// key, or if the existing item has expired. Returns an error otherwise. -func (c *cache) Add(k string, x interface{}, d time.Duration) error { - c.mu.Lock() - _, found := c.get(k) - if found { - c.mu.Unlock() - return fmt.Errorf("Item %s already exists", k) - } - c.set(k, x, d) - c.mu.Unlock() - return nil -} - -// Set a new value for the cache key only if it already exists, and the existing -// item hasn't expired. Returns an error otherwise. -func (c *cache) Replace(k string, x interface{}, d time.Duration) error { - c.mu.Lock() - _, found := c.get(k) - if !found { - c.mu.Unlock() - return fmt.Errorf("Item %s doesn't exist", k) - } - c.set(k, x, d) - c.mu.Unlock() - return nil -} - -// Get an item from the cache. Returns the item or nil, and a bool indicating -// whether the key was found. -func (c *cache) Get(k string) (interface{}, bool) { - c.mu.RLock() - // "Inlining" of get and Expired - item, found := c.items[k] - if !found { - c.mu.RUnlock() - return nil, false - } - if item.Expiration > 0 { - if time.Now().UnixNano() > item.Expiration { - c.mu.RUnlock() - return nil, false - } - } - c.mu.RUnlock() - return item.Object, true -} - -// GetWithExpiration returns an item and its expiration time from the cache. -// It returns the item or nil, the expiration time if one is set (if the item -// never expires a zero value for time.Time is returned), and a bool indicating -// whether the key was found. -func (c *cache) GetWithExpiration(k string) (interface{}, time.Time, bool) { - c.mu.RLock() - // "Inlining" of get and Expired - item, found := c.items[k] - if !found { - c.mu.RUnlock() - return nil, time.Time{}, false - } - - if item.Expiration > 0 { - if time.Now().UnixNano() > item.Expiration { - c.mu.RUnlock() - return nil, time.Time{}, false - } - - // Return the item and the expiration time - c.mu.RUnlock() - return item.Object, time.Unix(0, item.Expiration), true - } - - // If expiration <= 0 (i.e. no expiration time set) then return the item - // and a zeroed time.Time - c.mu.RUnlock() - return item.Object, time.Time{}, true -} - -func (c *cache) get(k string) (interface{}, bool) { - item, found := c.items[k] - if !found { - return nil, false - } - // "Inlining" of Expired - if item.Expiration > 0 { - if time.Now().UnixNano() > item.Expiration { - return nil, false - } - } - return item.Object, true -} - -// Increment an item of type int, int8, int16, int32, int64, uintptr, uint, -// uint8, uint32, or uint64, float32 or float64 by n. Returns an error if the -// item's value is not an integer, if it was not found, or if it is not -// possible to increment it by n. To retrieve the incremented value, use one -// of the specialized methods, e.g. IncrementInt64. -func (c *cache) Increment(k string, n int64) error { - c.mu.Lock() - v, found := c.items[k] - if !found || v.Expired() { - c.mu.Unlock() - return fmt.Errorf("Item %s not found", k) - } - switch v.Object.(type) { - case int: - v.Object = v.Object.(int) + int(n) - case int8: - v.Object = v.Object.(int8) + int8(n) - case int16: - v.Object = v.Object.(int16) + int16(n) - case int32: - v.Object = v.Object.(int32) + int32(n) - case int64: - v.Object = v.Object.(int64) + n - case uint: - v.Object = v.Object.(uint) + uint(n) - case uintptr: - v.Object = v.Object.(uintptr) + uintptr(n) - case uint8: - v.Object = v.Object.(uint8) + uint8(n) - case uint16: - v.Object = v.Object.(uint16) + uint16(n) - case uint32: - v.Object = v.Object.(uint32) + uint32(n) - case uint64: - v.Object = v.Object.(uint64) + uint64(n) - case float32: - v.Object = v.Object.(float32) + float32(n) - case float64: - v.Object = v.Object.(float64) + float64(n) - default: - c.mu.Unlock() - return fmt.Errorf("The value for %s is not an integer", k) - } - c.items[k] = v - c.mu.Unlock() - return nil -} - -// Increment an item of type float32 or float64 by n. Returns an error if the -// item's value is not floating point, if it was not found, or if it is not -// possible to increment it by n. Pass a negative number to decrement the -// value. To retrieve the incremented value, use one of the specialized methods, -// e.g. IncrementFloat64. -func (c *cache) IncrementFloat(k string, n float64) error { - c.mu.Lock() - v, found := c.items[k] - if !found || v.Expired() { - c.mu.Unlock() - return fmt.Errorf("Item %s not found", k) - } - switch v.Object.(type) { - case float32: - v.Object = v.Object.(float32) + float32(n) - case float64: - v.Object = v.Object.(float64) + n - default: - c.mu.Unlock() - return fmt.Errorf("The value for %s does not have type float32 or float64", k) - } - c.items[k] = v - c.mu.Unlock() - return nil -} - -// Increment an item of type int by n. Returns an error if the item's value is -// not an int, or if it was not found. If there is no error, the incremented -// value is returned. -func (c *cache) IncrementInt(k string, n int) (int, error) { - c.mu.Lock() - v, found := c.items[k] - if !found || v.Expired() { - c.mu.Unlock() - return 0, fmt.Errorf("Item %s not found", k) - } - rv, ok := v.Object.(int) - if !ok { - c.mu.Unlock() - return 0, fmt.Errorf("The value for %s is not an int", k) - } - nv := rv + n - v.Object = nv - c.items[k] = v - c.mu.Unlock() - return nv, nil -} - -// Increment an item of type int8 by n. Returns an error if the item's value is -// not an int8, or if it was not found. If there is no error, the incremented -// value is returned. -func (c *cache) IncrementInt8(k string, n int8) (int8, error) { - c.mu.Lock() - v, found := c.items[k] - if !found || v.Expired() { - c.mu.Unlock() - return 0, fmt.Errorf("Item %s not found", k) - } - rv, ok := v.Object.(int8) - if !ok { - c.mu.Unlock() - return 0, fmt.Errorf("The value for %s is not an int8", k) - } - nv := rv + n - v.Object = nv - c.items[k] = v - c.mu.Unlock() - return nv, nil -} - -// Increment an item of type int16 by n. Returns an error if the item's value is -// not an int16, or if it was not found. If there is no error, the incremented -// value is returned. -func (c *cache) IncrementInt16(k string, n int16) (int16, error) { - c.mu.Lock() - v, found := c.items[k] - if !found || v.Expired() { - c.mu.Unlock() - return 0, fmt.Errorf("Item %s not found", k) - } - rv, ok := v.Object.(int16) - if !ok { - c.mu.Unlock() - return 0, fmt.Errorf("The value for %s is not an int16", k) - } - nv := rv + n - v.Object = nv - c.items[k] = v - c.mu.Unlock() - return nv, nil -} - -// Increment an item of type int32 by n. Returns an error if the item's value is -// not an int32, or if it was not found. If there is no error, the incremented -// value is returned. -func (c *cache) IncrementInt32(k string, n int32) (int32, error) { - c.mu.Lock() - v, found := c.items[k] - if !found || v.Expired() { - c.mu.Unlock() - return 0, fmt.Errorf("Item %s not found", k) - } - rv, ok := v.Object.(int32) - if !ok { - c.mu.Unlock() - return 0, fmt.Errorf("The value for %s is not an int32", k) - } - nv := rv + n - v.Object = nv - c.items[k] = v - c.mu.Unlock() - return nv, nil -} - -// Increment an item of type int64 by n. Returns an error if the item's value is -// not an int64, or if it was not found. If there is no error, the incremented -// value is returned. -func (c *cache) IncrementInt64(k string, n int64) (int64, error) { - c.mu.Lock() - v, found := c.items[k] - if !found || v.Expired() { - c.mu.Unlock() - return 0, fmt.Errorf("Item %s not found", k) - } - rv, ok := v.Object.(int64) - if !ok { - c.mu.Unlock() - return 0, fmt.Errorf("The value for %s is not an int64", k) - } - nv := rv + n - v.Object = nv - c.items[k] = v - c.mu.Unlock() - return nv, nil -} - -// Increment an item of type uint by n. Returns an error if the item's value is -// not an uint, or if it was not found. If there is no error, the incremented -// value is returned. -func (c *cache) IncrementUint(k string, n uint) (uint, error) { - c.mu.Lock() - v, found := c.items[k] - if !found || v.Expired() { - c.mu.Unlock() - return 0, fmt.Errorf("Item %s not found", k) - } - rv, ok := v.Object.(uint) - if !ok { - c.mu.Unlock() - return 0, fmt.Errorf("The value for %s is not an uint", k) - } - nv := rv + n - v.Object = nv - c.items[k] = v - c.mu.Unlock() - return nv, nil -} - -// Increment an item of type uintptr by n. Returns an error if the item's value -// is not an uintptr, or if it was not found. If there is no error, the -// incremented value is returned. -func (c *cache) IncrementUintptr(k string, n uintptr) (uintptr, error) { - c.mu.Lock() - v, found := c.items[k] - if !found || v.Expired() { - c.mu.Unlock() - return 0, fmt.Errorf("Item %s not found", k) - } - rv, ok := v.Object.(uintptr) - if !ok { - c.mu.Unlock() - return 0, fmt.Errorf("The value for %s is not an uintptr", k) - } - nv := rv + n - v.Object = nv - c.items[k] = v - c.mu.Unlock() - return nv, nil -} - -// Increment an item of type uint8 by n. Returns an error if the item's value -// is not an uint8, or if it was not found. If there is no error, the -// incremented value is returned. -func (c *cache) IncrementUint8(k string, n uint8) (uint8, error) { - c.mu.Lock() - v, found := c.items[k] - if !found || v.Expired() { - c.mu.Unlock() - return 0, fmt.Errorf("Item %s not found", k) - } - rv, ok := v.Object.(uint8) - if !ok { - c.mu.Unlock() - return 0, fmt.Errorf("The value for %s is not an uint8", k) - } - nv := rv + n - v.Object = nv - c.items[k] = v - c.mu.Unlock() - return nv, nil -} - -// Increment an item of type uint16 by n. Returns an error if the item's value -// is not an uint16, or if it was not found. If there is no error, the -// incremented value is returned. -func (c *cache) IncrementUint16(k string, n uint16) (uint16, error) { - c.mu.Lock() - v, found := c.items[k] - if !found || v.Expired() { - c.mu.Unlock() - return 0, fmt.Errorf("Item %s not found", k) - } - rv, ok := v.Object.(uint16) - if !ok { - c.mu.Unlock() - return 0, fmt.Errorf("The value for %s is not an uint16", k) - } - nv := rv + n - v.Object = nv - c.items[k] = v - c.mu.Unlock() - return nv, nil -} - -// Increment an item of type uint32 by n. Returns an error if the item's value -// is not an uint32, or if it was not found. If there is no error, the -// incremented value is returned. -func (c *cache) IncrementUint32(k string, n uint32) (uint32, error) { - c.mu.Lock() - v, found := c.items[k] - if !found || v.Expired() { - c.mu.Unlock() - return 0, fmt.Errorf("Item %s not found", k) - } - rv, ok := v.Object.(uint32) - if !ok { - c.mu.Unlock() - return 0, fmt.Errorf("The value for %s is not an uint32", k) - } - nv := rv + n - v.Object = nv - c.items[k] = v - c.mu.Unlock() - return nv, nil -} - -// Increment an item of type uint64 by n. Returns an error if the item's value -// is not an uint64, or if it was not found. If there is no error, the -// incremented value is returned. -func (c *cache) IncrementUint64(k string, n uint64) (uint64, error) { - c.mu.Lock() - v, found := c.items[k] - if !found || v.Expired() { - c.mu.Unlock() - return 0, fmt.Errorf("Item %s not found", k) - } - rv, ok := v.Object.(uint64) - if !ok { - c.mu.Unlock() - return 0, fmt.Errorf("The value for %s is not an uint64", k) - } - nv := rv + n - v.Object = nv - c.items[k] = v - c.mu.Unlock() - return nv, nil -} - -// Increment an item of type float32 by n. Returns an error if the item's value -// is not an float32, or if it was not found. If there is no error, the -// incremented value is returned. -func (c *cache) IncrementFloat32(k string, n float32) (float32, error) { - c.mu.Lock() - v, found := c.items[k] - if !found || v.Expired() { - c.mu.Unlock() - return 0, fmt.Errorf("Item %s not found", k) - } - rv, ok := v.Object.(float32) - if !ok { - c.mu.Unlock() - return 0, fmt.Errorf("The value for %s is not an float32", k) - } - nv := rv + n - v.Object = nv - c.items[k] = v - c.mu.Unlock() - return nv, nil -} - -// Increment an item of type float64 by n. Returns an error if the item's value -// is not an float64, or if it was not found. If there is no error, the -// incremented value is returned. -func (c *cache) IncrementFloat64(k string, n float64) (float64, error) { - c.mu.Lock() - v, found := c.items[k] - if !found || v.Expired() { - c.mu.Unlock() - return 0, fmt.Errorf("Item %s not found", k) - } - rv, ok := v.Object.(float64) - if !ok { - c.mu.Unlock() - return 0, fmt.Errorf("The value for %s is not an float64", k) - } - nv := rv + n - v.Object = nv - c.items[k] = v - c.mu.Unlock() - return nv, nil -} - -// Decrement an item of type int, int8, int16, int32, int64, uintptr, uint, -// uint8, uint32, or uint64, float32 or float64 by n. Returns an error if the -// item's value is not an integer, if it was not found, or if it is not -// possible to decrement it by n. To retrieve the decremented value, use one -// of the specialized methods, e.g. DecrementInt64. -func (c *cache) Decrement(k string, n int64) error { - // TODO: Implement Increment and Decrement more cleanly. - // (Cannot do Increment(k, n*-1) for uints.) - c.mu.Lock() - v, found := c.items[k] - if !found || v.Expired() { - c.mu.Unlock() - return fmt.Errorf("Item not found") - } - switch v.Object.(type) { - case int: - v.Object = v.Object.(int) - int(n) - case int8: - v.Object = v.Object.(int8) - int8(n) - case int16: - v.Object = v.Object.(int16) - int16(n) - case int32: - v.Object = v.Object.(int32) - int32(n) - case int64: - v.Object = v.Object.(int64) - n - case uint: - v.Object = v.Object.(uint) - uint(n) - case uintptr: - v.Object = v.Object.(uintptr) - uintptr(n) - case uint8: - v.Object = v.Object.(uint8) - uint8(n) - case uint16: - v.Object = v.Object.(uint16) - uint16(n) - case uint32: - v.Object = v.Object.(uint32) - uint32(n) - case uint64: - v.Object = v.Object.(uint64) - uint64(n) - case float32: - v.Object = v.Object.(float32) - float32(n) - case float64: - v.Object = v.Object.(float64) - float64(n) - default: - c.mu.Unlock() - return fmt.Errorf("The value for %s is not an integer", k) - } - c.items[k] = v - c.mu.Unlock() - return nil -} - -// Decrement an item of type float32 or float64 by n. Returns an error if the -// item's value is not floating point, if it was not found, or if it is not -// possible to decrement it by n. Pass a negative number to decrement the -// value. To retrieve the decremented value, use one of the specialized methods, -// e.g. DecrementFloat64. -func (c *cache) DecrementFloat(k string, n float64) error { - c.mu.Lock() - v, found := c.items[k] - if !found || v.Expired() { - c.mu.Unlock() - return fmt.Errorf("Item %s not found", k) - } - switch v.Object.(type) { - case float32: - v.Object = v.Object.(float32) - float32(n) - case float64: - v.Object = v.Object.(float64) - n - default: - c.mu.Unlock() - return fmt.Errorf("The value for %s does not have type float32 or float64", k) - } - c.items[k] = v - c.mu.Unlock() - return nil -} - -// Decrement an item of type int by n. Returns an error if the item's value is -// not an int, or if it was not found. If there is no error, the decremented -// value is returned. -func (c *cache) DecrementInt(k string, n int) (int, error) { - c.mu.Lock() - v, found := c.items[k] - if !found || v.Expired() { - c.mu.Unlock() - return 0, fmt.Errorf("Item %s not found", k) - } - rv, ok := v.Object.(int) - if !ok { - c.mu.Unlock() - return 0, fmt.Errorf("The value for %s is not an int", k) - } - nv := rv - n - v.Object = nv - c.items[k] = v - c.mu.Unlock() - return nv, nil -} - -// Decrement an item of type int8 by n. Returns an error if the item's value is -// not an int8, or if it was not found. If there is no error, the decremented -// value is returned. -func (c *cache) DecrementInt8(k string, n int8) (int8, error) { - c.mu.Lock() - v, found := c.items[k] - if !found || v.Expired() { - c.mu.Unlock() - return 0, fmt.Errorf("Item %s not found", k) - } - rv, ok := v.Object.(int8) - if !ok { - c.mu.Unlock() - return 0, fmt.Errorf("The value for %s is not an int8", k) - } - nv := rv - n - v.Object = nv - c.items[k] = v - c.mu.Unlock() - return nv, nil -} - -// Decrement an item of type int16 by n. Returns an error if the item's value is -// not an int16, or if it was not found. If there is no error, the decremented -// value is returned. -func (c *cache) DecrementInt16(k string, n int16) (int16, error) { - c.mu.Lock() - v, found := c.items[k] - if !found || v.Expired() { - c.mu.Unlock() - return 0, fmt.Errorf("Item %s not found", k) - } - rv, ok := v.Object.(int16) - if !ok { - c.mu.Unlock() - return 0, fmt.Errorf("The value for %s is not an int16", k) - } - nv := rv - n - v.Object = nv - c.items[k] = v - c.mu.Unlock() - return nv, nil -} - -// Decrement an item of type int32 by n. Returns an error if the item's value is -// not an int32, or if it was not found. If there is no error, the decremented -// value is returned. -func (c *cache) DecrementInt32(k string, n int32) (int32, error) { - c.mu.Lock() - v, found := c.items[k] - if !found || v.Expired() { - c.mu.Unlock() - return 0, fmt.Errorf("Item %s not found", k) - } - rv, ok := v.Object.(int32) - if !ok { - c.mu.Unlock() - return 0, fmt.Errorf("The value for %s is not an int32", k) - } - nv := rv - n - v.Object = nv - c.items[k] = v - c.mu.Unlock() - return nv, nil -} - -// Decrement an item of type int64 by n. Returns an error if the item's value is -// not an int64, or if it was not found. If there is no error, the decremented -// value is returned. -func (c *cache) DecrementInt64(k string, n int64) (int64, error) { - c.mu.Lock() - v, found := c.items[k] - if !found || v.Expired() { - c.mu.Unlock() - return 0, fmt.Errorf("Item %s not found", k) - } - rv, ok := v.Object.(int64) - if !ok { - c.mu.Unlock() - return 0, fmt.Errorf("The value for %s is not an int64", k) - } - nv := rv - n - v.Object = nv - c.items[k] = v - c.mu.Unlock() - return nv, nil -} - -// Decrement an item of type uint by n. Returns an error if the item's value is -// not an uint, or if it was not found. If there is no error, the decremented -// value is returned. -func (c *cache) DecrementUint(k string, n uint) (uint, error) { - c.mu.Lock() - v, found := c.items[k] - if !found || v.Expired() { - c.mu.Unlock() - return 0, fmt.Errorf("Item %s not found", k) - } - rv, ok := v.Object.(uint) - if !ok { - c.mu.Unlock() - return 0, fmt.Errorf("The value for %s is not an uint", k) - } - nv := rv - n - v.Object = nv - c.items[k] = v - c.mu.Unlock() - return nv, nil -} - -// Decrement an item of type uintptr by n. Returns an error if the item's value -// is not an uintptr, or if it was not found. If there is no error, the -// decremented value is returned. -func (c *cache) DecrementUintptr(k string, n uintptr) (uintptr, error) { - c.mu.Lock() - v, found := c.items[k] - if !found || v.Expired() { - c.mu.Unlock() - return 0, fmt.Errorf("Item %s not found", k) - } - rv, ok := v.Object.(uintptr) - if !ok { - c.mu.Unlock() - return 0, fmt.Errorf("The value for %s is not an uintptr", k) - } - nv := rv - n - v.Object = nv - c.items[k] = v - c.mu.Unlock() - return nv, nil -} - -// Decrement an item of type uint8 by n. Returns an error if the item's value is -// not an uint8, or if it was not found. If there is no error, the decremented -// value is returned. -func (c *cache) DecrementUint8(k string, n uint8) (uint8, error) { - c.mu.Lock() - v, found := c.items[k] - if !found || v.Expired() { - c.mu.Unlock() - return 0, fmt.Errorf("Item %s not found", k) - } - rv, ok := v.Object.(uint8) - if !ok { - c.mu.Unlock() - return 0, fmt.Errorf("The value for %s is not an uint8", k) - } - nv := rv - n - v.Object = nv - c.items[k] = v - c.mu.Unlock() - return nv, nil -} - -// Decrement an item of type uint16 by n. Returns an error if the item's value -// is not an uint16, or if it was not found. If there is no error, the -// decremented value is returned. -func (c *cache) DecrementUint16(k string, n uint16) (uint16, error) { - c.mu.Lock() - v, found := c.items[k] - if !found || v.Expired() { - c.mu.Unlock() - return 0, fmt.Errorf("Item %s not found", k) - } - rv, ok := v.Object.(uint16) - if !ok { - c.mu.Unlock() - return 0, fmt.Errorf("The value for %s is not an uint16", k) - } - nv := rv - n - v.Object = nv - c.items[k] = v - c.mu.Unlock() - return nv, nil -} - -// Decrement an item of type uint32 by n. Returns an error if the item's value -// is not an uint32, or if it was not found. If there is no error, the -// decremented value is returned. -func (c *cache) DecrementUint32(k string, n uint32) (uint32, error) { - c.mu.Lock() - v, found := c.items[k] - if !found || v.Expired() { - c.mu.Unlock() - return 0, fmt.Errorf("Item %s not found", k) - } - rv, ok := v.Object.(uint32) - if !ok { - c.mu.Unlock() - return 0, fmt.Errorf("The value for %s is not an uint32", k) - } - nv := rv - n - v.Object = nv - c.items[k] = v - c.mu.Unlock() - return nv, nil -} - -// Decrement an item of type uint64 by n. Returns an error if the item's value -// is not an uint64, or if it was not found. If there is no error, the -// decremented value is returned. -func (c *cache) DecrementUint64(k string, n uint64) (uint64, error) { - c.mu.Lock() - v, found := c.items[k] - if !found || v.Expired() { - c.mu.Unlock() - return 0, fmt.Errorf("Item %s not found", k) - } - rv, ok := v.Object.(uint64) - if !ok { - c.mu.Unlock() - return 0, fmt.Errorf("The value for %s is not an uint64", k) - } - nv := rv - n - v.Object = nv - c.items[k] = v - c.mu.Unlock() - return nv, nil -} - -// Decrement an item of type float32 by n. Returns an error if the item's value -// is not an float32, or if it was not found. If there is no error, the -// decremented value is returned. -func (c *cache) DecrementFloat32(k string, n float32) (float32, error) { - c.mu.Lock() - v, found := c.items[k] - if !found || v.Expired() { - c.mu.Unlock() - return 0, fmt.Errorf("Item %s not found", k) - } - rv, ok := v.Object.(float32) - if !ok { - c.mu.Unlock() - return 0, fmt.Errorf("The value for %s is not an float32", k) - } - nv := rv - n - v.Object = nv - c.items[k] = v - c.mu.Unlock() - return nv, nil -} - -// Decrement an item of type float64 by n. Returns an error if the item's value -// is not an float64, or if it was not found. If there is no error, the -// decremented value is returned. -func (c *cache) DecrementFloat64(k string, n float64) (float64, error) { - c.mu.Lock() - v, found := c.items[k] - if !found || v.Expired() { - c.mu.Unlock() - return 0, fmt.Errorf("Item %s not found", k) - } - rv, ok := v.Object.(float64) - if !ok { - c.mu.Unlock() - return 0, fmt.Errorf("The value for %s is not an float64", k) - } - nv := rv - n - v.Object = nv - c.items[k] = v - c.mu.Unlock() - return nv, nil -} - -// Delete an item from the cache. Does nothing if the key is not in the cache. -func (c *cache) Delete(k string) { - c.mu.Lock() - v, evicted := c.delete(k) - c.mu.Unlock() - if evicted { - c.onEvicted(k, v) - } -} - -func (c *cache) delete(k string) (interface{}, bool) { - if c.onEvicted != nil { - if v, found := c.items[k]; found { - delete(c.items, k) - return v.Object, true - } - } - delete(c.items, k) - return nil, false -} - -type keyAndValue struct { - key string - value interface{} -} - -// Delete all expired items from the cache. -func (c *cache) DeleteExpired() { - var evictedItems []keyAndValue - now := time.Now().UnixNano() - c.mu.Lock() - for k, v := range c.items { - // "Inlining" of expired - if v.Expiration > 0 && now > v.Expiration { - ov, evicted := c.delete(k) - if evicted { - evictedItems = append(evictedItems, keyAndValue{k, ov}) - } - } - } - c.mu.Unlock() - for _, v := range evictedItems { - c.onEvicted(v.key, v.value) - } -} - -// Sets an (optional) function that is called with the key and value when an -// item is evicted from the cache. (Including when it is deleted manually, but -// not when it is overwritten.) Set to nil to disable. -func (c *cache) OnEvicted(f func(string, interface{})) { - c.mu.Lock() - c.onEvicted = f - c.mu.Unlock() -} - -// Write the cache's items (using Gob) to an io.Writer. -// -// NOTE: This method is deprecated in favor of c.Items() and NewFrom() (see the -// documentation for NewFrom().) -func (c *cache) Save(w io.Writer) (err error) { - enc := gob.NewEncoder(w) - defer func() { - if x := recover(); x != nil { - err = fmt.Errorf("Error registering item types with Gob library") - } - }() - c.mu.RLock() - defer c.mu.RUnlock() - for _, v := range c.items { - gob.Register(v.Object) - } - err = enc.Encode(&c.items) - return -} - -// Save the cache's items to the given filename, creating the file if it -// doesn't exist, and overwriting it if it does. -// -// NOTE: This method is deprecated in favor of c.Items() and NewFrom() (see the -// documentation for NewFrom().) -func (c *cache) SaveFile(fname string) error { - fp, err := os.Create(fname) - if err != nil { - return err - } - err = c.Save(fp) - if err != nil { - fp.Close() - return err - } - return fp.Close() -} - -// Add (Gob-serialized) cache items from an io.Reader, excluding any items with -// keys that already exist (and haven't expired) in the current cache. -// -// NOTE: This method is deprecated in favor of c.Items() and NewFrom() (see the -// documentation for NewFrom().) -func (c *cache) Load(r io.Reader) error { - dec := gob.NewDecoder(r) - items := map[string]Item{} - err := dec.Decode(&items) - if err == nil { - c.mu.Lock() - defer c.mu.Unlock() - for k, v := range items { - ov, found := c.items[k] - if !found || ov.Expired() { - c.items[k] = v - } - } - } - return err -} - -// Load and add cache items from the given filename, excluding any items with -// keys that already exist in the current cache. -// -// NOTE: This method is deprecated in favor of c.Items() and NewFrom() (see the -// documentation for NewFrom().) -func (c *cache) LoadFile(fname string) error { - fp, err := os.Open(fname) - if err != nil { - return err - } - err = c.Load(fp) - if err != nil { - fp.Close() - return err - } - return fp.Close() -} - -// Copies all unexpired items in the cache into a new map and returns it. -func (c *cache) Items() map[string]Item { - c.mu.RLock() - defer c.mu.RUnlock() - m := make(map[string]Item, len(c.items)) - now := time.Now().UnixNano() - for k, v := range c.items { - // "Inlining" of Expired - if v.Expiration > 0 { - if now > v.Expiration { - continue - } - } - m[k] = v - } - return m -} - -// Returns the number of items in the cache. This may include items that have -// expired, but have not yet been cleaned up. -func (c *cache) ItemCount() int { - c.mu.RLock() - n := len(c.items) - c.mu.RUnlock() - return n -} - -// Delete all items from the cache. -func (c *cache) Flush() { - c.mu.Lock() - c.items = map[string]Item{} - c.mu.Unlock() -} - -type janitor struct { - Interval time.Duration - stop chan bool -} - -func (j *janitor) Run(c *cache) { - ticker := time.NewTicker(j.Interval) - for { - select { - case <-ticker.C: - c.DeleteExpired() - case <-j.stop: - ticker.Stop() - return - } - } -} - -func stopJanitor(c *Cache) { - c.janitor.stop <- true -} - -func runJanitor(c *cache, ci time.Duration) { - j := &janitor{ - Interval: ci, - stop: make(chan bool), - } - c.janitor = j - go j.Run(c) -} - -func newCache(de time.Duration, m map[string]Item) *cache { - if de == 0 { - de = -1 - } - c := &cache{ - defaultExpiration: de, - items: m, - } - return c -} - -func newCacheWithJanitor(de time.Duration, ci time.Duration, m map[string]Item) *Cache { - c := newCache(de, m) - // This trick ensures that the janitor goroutine (which--granted it - // was enabled--is running DeleteExpired on c forever) does not keep - // the returned C object from being garbage collected. When it is - // garbage collected, the finalizer stops the janitor goroutine, after - // which c can be collected. - C := &Cache{c} - if ci > 0 { - runJanitor(c, ci) - runtime.SetFinalizer(C, stopJanitor) - } - return C -} - -// Return a new cache with a given default expiration duration and cleanup -// interval. If the expiration duration is less than one (or NoExpiration), -// the items in the cache never expire (by default), and must be deleted -// manually. If the cleanup interval is less than one, expired items are not -// deleted from the cache before calling c.DeleteExpired(). -func New(defaultExpiration, cleanupInterval time.Duration) *Cache { - items := make(map[string]Item) - return newCacheWithJanitor(defaultExpiration, cleanupInterval, items) -} - -// Return a new cache with a given default expiration duration and cleanup -// interval. If the expiration duration is less than one (or NoExpiration), -// the items in the cache never expire (by default), and must be deleted -// manually. If the cleanup interval is less than one, expired items are not -// deleted from the cache before calling c.DeleteExpired(). -// -// NewFrom() also accepts an items map which will serve as the underlying map -// for the cache. This is useful for starting from a deserialized cache -// (serialized using e.g. gob.Encode() on c.Items()), or passing in e.g. -// make(map[string]Item, 500) to improve startup performance when the cache -// is expected to reach a certain minimum size. -// -// Only the cache's methods synchronize access to this map, so it is not -// recommended to keep any references to the map around after creating a cache. -// If need be, the map can be accessed at a later point using c.Items() (subject -// to the same caveat.) -// -// Note regarding serialization: When using e.g. gob, make sure to -// gob.Register() the individual types stored in the cache before encoding a -// map retrieved with c.Items(), and to register those same types before -// decoding a blob containing an items map. -func NewFrom(defaultExpiration, cleanupInterval time.Duration, items map[string]Item) *Cache { - return newCacheWithJanitor(defaultExpiration, cleanupInterval, items) -} diff --git a/old/cache_test.go b/old/cache_test.go deleted file mode 100644 index 9233a0d..0000000 --- a/old/cache_test.go +++ /dev/null @@ -1,1771 +0,0 @@ -package old - -import ( - "bytes" - "io/ioutil" - "runtime" - "strconv" - "sync" - "testing" - "time" -) - -type TestStruct struct { - Num int - Children []*TestStruct -} - -func TestCache(t *testing.T) { - tc := New(DefaultExpiration, 0) - - a, found := tc.Get("a") - if found || a != nil { - t.Error("Getting A found value that shouldn't exist:", a) - } - - b, found := tc.Get("b") - if found || b != nil { - t.Error("Getting B found value that shouldn't exist:", b) - } - - c, found := tc.Get("c") - if found || c != nil { - t.Error("Getting C found value that shouldn't exist:", c) - } - - tc.Set("a", 1, DefaultExpiration) - tc.Set("b", "b", DefaultExpiration) - tc.Set("c", 3.5, DefaultExpiration) - - x, found := tc.Get("a") - if !found { - t.Error("a was not found while getting a2") - } - if x == nil { - t.Error("x for a is nil") - } else if a2 := x.(int); a2+2 != 3 { - t.Error("a2 (which should be 1) plus 2 does not equal 3; value:", a2) - } - - x, found = tc.Get("b") - if !found { - t.Error("b was not found while getting b2") - } - if x == nil { - t.Error("x for b is nil") - } else if b2 := x.(string); b2+"B" != "bB" { - t.Error("b2 (which should be b) plus B does not equal bB; value:", b2) - } - - x, found = tc.Get("c") - if !found { - t.Error("c was not found while getting c2") - } - if x == nil { - t.Error("x for c is nil") - } else if c2 := x.(float64); c2+1.2 != 4.7 { - t.Error("c2 (which should be 3.5) plus 1.2 does not equal 4.7; value:", c2) - } -} - -func TestCacheTimes(t *testing.T) { - var found bool - - tc := New(50*time.Millisecond, 1*time.Millisecond) - tc.Set("a", 1, DefaultExpiration) - tc.Set("b", 2, NoExpiration) - tc.Set("c", 3, 20*time.Millisecond) - tc.Set("d", 4, 70*time.Millisecond) - - <-time.After(25 * time.Millisecond) - _, found = tc.Get("c") - if found { - t.Error("Found c when it should have been automatically deleted") - } - - <-time.After(30 * time.Millisecond) - _, found = tc.Get("a") - if found { - t.Error("Found a when it should have been automatically deleted") - } - - _, found = tc.Get("b") - if !found { - t.Error("Did not find b even though it was set to never expire") - } - - _, found = tc.Get("d") - if !found { - t.Error("Did not find d even though it was set to expire later than the default") - } - - <-time.After(20 * time.Millisecond) - _, found = tc.Get("d") - if found { - t.Error("Found d when it should have been automatically deleted (later than the default)") - } -} - -func TestNewFrom(t *testing.T) { - m := map[string]Item{ - "a": Item{ - Object: 1, - Expiration: 0, - }, - "b": Item{ - Object: 2, - Expiration: 0, - }, - } - tc := NewFrom(DefaultExpiration, 0, m) - a, found := tc.Get("a") - if !found { - t.Fatal("Did not find a") - } - if a.(int) != 1 { - t.Fatal("a is not 1") - } - b, found := tc.Get("b") - if !found { - t.Fatal("Did not find b") - } - if b.(int) != 2 { - t.Fatal("b is not 2") - } -} - -func TestStorePointerToStruct(t *testing.T) { - tc := New(DefaultExpiration, 0) - tc.Set("foo", &TestStruct{Num: 1}, DefaultExpiration) - x, found := tc.Get("foo") - if !found { - t.Fatal("*TestStruct was not found for foo") - } - foo := x.(*TestStruct) - foo.Num++ - - y, found := tc.Get("foo") - if !found { - t.Fatal("*TestStruct was not found for foo (second time)") - } - bar := y.(*TestStruct) - if bar.Num != 2 { - t.Fatal("TestStruct.Num is not 2") - } -} - -func TestIncrementWithInt(t *testing.T) { - tc := New(DefaultExpiration, 0) - tc.Set("tint", 1, DefaultExpiration) - err := tc.Increment("tint", 2) - if err != nil { - t.Error("Error incrementing:", err) - } - x, found := tc.Get("tint") - if !found { - t.Error("tint was not found") - } - if x.(int) != 3 { - t.Error("tint is not 3:", x) - } -} - -func TestIncrementWithInt8(t *testing.T) { - tc := New(DefaultExpiration, 0) - tc.Set("tint8", int8(1), DefaultExpiration) - err := tc.Increment("tint8", 2) - if err != nil { - t.Error("Error incrementing:", err) - } - x, found := tc.Get("tint8") - if !found { - t.Error("tint8 was not found") - } - if x.(int8) != 3 { - t.Error("tint8 is not 3:", x) - } -} - -func TestIncrementWithInt16(t *testing.T) { - tc := New(DefaultExpiration, 0) - tc.Set("tint16", int16(1), DefaultExpiration) - err := tc.Increment("tint16", 2) - if err != nil { - t.Error("Error incrementing:", err) - } - x, found := tc.Get("tint16") - if !found { - t.Error("tint16 was not found") - } - if x.(int16) != 3 { - t.Error("tint16 is not 3:", x) - } -} - -func TestIncrementWithInt32(t *testing.T) { - tc := New(DefaultExpiration, 0) - tc.Set("tint32", int32(1), DefaultExpiration) - err := tc.Increment("tint32", 2) - if err != nil { - t.Error("Error incrementing:", err) - } - x, found := tc.Get("tint32") - if !found { - t.Error("tint32 was not found") - } - if x.(int32) != 3 { - t.Error("tint32 is not 3:", x) - } -} - -func TestIncrementWithInt64(t *testing.T) { - tc := New(DefaultExpiration, 0) - tc.Set("tint64", int64(1), DefaultExpiration) - err := tc.Increment("tint64", 2) - if err != nil { - t.Error("Error incrementing:", err) - } - x, found := tc.Get("tint64") - if !found { - t.Error("tint64 was not found") - } - if x.(int64) != 3 { - t.Error("tint64 is not 3:", x) - } -} - -func TestIncrementWithUint(t *testing.T) { - tc := New(DefaultExpiration, 0) - tc.Set("tuint", uint(1), DefaultExpiration) - err := tc.Increment("tuint", 2) - if err != nil { - t.Error("Error incrementing:", err) - } - x, found := tc.Get("tuint") - if !found { - t.Error("tuint was not found") - } - if x.(uint) != 3 { - t.Error("tuint is not 3:", x) - } -} - -func TestIncrementWithUintptr(t *testing.T) { - tc := New(DefaultExpiration, 0) - tc.Set("tuintptr", uintptr(1), DefaultExpiration) - err := tc.Increment("tuintptr", 2) - if err != nil { - t.Error("Error incrementing:", err) - } - - x, found := tc.Get("tuintptr") - if !found { - t.Error("tuintptr was not found") - } - if x.(uintptr) != 3 { - t.Error("tuintptr is not 3:", x) - } -} - -func TestIncrementWithUint8(t *testing.T) { - tc := New(DefaultExpiration, 0) - tc.Set("tuint8", uint8(1), DefaultExpiration) - err := tc.Increment("tuint8", 2) - if err != nil { - t.Error("Error incrementing:", err) - } - x, found := tc.Get("tuint8") - if !found { - t.Error("tuint8 was not found") - } - if x.(uint8) != 3 { - t.Error("tuint8 is not 3:", x) - } -} - -func TestIncrementWithUint16(t *testing.T) { - tc := New(DefaultExpiration, 0) - tc.Set("tuint16", uint16(1), DefaultExpiration) - err := tc.Increment("tuint16", 2) - if err != nil { - t.Error("Error incrementing:", err) - } - - x, found := tc.Get("tuint16") - if !found { - t.Error("tuint16 was not found") - } - if x.(uint16) != 3 { - t.Error("tuint16 is not 3:", x) - } -} - -func TestIncrementWithUint32(t *testing.T) { - tc := New(DefaultExpiration, 0) - tc.Set("tuint32", uint32(1), DefaultExpiration) - err := tc.Increment("tuint32", 2) - if err != nil { - t.Error("Error incrementing:", err) - } - x, found := tc.Get("tuint32") - if !found { - t.Error("tuint32 was not found") - } - if x.(uint32) != 3 { - t.Error("tuint32 is not 3:", x) - } -} - -func TestIncrementWithUint64(t *testing.T) { - tc := New(DefaultExpiration, 0) - tc.Set("tuint64", uint64(1), DefaultExpiration) - err := tc.Increment("tuint64", 2) - if err != nil { - t.Error("Error incrementing:", err) - } - - x, found := tc.Get("tuint64") - if !found { - t.Error("tuint64 was not found") - } - if x.(uint64) != 3 { - t.Error("tuint64 is not 3:", x) - } -} - -func TestIncrementWithFloat32(t *testing.T) { - tc := New(DefaultExpiration, 0) - tc.Set("float32", float32(1.5), DefaultExpiration) - err := tc.Increment("float32", 2) - if err != nil { - t.Error("Error incrementing:", err) - } - x, found := tc.Get("float32") - if !found { - t.Error("float32 was not found") - } - if x.(float32) != 3.5 { - t.Error("float32 is not 3.5:", x) - } -} - -func TestIncrementWithFloat64(t *testing.T) { - tc := New(DefaultExpiration, 0) - tc.Set("float64", float64(1.5), DefaultExpiration) - err := tc.Increment("float64", 2) - if err != nil { - t.Error("Error incrementing:", err) - } - x, found := tc.Get("float64") - if !found { - t.Error("float64 was not found") - } - if x.(float64) != 3.5 { - t.Error("float64 is not 3.5:", x) - } -} - -func TestIncrementFloatWithFloat32(t *testing.T) { - tc := New(DefaultExpiration, 0) - tc.Set("float32", float32(1.5), DefaultExpiration) - err := tc.IncrementFloat("float32", 2) - if err != nil { - t.Error("Error incrementfloating:", err) - } - x, found := tc.Get("float32") - if !found { - t.Error("float32 was not found") - } - if x.(float32) != 3.5 { - t.Error("float32 is not 3.5:", x) - } -} - -func TestIncrementFloatWithFloat64(t *testing.T) { - tc := New(DefaultExpiration, 0) - tc.Set("float64", float64(1.5), DefaultExpiration) - err := tc.IncrementFloat("float64", 2) - if err != nil { - t.Error("Error incrementfloating:", err) - } - x, found := tc.Get("float64") - if !found { - t.Error("float64 was not found") - } - if x.(float64) != 3.5 { - t.Error("float64 is not 3.5:", x) - } -} - -func TestDecrementWithInt(t *testing.T) { - tc := New(DefaultExpiration, 0) - tc.Set("int", int(5), DefaultExpiration) - err := tc.Decrement("int", 2) - if err != nil { - t.Error("Error decrementing:", err) - } - x, found := tc.Get("int") - if !found { - t.Error("int was not found") - } - if x.(int) != 3 { - t.Error("int is not 3:", x) - } -} - -func TestDecrementWithInt8(t *testing.T) { - tc := New(DefaultExpiration, 0) - tc.Set("int8", int8(5), DefaultExpiration) - err := tc.Decrement("int8", 2) - if err != nil { - t.Error("Error decrementing:", err) - } - x, found := tc.Get("int8") - if !found { - t.Error("int8 was not found") - } - if x.(int8) != 3 { - t.Error("int8 is not 3:", x) - } -} - -func TestDecrementWithInt16(t *testing.T) { - tc := New(DefaultExpiration, 0) - tc.Set("int16", int16(5), DefaultExpiration) - err := tc.Decrement("int16", 2) - if err != nil { - t.Error("Error decrementing:", err) - } - x, found := tc.Get("int16") - if !found { - t.Error("int16 was not found") - } - if x.(int16) != 3 { - t.Error("int16 is not 3:", x) - } -} - -func TestDecrementWithInt32(t *testing.T) { - tc := New(DefaultExpiration, 0) - tc.Set("int32", int32(5), DefaultExpiration) - err := tc.Decrement("int32", 2) - if err != nil { - t.Error("Error decrementing:", err) - } - x, found := tc.Get("int32") - if !found { - t.Error("int32 was not found") - } - if x.(int32) != 3 { - t.Error("int32 is not 3:", x) - } -} - -func TestDecrementWithInt64(t *testing.T) { - tc := New(DefaultExpiration, 0) - tc.Set("int64", int64(5), DefaultExpiration) - err := tc.Decrement("int64", 2) - if err != nil { - t.Error("Error decrementing:", err) - } - x, found := tc.Get("int64") - if !found { - t.Error("int64 was not found") - } - if x.(int64) != 3 { - t.Error("int64 is not 3:", x) - } -} - -func TestDecrementWithUint(t *testing.T) { - tc := New(DefaultExpiration, 0) - tc.Set("uint", uint(5), DefaultExpiration) - err := tc.Decrement("uint", 2) - if err != nil { - t.Error("Error decrementing:", err) - } - x, found := tc.Get("uint") - if !found { - t.Error("uint was not found") - } - if x.(uint) != 3 { - t.Error("uint is not 3:", x) - } -} - -func TestDecrementWithUintptr(t *testing.T) { - tc := New(DefaultExpiration, 0) - tc.Set("uintptr", uintptr(5), DefaultExpiration) - err := tc.Decrement("uintptr", 2) - if err != nil { - t.Error("Error decrementing:", err) - } - x, found := tc.Get("uintptr") - if !found { - t.Error("uintptr was not found") - } - if x.(uintptr) != 3 { - t.Error("uintptr is not 3:", x) - } -} - -func TestDecrementWithUint8(t *testing.T) { - tc := New(DefaultExpiration, 0) - tc.Set("uint8", uint8(5), DefaultExpiration) - err := tc.Decrement("uint8", 2) - if err != nil { - t.Error("Error decrementing:", err) - } - x, found := tc.Get("uint8") - if !found { - t.Error("uint8 was not found") - } - if x.(uint8) != 3 { - t.Error("uint8 is not 3:", x) - } -} - -func TestDecrementWithUint16(t *testing.T) { - tc := New(DefaultExpiration, 0) - tc.Set("uint16", uint16(5), DefaultExpiration) - err := tc.Decrement("uint16", 2) - if err != nil { - t.Error("Error decrementing:", err) - } - x, found := tc.Get("uint16") - if !found { - t.Error("uint16 was not found") - } - if x.(uint16) != 3 { - t.Error("uint16 is not 3:", x) - } -} - -func TestDecrementWithUint32(t *testing.T) { - tc := New(DefaultExpiration, 0) - tc.Set("uint32", uint32(5), DefaultExpiration) - err := tc.Decrement("uint32", 2) - if err != nil { - t.Error("Error decrementing:", err) - } - x, found := tc.Get("uint32") - if !found { - t.Error("uint32 was not found") - } - if x.(uint32) != 3 { - t.Error("uint32 is not 3:", x) - } -} - -func TestDecrementWithUint64(t *testing.T) { - tc := New(DefaultExpiration, 0) - tc.Set("uint64", uint64(5), DefaultExpiration) - err := tc.Decrement("uint64", 2) - if err != nil { - t.Error("Error decrementing:", err) - } - x, found := tc.Get("uint64") - if !found { - t.Error("uint64 was not found") - } - if x.(uint64) != 3 { - t.Error("uint64 is not 3:", x) - } -} - -func TestDecrementWithFloat32(t *testing.T) { - tc := New(DefaultExpiration, 0) - tc.Set("float32", float32(5.5), DefaultExpiration) - err := tc.Decrement("float32", 2) - if err != nil { - t.Error("Error decrementing:", err) - } - x, found := tc.Get("float32") - if !found { - t.Error("float32 was not found") - } - if x.(float32) != 3.5 { - t.Error("float32 is not 3:", x) - } -} - -func TestDecrementWithFloat64(t *testing.T) { - tc := New(DefaultExpiration, 0) - tc.Set("float64", float64(5.5), DefaultExpiration) - err := tc.Decrement("float64", 2) - if err != nil { - t.Error("Error decrementing:", err) - } - x, found := tc.Get("float64") - if !found { - t.Error("float64 was not found") - } - if x.(float64) != 3.5 { - t.Error("float64 is not 3:", x) - } -} - -func TestDecrementFloatWithFloat32(t *testing.T) { - tc := New(DefaultExpiration, 0) - tc.Set("float32", float32(5.5), DefaultExpiration) - err := tc.DecrementFloat("float32", 2) - if err != nil { - t.Error("Error decrementing:", err) - } - x, found := tc.Get("float32") - if !found { - t.Error("float32 was not found") - } - if x.(float32) != 3.5 { - t.Error("float32 is not 3:", x) - } -} - -func TestDecrementFloatWithFloat64(t *testing.T) { - tc := New(DefaultExpiration, 0) - tc.Set("float64", float64(5.5), DefaultExpiration) - err := tc.DecrementFloat("float64", 2) - if err != nil { - t.Error("Error decrementing:", err) - } - x, found := tc.Get("float64") - if !found { - t.Error("float64 was not found") - } - if x.(float64) != 3.5 { - t.Error("float64 is not 3:", x) - } -} - -func TestIncrementInt(t *testing.T) { - tc := New(DefaultExpiration, 0) - tc.Set("tint", 1, DefaultExpiration) - n, err := tc.IncrementInt("tint", 2) - if err != nil { - t.Error("Error incrementing:", err) - } - if n != 3 { - t.Error("Returned number is not 3:", n) - } - x, found := tc.Get("tint") - if !found { - t.Error("tint was not found") - } - if x.(int) != 3 { - t.Error("tint is not 3:", x) - } -} - -func TestIncrementInt8(t *testing.T) { - tc := New(DefaultExpiration, 0) - tc.Set("tint8", int8(1), DefaultExpiration) - n, err := tc.IncrementInt8("tint8", 2) - if err != nil { - t.Error("Error incrementing:", err) - } - if n != 3 { - t.Error("Returned number is not 3:", n) - } - x, found := tc.Get("tint8") - if !found { - t.Error("tint8 was not found") - } - if x.(int8) != 3 { - t.Error("tint8 is not 3:", x) - } -} - -func TestIncrementInt16(t *testing.T) { - tc := New(DefaultExpiration, 0) - tc.Set("tint16", int16(1), DefaultExpiration) - n, err := tc.IncrementInt16("tint16", 2) - if err != nil { - t.Error("Error incrementing:", err) - } - if n != 3 { - t.Error("Returned number is not 3:", n) - } - x, found := tc.Get("tint16") - if !found { - t.Error("tint16 was not found") - } - if x.(int16) != 3 { - t.Error("tint16 is not 3:", x) - } -} - -func TestIncrementInt32(t *testing.T) { - tc := New(DefaultExpiration, 0) - tc.Set("tint32", int32(1), DefaultExpiration) - n, err := tc.IncrementInt32("tint32", 2) - if err != nil { - t.Error("Error incrementing:", err) - } - if n != 3 { - t.Error("Returned number is not 3:", n) - } - x, found := tc.Get("tint32") - if !found { - t.Error("tint32 was not found") - } - if x.(int32) != 3 { - t.Error("tint32 is not 3:", x) - } -} - -func TestIncrementInt64(t *testing.T) { - tc := New(DefaultExpiration, 0) - tc.Set("tint64", int64(1), DefaultExpiration) - n, err := tc.IncrementInt64("tint64", 2) - if err != nil { - t.Error("Error incrementing:", err) - } - if n != 3 { - t.Error("Returned number is not 3:", n) - } - x, found := tc.Get("tint64") - if !found { - t.Error("tint64 was not found") - } - if x.(int64) != 3 { - t.Error("tint64 is not 3:", x) - } -} - -func TestIncrementUint(t *testing.T) { - tc := New(DefaultExpiration, 0) - tc.Set("tuint", uint(1), DefaultExpiration) - n, err := tc.IncrementUint("tuint", 2) - if err != nil { - t.Error("Error incrementing:", err) - } - if n != 3 { - t.Error("Returned number is not 3:", n) - } - x, found := tc.Get("tuint") - if !found { - t.Error("tuint was not found") - } - if x.(uint) != 3 { - t.Error("tuint is not 3:", x) - } -} - -func TestIncrementUintptr(t *testing.T) { - tc := New(DefaultExpiration, 0) - tc.Set("tuintptr", uintptr(1), DefaultExpiration) - n, err := tc.IncrementUintptr("tuintptr", 2) - if err != nil { - t.Error("Error incrementing:", err) - } - if n != 3 { - t.Error("Returned number is not 3:", n) - } - x, found := tc.Get("tuintptr") - if !found { - t.Error("tuintptr was not found") - } - if x.(uintptr) != 3 { - t.Error("tuintptr is not 3:", x) - } -} - -func TestIncrementUint8(t *testing.T) { - tc := New(DefaultExpiration, 0) - tc.Set("tuint8", uint8(1), DefaultExpiration) - n, err := tc.IncrementUint8("tuint8", 2) - if err != nil { - t.Error("Error incrementing:", err) - } - if n != 3 { - t.Error("Returned number is not 3:", n) - } - x, found := tc.Get("tuint8") - if !found { - t.Error("tuint8 was not found") - } - if x.(uint8) != 3 { - t.Error("tuint8 is not 3:", x) - } -} - -func TestIncrementUint16(t *testing.T) { - tc := New(DefaultExpiration, 0) - tc.Set("tuint16", uint16(1), DefaultExpiration) - n, err := tc.IncrementUint16("tuint16", 2) - if err != nil { - t.Error("Error incrementing:", err) - } - if n != 3 { - t.Error("Returned number is not 3:", n) - } - x, found := tc.Get("tuint16") - if !found { - t.Error("tuint16 was not found") - } - if x.(uint16) != 3 { - t.Error("tuint16 is not 3:", x) - } -} - -func TestIncrementUint32(t *testing.T) { - tc := New(DefaultExpiration, 0) - tc.Set("tuint32", uint32(1), DefaultExpiration) - n, err := tc.IncrementUint32("tuint32", 2) - if err != nil { - t.Error("Error incrementing:", err) - } - if n != 3 { - t.Error("Returned number is not 3:", n) - } - x, found := tc.Get("tuint32") - if !found { - t.Error("tuint32 was not found") - } - if x.(uint32) != 3 { - t.Error("tuint32 is not 3:", x) - } -} - -func TestIncrementUint64(t *testing.T) { - tc := New(DefaultExpiration, 0) - tc.Set("tuint64", uint64(1), DefaultExpiration) - n, err := tc.IncrementUint64("tuint64", 2) - if err != nil { - t.Error("Error incrementing:", err) - } - if n != 3 { - t.Error("Returned number is not 3:", n) - } - x, found := tc.Get("tuint64") - if !found { - t.Error("tuint64 was not found") - } - if x.(uint64) != 3 { - t.Error("tuint64 is not 3:", x) - } -} - -func TestIncrementFloat32(t *testing.T) { - tc := New(DefaultExpiration, 0) - tc.Set("float32", float32(1.5), DefaultExpiration) - n, err := tc.IncrementFloat32("float32", 2) - if err != nil { - t.Error("Error incrementing:", err) - } - if n != 3.5 { - t.Error("Returned number is not 3.5:", n) - } - x, found := tc.Get("float32") - if !found { - t.Error("float32 was not found") - } - if x.(float32) != 3.5 { - t.Error("float32 is not 3.5:", x) - } -} - -func TestIncrementFloat64(t *testing.T) { - tc := New(DefaultExpiration, 0) - tc.Set("float64", float64(1.5), DefaultExpiration) - n, err := tc.IncrementFloat64("float64", 2) - if err != nil { - t.Error("Error incrementing:", err) - } - if n != 3.5 { - t.Error("Returned number is not 3.5:", n) - } - x, found := tc.Get("float64") - if !found { - t.Error("float64 was not found") - } - if x.(float64) != 3.5 { - t.Error("float64 is not 3.5:", x) - } -} - -func TestDecrementInt8(t *testing.T) { - tc := New(DefaultExpiration, 0) - tc.Set("int8", int8(5), DefaultExpiration) - n, err := tc.DecrementInt8("int8", 2) - if err != nil { - t.Error("Error decrementing:", err) - } - if n != 3 { - t.Error("Returned number is not 3:", n) - } - x, found := tc.Get("int8") - if !found { - t.Error("int8 was not found") - } - if x.(int8) != 3 { - t.Error("int8 is not 3:", x) - } -} - -func TestDecrementInt16(t *testing.T) { - tc := New(DefaultExpiration, 0) - tc.Set("int16", int16(5), DefaultExpiration) - n, err := tc.DecrementInt16("int16", 2) - if err != nil { - t.Error("Error decrementing:", err) - } - if n != 3 { - t.Error("Returned number is not 3:", n) - } - x, found := tc.Get("int16") - if !found { - t.Error("int16 was not found") - } - if x.(int16) != 3 { - t.Error("int16 is not 3:", x) - } -} - -func TestDecrementInt32(t *testing.T) { - tc := New(DefaultExpiration, 0) - tc.Set("int32", int32(5), DefaultExpiration) - n, err := tc.DecrementInt32("int32", 2) - if err != nil { - t.Error("Error decrementing:", err) - } - if n != 3 { - t.Error("Returned number is not 3:", n) - } - x, found := tc.Get("int32") - if !found { - t.Error("int32 was not found") - } - if x.(int32) != 3 { - t.Error("int32 is not 3:", x) - } -} - -func TestDecrementInt64(t *testing.T) { - tc := New(DefaultExpiration, 0) - tc.Set("int64", int64(5), DefaultExpiration) - n, err := tc.DecrementInt64("int64", 2) - if err != nil { - t.Error("Error decrementing:", err) - } - if n != 3 { - t.Error("Returned number is not 3:", n) - } - x, found := tc.Get("int64") - if !found { - t.Error("int64 was not found") - } - if x.(int64) != 3 { - t.Error("int64 is not 3:", x) - } -} - -func TestDecrementUint(t *testing.T) { - tc := New(DefaultExpiration, 0) - tc.Set("uint", uint(5), DefaultExpiration) - n, err := tc.DecrementUint("uint", 2) - if err != nil { - t.Error("Error decrementing:", err) - } - if n != 3 { - t.Error("Returned number is not 3:", n) - } - x, found := tc.Get("uint") - if !found { - t.Error("uint was not found") - } - if x.(uint) != 3 { - t.Error("uint is not 3:", x) - } -} - -func TestDecrementUintptr(t *testing.T) { - tc := New(DefaultExpiration, 0) - tc.Set("uintptr", uintptr(5), DefaultExpiration) - n, err := tc.DecrementUintptr("uintptr", 2) - if err != nil { - t.Error("Error decrementing:", err) - } - if n != 3 { - t.Error("Returned number is not 3:", n) - } - x, found := tc.Get("uintptr") - if !found { - t.Error("uintptr was not found") - } - if x.(uintptr) != 3 { - t.Error("uintptr is not 3:", x) - } -} - -func TestDecrementUint8(t *testing.T) { - tc := New(DefaultExpiration, 0) - tc.Set("uint8", uint8(5), DefaultExpiration) - n, err := tc.DecrementUint8("uint8", 2) - if err != nil { - t.Error("Error decrementing:", err) - } - if n != 3 { - t.Error("Returned number is not 3:", n) - } - x, found := tc.Get("uint8") - if !found { - t.Error("uint8 was not found") - } - if x.(uint8) != 3 { - t.Error("uint8 is not 3:", x) - } -} - -func TestDecrementUint16(t *testing.T) { - tc := New(DefaultExpiration, 0) - tc.Set("uint16", uint16(5), DefaultExpiration) - n, err := tc.DecrementUint16("uint16", 2) - if err != nil { - t.Error("Error decrementing:", err) - } - if n != 3 { - t.Error("Returned number is not 3:", n) - } - x, found := tc.Get("uint16") - if !found { - t.Error("uint16 was not found") - } - if x.(uint16) != 3 { - t.Error("uint16 is not 3:", x) - } -} - -func TestDecrementUint32(t *testing.T) { - tc := New(DefaultExpiration, 0) - tc.Set("uint32", uint32(5), DefaultExpiration) - n, err := tc.DecrementUint32("uint32", 2) - if err != nil { - t.Error("Error decrementing:", err) - } - if n != 3 { - t.Error("Returned number is not 3:", n) - } - x, found := tc.Get("uint32") - if !found { - t.Error("uint32 was not found") - } - if x.(uint32) != 3 { - t.Error("uint32 is not 3:", x) - } -} - -func TestDecrementUint64(t *testing.T) { - tc := New(DefaultExpiration, 0) - tc.Set("uint64", uint64(5), DefaultExpiration) - n, err := tc.DecrementUint64("uint64", 2) - if err != nil { - t.Error("Error decrementing:", err) - } - if n != 3 { - t.Error("Returned number is not 3:", n) - } - x, found := tc.Get("uint64") - if !found { - t.Error("uint64 was not found") - } - if x.(uint64) != 3 { - t.Error("uint64 is not 3:", x) - } -} - -func TestDecrementFloat32(t *testing.T) { - tc := New(DefaultExpiration, 0) - tc.Set("float32", float32(5), DefaultExpiration) - n, err := tc.DecrementFloat32("float32", 2) - if err != nil { - t.Error("Error decrementing:", err) - } - if n != 3 { - t.Error("Returned number is not 3:", n) - } - x, found := tc.Get("float32") - if !found { - t.Error("float32 was not found") - } - if x.(float32) != 3 { - t.Error("float32 is not 3:", x) - } -} - -func TestDecrementFloat64(t *testing.T) { - tc := New(DefaultExpiration, 0) - tc.Set("float64", float64(5), DefaultExpiration) - n, err := tc.DecrementFloat64("float64", 2) - if err != nil { - t.Error("Error decrementing:", err) - } - if n != 3 { - t.Error("Returned number is not 3:", n) - } - x, found := tc.Get("float64") - if !found { - t.Error("float64 was not found") - } - if x.(float64) != 3 { - t.Error("float64 is not 3:", x) - } -} - -func TestAdd(t *testing.T) { - tc := New(DefaultExpiration, 0) - err := tc.Add("foo", "bar", DefaultExpiration) - if err != nil { - t.Error("Couldn't add foo even though it shouldn't exist") - } - err = tc.Add("foo", "baz", DefaultExpiration) - if err == nil { - t.Error("Successfully added another foo when it should have returned an error") - } -} - -func TestReplace(t *testing.T) { - tc := New(DefaultExpiration, 0) - err := tc.Replace("foo", "bar", DefaultExpiration) - if err == nil { - t.Error("Replaced foo when it shouldn't exist") - } - tc.Set("foo", "bar", DefaultExpiration) - err = tc.Replace("foo", "bar", DefaultExpiration) - if err != nil { - t.Error("Couldn't replace existing key foo") - } -} - -func TestDelete(t *testing.T) { - tc := New(DefaultExpiration, 0) - tc.Set("foo", "bar", DefaultExpiration) - tc.Delete("foo") - x, found := tc.Get("foo") - if found { - t.Error("foo was found, but it should have been deleted") - } - if x != nil { - t.Error("x is not nil:", x) - } -} - -func TestItemCount(t *testing.T) { - tc := New(DefaultExpiration, 0) - tc.Set("foo", "1", DefaultExpiration) - tc.Set("bar", "2", DefaultExpiration) - tc.Set("baz", "3", DefaultExpiration) - if n := tc.ItemCount(); n != 3 { - t.Errorf("Item count is not 3: %d", n) - } -} - -func TestFlush(t *testing.T) { - tc := New(DefaultExpiration, 0) - tc.Set("foo", "bar", DefaultExpiration) - tc.Set("baz", "yes", DefaultExpiration) - tc.Flush() - x, found := tc.Get("foo") - if found { - t.Error("foo was found, but it should have been deleted") - } - if x != nil { - t.Error("x is not nil:", x) - } - x, found = tc.Get("baz") - if found { - t.Error("baz was found, but it should have been deleted") - } - if x != nil { - t.Error("x is not nil:", x) - } -} - -func TestIncrementOverflowInt(t *testing.T) { - tc := New(DefaultExpiration, 0) - tc.Set("int8", int8(127), DefaultExpiration) - err := tc.Increment("int8", 1) - if err != nil { - t.Error("Error incrementing int8:", err) - } - x, _ := tc.Get("int8") - int8 := x.(int8) - if int8 != -128 { - t.Error("int8 did not overflow as expected; value:", int8) - } - -} - -func TestIncrementOverflowUint(t *testing.T) { - tc := New(DefaultExpiration, 0) - tc.Set("uint8", uint8(255), DefaultExpiration) - err := tc.Increment("uint8", 1) - if err != nil { - t.Error("Error incrementing int8:", err) - } - x, _ := tc.Get("uint8") - uint8 := x.(uint8) - if uint8 != 0 { - t.Error("uint8 did not overflow as expected; value:", uint8) - } -} - -func TestDecrementUnderflowUint(t *testing.T) { - tc := New(DefaultExpiration, 0) - tc.Set("uint8", uint8(0), DefaultExpiration) - err := tc.Decrement("uint8", 1) - if err != nil { - t.Error("Error decrementing int8:", err) - } - x, _ := tc.Get("uint8") - uint8 := x.(uint8) - if uint8 != 255 { - t.Error("uint8 did not underflow as expected; value:", uint8) - } -} - -func TestOnEvicted(t *testing.T) { - tc := New(DefaultExpiration, 0) - tc.Set("foo", 3, DefaultExpiration) - if tc.onEvicted != nil { - t.Fatal("tc.onEvicted is not nil") - } - works := false - tc.OnEvicted(func(k string, v interface{}) { - if k == "foo" && v.(int) == 3 { - works = true - } - tc.Set("bar", 4, DefaultExpiration) - }) - tc.Delete("foo") - x, _ := tc.Get("bar") - if !works { - t.Error("works bool not true") - } - if x.(int) != 4 { - t.Error("bar was not 4") - } -} - -func TestCacheSerialization(t *testing.T) { - tc := New(DefaultExpiration, 0) - testFillAndSerialize(t, tc) - - // Check if gob.Register behaves properly even after multiple gob.Register - // on c.Items (many of which will be the same type) - testFillAndSerialize(t, tc) -} - -func testFillAndSerialize(t *testing.T, tc *Cache) { - tc.Set("a", "a", DefaultExpiration) - tc.Set("b", "b", DefaultExpiration) - tc.Set("c", "c", DefaultExpiration) - tc.Set("expired", "foo", 1*time.Millisecond) - tc.Set("*struct", &TestStruct{Num: 1}, DefaultExpiration) - tc.Set("[]struct", []TestStruct{ - {Num: 2}, - {Num: 3}, - }, DefaultExpiration) - tc.Set("[]*struct", []*TestStruct{ - &TestStruct{Num: 4}, - &TestStruct{Num: 5}, - }, DefaultExpiration) - tc.Set("structception", &TestStruct{ - Num: 42, - Children: []*TestStruct{ - &TestStruct{Num: 6174}, - &TestStruct{Num: 4716}, - }, - }, DefaultExpiration) - - fp := &bytes.Buffer{} - err := tc.Save(fp) - if err != nil { - t.Fatal("Couldn't save cache to fp:", err) - } - - oc := New(DefaultExpiration, 0) - err = oc.Load(fp) - if err != nil { - t.Fatal("Couldn't load cache from fp:", err) - } - - a, found := oc.Get("a") - if !found { - t.Error("a was not found") - } - if a.(string) != "a" { - t.Error("a is not a") - } - - b, found := oc.Get("b") - if !found { - t.Error("b was not found") - } - if b.(string) != "b" { - t.Error("b is not b") - } - - c, found := oc.Get("c") - if !found { - t.Error("c was not found") - } - if c.(string) != "c" { - t.Error("c is not c") - } - - <-time.After(5 * time.Millisecond) - _, found = oc.Get("expired") - if found { - t.Error("expired was found") - } - - s1, found := oc.Get("*struct") - if !found { - t.Error("*struct was not found") - } - if s1.(*TestStruct).Num != 1 { - t.Error("*struct.Num is not 1") - } - - s2, found := oc.Get("[]struct") - if !found { - t.Error("[]struct was not found") - } - s2r := s2.([]TestStruct) - if len(s2r) != 2 { - t.Error("Length of s2r is not 2") - } - if s2r[0].Num != 2 { - t.Error("s2r[0].Num is not 2") - } - if s2r[1].Num != 3 { - t.Error("s2r[1].Num is not 3") - } - - s3, found := oc.get("[]*struct") - if !found { - t.Error("[]*struct was not found") - } - s3r := s3.([]*TestStruct) - if len(s3r) != 2 { - t.Error("Length of s3r is not 2") - } - if s3r[0].Num != 4 { - t.Error("s3r[0].Num is not 4") - } - if s3r[1].Num != 5 { - t.Error("s3r[1].Num is not 5") - } - - s4, found := oc.get("structception") - if !found { - t.Error("structception was not found") - } - s4r := s4.(*TestStruct) - if len(s4r.Children) != 2 { - t.Error("Length of s4r.Children is not 2") - } - if s4r.Children[0].Num != 6174 { - t.Error("s4r.Children[0].Num is not 6174") - } - if s4r.Children[1].Num != 4716 { - t.Error("s4r.Children[1].Num is not 4716") - } -} - -func TestFileSerialization(t *testing.T) { - tc := New(DefaultExpiration, 0) - tc.Add("a", "a", DefaultExpiration) - tc.Add("b", "b", DefaultExpiration) - f, err := ioutil.TempFile("", "go-cache-cache.dat") - if err != nil { - t.Fatal("Couldn't create cache file:", err) - } - fname := f.Name() - f.Close() - tc.SaveFile(fname) - - oc := New(DefaultExpiration, 0) - oc.Add("a", "aa", 0) // this should not be overwritten - err = oc.LoadFile(fname) - if err != nil { - t.Error(err) - } - a, found := oc.Get("a") - if !found { - t.Error("a was not found") - } - astr := a.(string) - if astr != "aa" { - if astr == "a" { - t.Error("a was overwritten") - } else { - t.Error("a is not aa") - } - } - b, found := oc.Get("b") - if !found { - t.Error("b was not found") - } - if b.(string) != "b" { - t.Error("b is not b") - } -} - -func TestSerializeUnserializable(t *testing.T) { - tc := New(DefaultExpiration, 0) - ch := make(chan bool, 1) - ch <- true - tc.Set("chan", ch, DefaultExpiration) - fp := &bytes.Buffer{} - err := tc.Save(fp) // this should fail gracefully - if err.Error() != "gob NewTypeObject can't handle type: chan bool" { - t.Error("Error from Save was not gob NewTypeObject can't handle type chan bool:", err) - } -} - -func BenchmarkCacheGetExpiring(b *testing.B) { - benchmarkCacheGet(b, 5*time.Minute) -} - -func BenchmarkCacheGetNotExpiring(b *testing.B) { - benchmarkCacheGet(b, NoExpiration) -} - -func benchmarkCacheGet(b *testing.B, exp time.Duration) { - b.StopTimer() - tc := New(exp, 0) - tc.Set("foo", "bar", DefaultExpiration) - b.StartTimer() - for i := 0; i < b.N; i++ { - tc.Get("foo") - } -} - -func BenchmarkRWMutexMapGet(b *testing.B) { - b.StopTimer() - m := map[string]string{ - "foo": "bar", - } - mu := sync.RWMutex{} - b.StartTimer() - for i := 0; i < b.N; i++ { - mu.RLock() - _, _ = m["foo"] - mu.RUnlock() - } -} - -func BenchmarkRWMutexInterfaceMapGetStruct(b *testing.B) { - b.StopTimer() - s := struct{ name string }{name: "foo"} - m := map[interface{}]string{ - s: "bar", - } - mu := sync.RWMutex{} - b.StartTimer() - for i := 0; i < b.N; i++ { - mu.RLock() - _, _ = m[s] - mu.RUnlock() - } -} - -func BenchmarkRWMutexInterfaceMapGetString(b *testing.B) { - b.StopTimer() - m := map[interface{}]string{ - "foo": "bar", - } - mu := sync.RWMutex{} - b.StartTimer() - for i := 0; i < b.N; i++ { - mu.RLock() - _, _ = m["foo"] - mu.RUnlock() - } -} - -func BenchmarkCacheGetConcurrentExpiring(b *testing.B) { - benchmarkCacheGetConcurrent(b, 5*time.Minute) -} - -func BenchmarkCacheGetConcurrentNotExpiring(b *testing.B) { - benchmarkCacheGetConcurrent(b, NoExpiration) -} - -func benchmarkCacheGetConcurrent(b *testing.B, exp time.Duration) { - b.StopTimer() - tc := New(exp, 0) - tc.Set("foo", "bar", DefaultExpiration) - wg := new(sync.WaitGroup) - workers := runtime.NumCPU() - each := b.N / workers - wg.Add(workers) - b.StartTimer() - for i := 0; i < workers; i++ { - go func() { - for j := 0; j < each; j++ { - tc.Get("foo") - } - wg.Done() - }() - } - wg.Wait() -} - -func BenchmarkRWMutexMapGetConcurrent(b *testing.B) { - b.StopTimer() - m := map[string]string{ - "foo": "bar", - } - mu := sync.RWMutex{} - wg := new(sync.WaitGroup) - workers := runtime.NumCPU() - each := b.N / workers - wg.Add(workers) - b.StartTimer() - for i := 0; i < workers; i++ { - go func() { - for j := 0; j < each; j++ { - mu.RLock() - _, _ = m["foo"] - mu.RUnlock() - } - wg.Done() - }() - } - wg.Wait() -} - -func BenchmarkCacheGetManyConcurrentExpiring(b *testing.B) { - benchmarkCacheGetManyConcurrent(b, 5*time.Minute) -} - -func BenchmarkCacheGetManyConcurrentNotExpiring(b *testing.B) { - benchmarkCacheGetManyConcurrent(b, NoExpiration) -} - -func benchmarkCacheGetManyConcurrent(b *testing.B, exp time.Duration) { - // This is the same as BenchmarkCacheGetConcurrent, but its result - // can be compared against BenchmarkShardedCacheGetManyConcurrent - // in sharded_test.go. - b.StopTimer() - n := 10000 - tc := New(exp, 0) - keys := make([]string, n) - for i := 0; i < n; i++ { - k := "foo" + strconv.Itoa(n) - keys[i] = k - tc.Set(k, "bar", DefaultExpiration) - } - each := b.N / n - wg := new(sync.WaitGroup) - wg.Add(n) - for _, v := range keys { - go func() { - for j := 0; j < each; j++ { - tc.Get(v) - } - wg.Done() - }() - } - b.StartTimer() - wg.Wait() -} - -func BenchmarkCacheSetExpiring(b *testing.B) { - benchmarkCacheSet(b, 5*time.Minute) -} - -func BenchmarkCacheSetNotExpiring(b *testing.B) { - benchmarkCacheSet(b, NoExpiration) -} - -func benchmarkCacheSet(b *testing.B, exp time.Duration) { - b.StopTimer() - tc := New(exp, 0) - b.StartTimer() - for i := 0; i < b.N; i++ { - tc.Set("foo", "bar", DefaultExpiration) - } -} - -func BenchmarkRWMutexMapSet(b *testing.B) { - b.StopTimer() - m := map[string]string{} - mu := sync.RWMutex{} - b.StartTimer() - for i := 0; i < b.N; i++ { - mu.Lock() - m["foo"] = "bar" - mu.Unlock() - } -} - -func BenchmarkCacheSetDelete(b *testing.B) { - b.StopTimer() - tc := New(DefaultExpiration, 0) - b.StartTimer() - for i := 0; i < b.N; i++ { - tc.Set("foo", "bar", DefaultExpiration) - tc.Delete("foo") - } -} - -func BenchmarkRWMutexMapSetDelete(b *testing.B) { - b.StopTimer() - m := map[string]string{} - mu := sync.RWMutex{} - b.StartTimer() - for i := 0; i < b.N; i++ { - mu.Lock() - m["foo"] = "bar" - mu.Unlock() - mu.Lock() - delete(m, "foo") - mu.Unlock() - } -} - -func BenchmarkCacheSetDeleteSingleLock(b *testing.B) { - b.StopTimer() - tc := New(DefaultExpiration, 0) - b.StartTimer() - for i := 0; i < b.N; i++ { - tc.mu.Lock() - tc.set("foo", "bar", DefaultExpiration) - tc.delete("foo") - tc.mu.Unlock() - } -} - -func BenchmarkRWMutexMapSetDeleteSingleLock(b *testing.B) { - b.StopTimer() - m := map[string]string{} - mu := sync.RWMutex{} - b.StartTimer() - for i := 0; i < b.N; i++ { - mu.Lock() - m["foo"] = "bar" - delete(m, "foo") - mu.Unlock() - } -} - -func BenchmarkIncrementInt(b *testing.B) { - b.StopTimer() - tc := New(DefaultExpiration, 0) - tc.Set("foo", 0, DefaultExpiration) - b.StartTimer() - for i := 0; i < b.N; i++ { - tc.IncrementInt("foo", 1) - } -} - -func BenchmarkDeleteExpiredLoop(b *testing.B) { - b.StopTimer() - tc := New(5*time.Minute, 0) - tc.mu.Lock() - for i := 0; i < 100000; i++ { - tc.set(strconv.Itoa(i), "bar", DefaultExpiration) - } - tc.mu.Unlock() - b.StartTimer() - for i := 0; i < b.N; i++ { - tc.DeleteExpired() - } -} - -func TestGetWithExpiration(t *testing.T) { - tc := New(DefaultExpiration, 0) - - a, expiration, found := tc.GetWithExpiration("a") - if found || a != nil || !expiration.IsZero() { - t.Error("Getting A found value that shouldn't exist:", a) - } - - b, expiration, found := tc.GetWithExpiration("b") - if found || b != nil || !expiration.IsZero() { - t.Error("Getting B found value that shouldn't exist:", b) - } - - c, expiration, found := tc.GetWithExpiration("c") - if found || c != nil || !expiration.IsZero() { - t.Error("Getting C found value that shouldn't exist:", c) - } - - tc.Set("a", 1, DefaultExpiration) - tc.Set("b", "b", DefaultExpiration) - tc.Set("c", 3.5, DefaultExpiration) - tc.Set("d", 1, NoExpiration) - tc.Set("e", 1, 50*time.Millisecond) - - x, expiration, found := tc.GetWithExpiration("a") - if !found { - t.Error("a was not found while getting a2") - } - if x == nil { - t.Error("x for a is nil") - } else if a2 := x.(int); a2+2 != 3 { - t.Error("a2 (which should be 1) plus 2 does not equal 3; value:", a2) - } - if !expiration.IsZero() { - t.Error("expiration for a is not a zeroed time") - } - - x, expiration, found = tc.GetWithExpiration("b") - if !found { - t.Error("b was not found while getting b2") - } - if x == nil { - t.Error("x for b is nil") - } else if b2 := x.(string); b2+"B" != "bB" { - t.Error("b2 (which should be b) plus B does not equal bB; value:", b2) - } - if !expiration.IsZero() { - t.Error("expiration for b is not a zeroed time") - } - - x, expiration, found = tc.GetWithExpiration("c") - if !found { - t.Error("c was not found while getting c2") - } - if x == nil { - t.Error("x for c is nil") - } else if c2 := x.(float64); c2+1.2 != 4.7 { - t.Error("c2 (which should be 3.5) plus 1.2 does not equal 4.7; value:", c2) - } - if !expiration.IsZero() { - t.Error("expiration for c is not a zeroed time") - } - - x, expiration, found = tc.GetWithExpiration("d") - if !found { - t.Error("d was not found while getting d2") - } - if x == nil { - t.Error("x for d is nil") - } else if d2 := x.(int); d2+2 != 3 { - t.Error("d (which should be 1) plus 2 does not equal 3; value:", d2) - } - if !expiration.IsZero() { - t.Error("expiration for d is not a zeroed time") - } - - x, expiration, found = tc.GetWithExpiration("e") - if !found { - t.Error("e was not found while getting e2") - } - if x == nil { - t.Error("x for e is nil") - } else if e2 := x.(int); e2+2 != 3 { - t.Error("e (which should be 1) plus 2 does not equal 3; value:", e2) - } - if expiration.UnixNano() != tc.items["e"].Expiration { - t.Error("expiration for e is not the correct time") - } - if expiration.UnixNano() < time.Now().UnixNano() { - t.Error("expiration for e is in the past") - } -} diff --git a/old/sharded.go b/old/sharded.go deleted file mode 100644 index 5aa0564..0000000 --- a/old/sharded.go +++ /dev/null @@ -1,192 +0,0 @@ -package old - -import ( - "crypto/rand" - "math" - "math/big" - insecurerand "math/rand" - "os" - "runtime" - "time" -) - -// This is an experimental and unexported (for now) attempt at making a cache -// with better algorithmic complexity than the standard one, namely by -// preventing write locks of the entire cache when an item is added. As of the -// time of writing, the overhead of selecting buckets results in cache -// operations being about twice as slow as for the standard cache with small -// total cache sizes, and faster for larger ones. -// -// See cache_test.go for a few benchmarks. - -type unexportedShardedCache struct { - *shardedCache -} - -type shardedCache struct { - seed uint32 - m uint32 - cs []*cache - janitor *shardedJanitor -} - -// djb2 with better shuffling. 5x faster than FNV with the hash.Hash overhead. -func djb33(seed uint32, k string) uint32 { - var ( - l = uint32(len(k)) - d = 5381 + seed + l - i = uint32(0) - ) - // Why is all this 5x faster than a for loop? - if l >= 4 { - for i < l-4 { - d = (d * 33) ^ uint32(k[i]) - d = (d * 33) ^ uint32(k[i+1]) - d = (d * 33) ^ uint32(k[i+2]) - d = (d * 33) ^ uint32(k[i+3]) - i += 4 - } - } - switch l - i { - case 1: - case 2: - d = (d * 33) ^ uint32(k[i]) - case 3: - d = (d * 33) ^ uint32(k[i]) - d = (d * 33) ^ uint32(k[i+1]) - case 4: - d = (d * 33) ^ uint32(k[i]) - d = (d * 33) ^ uint32(k[i+1]) - d = (d * 33) ^ uint32(k[i+2]) - } - return d ^ (d >> 16) -} - -func (sc *shardedCache) bucket(k string) *cache { - return sc.cs[djb33(sc.seed, k)%sc.m] -} - -func (sc *shardedCache) Set(k string, x interface{}, d time.Duration) { - sc.bucket(k).Set(k, x, d) -} - -func (sc *shardedCache) Add(k string, x interface{}, d time.Duration) error { - return sc.bucket(k).Add(k, x, d) -} - -func (sc *shardedCache) Replace(k string, x interface{}, d time.Duration) error { - return sc.bucket(k).Replace(k, x, d) -} - -func (sc *shardedCache) Get(k string) (interface{}, bool) { - return sc.bucket(k).Get(k) -} - -func (sc *shardedCache) Increment(k string, n int64) error { - return sc.bucket(k).Increment(k, n) -} - -func (sc *shardedCache) IncrementFloat(k string, n float64) error { - return sc.bucket(k).IncrementFloat(k, n) -} - -func (sc *shardedCache) Decrement(k string, n int64) error { - return sc.bucket(k).Decrement(k, n) -} - -func (sc *shardedCache) Delete(k string) { - sc.bucket(k).Delete(k) -} - -func (sc *shardedCache) DeleteExpired() { - for _, v := range sc.cs { - v.DeleteExpired() - } -} - -// Returns the items in the cache. This may include items that have expired, -// but have not yet been cleaned up. If this is significant, the Expiration -// fields of the items should be checked. Note that explicit synchronization -// is needed to use a cache and its corresponding Items() return values at -// the same time, as the maps are shared. -func (sc *shardedCache) Items() []map[string]Item { - res := make([]map[string]Item, len(sc.cs)) - for i, v := range sc.cs { - res[i] = v.Items() - } - return res -} - -func (sc *shardedCache) Flush() { - for _, v := range sc.cs { - v.Flush() - } -} - -type shardedJanitor struct { - Interval time.Duration - stop chan bool -} - -func (j *shardedJanitor) Run(sc *shardedCache) { - j.stop = make(chan bool) - tick := time.Tick(j.Interval) - for { - select { - case <-tick: - sc.DeleteExpired() - case <-j.stop: - return - } - } -} - -func stopShardedJanitor(sc *unexportedShardedCache) { - sc.janitor.stop <- true -} - -func runShardedJanitor(sc *shardedCache, ci time.Duration) { - j := &shardedJanitor{ - Interval: ci, - } - sc.janitor = j - go j.Run(sc) -} - -func newShardedCache(n int, de time.Duration) *shardedCache { - max := big.NewInt(0).SetUint64(uint64(math.MaxUint32)) - rnd, err := rand.Int(rand.Reader, max) - var seed uint32 - if err != nil { - os.Stderr.Write([]byte("WARNING: go-cache's newShardedCache failed to read from the system CSPRNG (/dev/urandom or equivalent.) Your system's security may be compromised. Continuing with an insecure seed.\n")) - seed = insecurerand.Uint32() - } else { - seed = uint32(rnd.Uint64()) - } - sc := &shardedCache{ - seed: seed, - m: uint32(n), - cs: make([]*cache, n), - } - for i := 0; i < n; i++ { - c := &cache{ - defaultExpiration: de, - items: map[string]Item{}, - } - sc.cs[i] = c - } - return sc -} - -func unexportedNewSharded(defaultExpiration, cleanupInterval time.Duration, shards int) *unexportedShardedCache { - if defaultExpiration == 0 { - defaultExpiration = -1 - } - sc := newShardedCache(shards, defaultExpiration) - SC := &unexportedShardedCache{sc} - if cleanupInterval > 0 { - runShardedJanitor(sc, cleanupInterval) - runtime.SetFinalizer(SC, stopShardedJanitor) - } - return SC -} diff --git a/old/sharded_test.go b/old/sharded_test.go deleted file mode 100644 index 9e13b2b..0000000 --- a/old/sharded_test.go +++ /dev/null @@ -1,85 +0,0 @@ -package old - -import ( - "strconv" - "sync" - "testing" - "time" -) - -// func TestDjb33(t *testing.T) { -// } - -var shardedKeys = []string{ - "f", - "fo", - "foo", - "barf", - "barfo", - "foobar", - "bazbarf", - "bazbarfo", - "bazbarfoo", - "foobarbazq", - "foobarbazqu", - "foobarbazquu", - "foobarbazquux", -} - -func TestShardedCache(t *testing.T) { - tc := unexportedNewSharded(DefaultExpiration, 0, 13) - for _, v := range shardedKeys { - tc.Set(v, "value", DefaultExpiration) - } -} - -func BenchmarkShardedCacheGetExpiring(b *testing.B) { - benchmarkShardedCacheGet(b, 5*time.Minute) -} - -func BenchmarkShardedCacheGetNotExpiring(b *testing.B) { - benchmarkShardedCacheGet(b, NoExpiration) -} - -func benchmarkShardedCacheGet(b *testing.B, exp time.Duration) { - b.StopTimer() - tc := unexportedNewSharded(exp, 0, 10) - tc.Set("foobarba", "zquux", DefaultExpiration) - b.StartTimer() - for i := 0; i < b.N; i++ { - tc.Get("foobarba") - } -} - -func BenchmarkShardedCacheGetManyConcurrentExpiring(b *testing.B) { - benchmarkShardedCacheGetManyConcurrent(b, 5*time.Minute) -} - -func BenchmarkShardedCacheGetManyConcurrentNotExpiring(b *testing.B) { - benchmarkShardedCacheGetManyConcurrent(b, NoExpiration) -} - -func benchmarkShardedCacheGetManyConcurrent(b *testing.B, exp time.Duration) { - b.StopTimer() - n := 10000 - tsc := unexportedNewSharded(exp, 0, 20) - keys := make([]string, n) - for i := 0; i < n; i++ { - k := "foo" + strconv.Itoa(n) - keys[i] = k - tsc.Set(k, "bar", DefaultExpiration) - } - each := b.N / n - wg := new(sync.WaitGroup) - wg.Add(n) - for _, v := range keys { - go func() { - for j := 0; j < each; j++ { - tsc.Get(v) - } - wg.Done() - }() - } - b.StartTimer() - wg.Wait() -}