golang-go-cache-0.0~git20150304/0000755000175000000620000000000012524013243015322 5ustar jenkinsstaffgolang-go-cache-0.0~git20150304/cache.go0000644000175000000620000006577712524013210016734 0ustar jenkinsstaffpackage cache import ( "encoding/gob" "fmt" "io" "os" "runtime" "sync" "time" ) type Item struct { Object interface{} Expiration *time.Time } // Returns true if the item has expired. func (item *Item) Expired() bool { if item.Expiration == nil { return false } return item.Expiration.Before(time.Now()) } 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 { sync.RWMutex defaultExpiration time.Duration items map[string]*Item 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) { c.Lock() c.set(k, x, d) // TODO: Calls to mu.Unlock are currently not deferred because defer // adds ~200 ns (as of go1.) c.Unlock() } func (c *cache) set(k string, x interface{}, d time.Duration) { var e *time.Time if d == DefaultExpiration { d = c.defaultExpiration } if d > 0 { t := time.Now().Add(d) e = &t } c.items[k] = &Item{ Object: x, Expiration: e, } } // 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.Lock() _, found := c.get(k) if found { c.Unlock() return fmt.Errorf("Item %s already exists", k) } c.set(k, x, d) c.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.Lock() _, found := c.get(k) if !found { c.Unlock() return fmt.Errorf("Item %s doesn't exist", k) } c.set(k, x, d) c.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.RLock() x, found := c.get(k) c.RUnlock() return x, found } func (c *cache) get(k string) (interface{}, bool) { item, found := c.items[k] if !found || item.Expired() { 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.Lock() v, found := c.items[k] if !found || v.Expired() { c.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.Unlock() return fmt.Errorf("The value for %s is not an integer", k) } c.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.Lock() v, found := c.items[k] if !found || v.Expired() { c.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.Unlock() return fmt.Errorf("The value for %s does not have type float32 or float64", k) } c.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.Lock() v, found := c.items[k] if !found || v.Expired() { c.Unlock() return 0, fmt.Errorf("Item %s not found", k) } rv, ok := v.Object.(int) if !ok { c.Unlock() return 0, fmt.Errorf("The value for %s is not an int", k) } nv := rv + n v.Object = nv c.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.Lock() v, found := c.items[k] if !found || v.Expired() { c.Unlock() return 0, fmt.Errorf("Item %s not found", k) } rv, ok := v.Object.(int8) if !ok { c.Unlock() return 0, fmt.Errorf("The value for %s is not an int8", k) } nv := rv + n v.Object = nv c.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.Lock() v, found := c.items[k] if !found || v.Expired() { c.Unlock() return 0, fmt.Errorf("Item %s not found", k) } rv, ok := v.Object.(int16) if !ok { c.Unlock() return 0, fmt.Errorf("The value for %s is not an int16", k) } nv := rv + n v.Object = nv c.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.Lock() v, found := c.items[k] if !found || v.Expired() { c.Unlock() return 0, fmt.Errorf("Item %s not found", k) } rv, ok := v.Object.(int32) if !ok { c.Unlock() return 0, fmt.Errorf("The value for %s is not an int32", k) } nv := rv + n v.Object = nv c.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.Lock() v, found := c.items[k] if !found || v.Expired() { c.Unlock() return 0, fmt.Errorf("Item %s not found", k) } rv, ok := v.Object.(int64) if !ok { c.Unlock() return 0, fmt.Errorf("The value for %s is not an int64", k) } nv := rv + n v.Object = nv c.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.Lock() v, found := c.items[k] if !found || v.Expired() { c.Unlock() return 0, fmt.Errorf("Item %s not found", k) } rv, ok := v.Object.(uint) if !ok { c.Unlock() return 0, fmt.Errorf("The value for %s is not an uint", k) } nv := rv + n v.Object = nv c.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.Lock() v, found := c.items[k] if !found || v.Expired() { c.Unlock() return 0, fmt.Errorf("Item %s not found", k) } rv, ok := v.Object.(uintptr) if !ok { c.Unlock() return 0, fmt.Errorf("The value for %s is not an uintptr", k) } nv := rv + n v.Object = nv c.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.Lock() v, found := c.items[k] if !found || v.Expired() { c.Unlock() return 0, fmt.Errorf("Item %s not found", k) } rv, ok := v.Object.(uint8) if !ok { c.Unlock() return 0, fmt.Errorf("The value for %s is not an uint8", k) } nv := rv + n v.Object = nv c.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.Lock() v, found := c.items[k] if !found || v.Expired() { c.Unlock() return 0, fmt.Errorf("Item %s not found", k) } rv, ok := v.Object.(uint16) if !ok { c.Unlock() return 0, fmt.Errorf("The value for %s is not an uint16", k) } nv := rv + n v.Object = nv c.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.Lock() v, found := c.items[k] if !found || v.Expired() { c.Unlock() return 0, fmt.Errorf("Item %s not found", k) } rv, ok := v.Object.(uint32) if !ok { c.Unlock() return 0, fmt.Errorf("The value for %s is not an uint32", k) } nv := rv + n v.Object = nv c.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.Lock() v, found := c.items[k] if !found || v.Expired() { c.Unlock() return 0, fmt.Errorf("Item %s not found", k) } rv, ok := v.Object.(uint64) if !ok { c.Unlock() return 0, fmt.Errorf("The value for %s is not an uint64", k) } nv := rv + n v.Object = nv c.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.Lock() v, found := c.items[k] if !found || v.Expired() { c.Unlock() return 0, fmt.Errorf("Item %s not found", k) } rv, ok := v.Object.(float32) if !ok { c.Unlock() return 0, fmt.Errorf("The value for %s is not an float32", k) } nv := rv + n v.Object = nv c.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.Lock() v, found := c.items[k] if !found || v.Expired() { c.Unlock() return 0, fmt.Errorf("Item %s not found", k) } rv, ok := v.Object.(float64) if !ok { c.Unlock() return 0, fmt.Errorf("The value for %s is not an float64", k) } nv := rv + n v.Object = nv c.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.Lock() v, found := c.items[k] if !found || v.Expired() { c.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.Unlock() return fmt.Errorf("The value for %s is not an integer", k) } c.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.Lock() v, found := c.items[k] if !found || v.Expired() { c.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.Unlock() return fmt.Errorf("The value for %s does not have type float32 or float64", k) } c.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.Lock() v, found := c.items[k] if !found || v.Expired() { c.Unlock() return 0, fmt.Errorf("Item %s not found", k) } rv, ok := v.Object.(int) if !ok { c.Unlock() return 0, fmt.Errorf("The value for %s is not an int", k) } nv := rv - n v.Object = nv c.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.Lock() v, found := c.items[k] if !found || v.Expired() { c.Unlock() return 0, fmt.Errorf("Item %s not found", k) } rv, ok := v.Object.(int8) if !ok { c.Unlock() return 0, fmt.Errorf("The value for %s is not an int8", k) } nv := rv - n v.Object = nv c.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.Lock() v, found := c.items[k] if !found || v.Expired() { c.Unlock() return 0, fmt.Errorf("Item %s not found", k) } rv, ok := v.Object.(int16) if !ok { c.Unlock() return 0, fmt.Errorf("The value for %s is not an int16", k) } nv := rv - n v.Object = nv c.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.Lock() v, found := c.items[k] if !found || v.Expired() { c.Unlock() return 0, fmt.Errorf("Item %s not found", k) } rv, ok := v.Object.(int32) if !ok { c.Unlock() return 0, fmt.Errorf("The value for %s is not an int32", k) } nv := rv - n v.Object = nv c.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.Lock() v, found := c.items[k] if !found || v.Expired() { c.Unlock() return 0, fmt.Errorf("Item %s not found", k) } rv, ok := v.Object.(int64) if !ok { c.Unlock() return 0, fmt.Errorf("The value for %s is not an int64", k) } nv := rv - n v.Object = nv c.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.Lock() v, found := c.items[k] if !found || v.Expired() { c.Unlock() return 0, fmt.Errorf("Item %s not found", k) } rv, ok := v.Object.(uint) if !ok { c.Unlock() return 0, fmt.Errorf("The value for %s is not an uint", k) } nv := rv - n v.Object = nv c.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.Lock() v, found := c.items[k] if !found || v.Expired() { c.Unlock() return 0, fmt.Errorf("Item %s not found", k) } rv, ok := v.Object.(uintptr) if !ok { c.Unlock() return 0, fmt.Errorf("The value for %s is not an uintptr", k) } nv := rv - n v.Object = nv c.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.Lock() v, found := c.items[k] if !found || v.Expired() { c.Unlock() return 0, fmt.Errorf("Item %s not found", k) } rv, ok := v.Object.(uint8) if !ok { c.Unlock() return 0, fmt.Errorf("The value for %s is not an uint8", k) } nv := rv - n v.Object = nv c.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.Lock() v, found := c.items[k] if !found || v.Expired() { c.Unlock() return 0, fmt.Errorf("Item %s not found", k) } rv, ok := v.Object.(uint16) if !ok { c.Unlock() return 0, fmt.Errorf("The value for %s is not an uint16", k) } nv := rv - n v.Object = nv c.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.Lock() v, found := c.items[k] if !found || v.Expired() { c.Unlock() return 0, fmt.Errorf("Item %s not found", k) } rv, ok := v.Object.(uint32) if !ok { c.Unlock() return 0, fmt.Errorf("The value for %s is not an uint32", k) } nv := rv - n v.Object = nv c.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.Lock() v, found := c.items[k] if !found || v.Expired() { c.Unlock() return 0, fmt.Errorf("Item %s not found", k) } rv, ok := v.Object.(uint64) if !ok { c.Unlock() return 0, fmt.Errorf("The value for %s is not an uint64", k) } nv := rv - n v.Object = nv c.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.Lock() v, found := c.items[k] if !found || v.Expired() { c.Unlock() return 0, fmt.Errorf("Item %s not found", k) } rv, ok := v.Object.(float32) if !ok { c.Unlock() return 0, fmt.Errorf("The value for %s is not an float32", k) } nv := rv - n v.Object = nv c.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.Lock() v, found := c.items[k] if !found || v.Expired() { c.Unlock() return 0, fmt.Errorf("Item %s not found", k) } rv, ok := v.Object.(float64) if !ok { c.Unlock() return 0, fmt.Errorf("The value for %s is not an float64", k) } nv := rv - n v.Object = nv c.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.Lock() c.delete(k) c.Unlock() } func (c *cache) delete(k string) { delete(c.items, k) } // Delete all expired items from the cache. func (c *cache) DeleteExpired() { c.Lock() for k, v := range c.items { if v.Expired() { c.delete(k) } } c.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.RLock() defer c.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.Lock() defer c.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() } // 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 value at // the same time, as the map is shared. func (c *cache) Items() map[string]*Item { c.RLock() defer c.RUnlock() return c.items } // Returns the number of items in the cache. This may include items that have // expired, but have not yet been cleaned up. Equivalent to len(c.Items()). func (c *cache) ItemCount() int { c.RLock() n := len(c.items) c.RUnlock() return n } // Delete all items from the cache. func (c *cache) Flush() { c.Lock() c.items = map[string]*Item{} c.Unlock() } type janitor struct { Interval time.Duration stop chan bool } func (j *janitor) Run(c *cache) { j.stop = make(chan bool) tick := time.Tick(j.Interval) for { select { case <-tick: c.DeleteExpired() case <-j.stop: return } } } func stopJanitor(c *Cache) { c.janitor.stop <- true } func runJanitor(c *cache, ci time.Duration) { j := &janitor{ Interval: ci, } 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) } golang-go-cache-0.0~git20150304/cache_test.go0000644000175000000620000010307712524013210017755 0ustar jenkinsstaffpackage cache 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: nil, }, "b": &Item{ Object: 2, Expiration: nil, }, } 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 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 BenchmarkCacheGet(b *testing.B) { b.StopTimer() tc := New(DefaultExpiration, 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 BenchmarkCacheGetConcurrent(b *testing.B) { b.StopTimer() tc := New(DefaultExpiration, 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 BenchmarkCacheGetManyConcurrent(b *testing.B) { // This is the same as BenchmarkCacheGetConcurrent, but its result // can be compared against BenchmarkShardedCacheGetManyConcurrent // in sharded_test.go. b.StopTimer() n := 10000 tc := New(DefaultExpiration, 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 BenchmarkCacheSet(b *testing.B) { b.StopTimer() tc := New(DefaultExpiration, 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.Lock() tc.set("foo", "bar", DefaultExpiration) tc.delete("foo") tc.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() } } golang-go-cache-0.0~git20150304/CONTRIBUTORS0000644000175000000620000000055412524013210017200 0ustar jenkinsstaffThis is a list of people who have contributed code to go-cache. They, or their employers, are the copyright holders of the contributed code. Contributed code is subject to the license restrictions listed in LICENSE (as they were when the code was contributed.) Dustin Sallings Jason Mooberry Sergey Shepelev golang-go-cache-0.0~git20150304/LICENSE0000644000175000000620000000211512524013210016320 0ustar jenkinsstaffCopyright (c) 2012-2014 Patrick Mylund Nielsen and the go-cache contributors Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. golang-go-cache-0.0~git20150304/README.md0000644000175000000620000000617412524013210016603 0ustar jenkinsstaff# go-cache go-cache is an in-memory key:value store/cache similar to memcached that is suitable for applications running on a single machine. Its major advantage is that, being essentially a thread-safe `map[string]interface{}` with expiration times, it doesn't need to serialize or transmit its contents over the network. Any object can be stored, for a given duration or forever, and the cache can be safely used by multiple goroutines. Although go-cache isn't meant to be used as a persistent datastore, the entire cache can be saved to and loaded from a file (using `c.Items()` to retrieve the items map to serialize, and `NewFrom()` to create a cache from a deserialized one) to recover from downtime quickly. (See the docs for `NewFrom()` for caveats.) ### Installation `go get github.com/pmylund/go-cache` ### Usage import ( "fmt" "github.com/pmylund/go-cache" "time" ) func main() { // Create a cache with a default expiration time of 5 minutes, and which // purges expired items every 30 seconds c := cache.New(5*time.Minute, 30*time.Second) // Set the value of the key "foo" to "bar", with the default expiration time c.Set("foo", "bar", cache.DefaultExpiration) // Set the value of the key "baz" to 42, with no expiration time // (the item won't be removed until it is re-set, or removed using // c.Delete("baz") c.Set("baz", 42, cache.NoExpiration) // Get the string associated with the key "foo" from the cache foo, found := c.Get("foo") if found { fmt.Println(foo) } // Since Go is statically typed, and cache values can be anything, type // assertion is needed when values are being passed to functions that don't // take arbitrary types, (i.e. interface{}). The simplest way to do this for // values which will only be used once--e.g. for passing to another // function--is: foo, found := c.Get("foo") if found { MyFunction(foo.(string)) } // This gets tedious if the value is used several times in the same function. // You might do either of the following instead: if x, found := c.Get("foo"); found { foo := x.(string) // ... } // or var foo string if x, found := c.Get("foo"); found { foo = x.(string) } // ... // foo can then be passed around freely as a string // Want performance? Store pointers! c.Set("foo", &MyStruct, cache.DefaultExpiration) if x, found := c.Get("foo"); found { foo := x.(*MyStruct) // ... } // If you store a reference type like a pointer, slice, map or channel, you // do not need to run Set if you modify the underlying data. The cached // reference points to the same memory, so if you modify a struct whose // pointer you've stored in the cache, retrieving that pointer with Get will // point you to the same data: foo := &MyStruct{Num: 1} c.Set("foo", foo, cache.DefaultExpiration) // ... x, _ := c.Get("foo") foo := x.(*MyStruct) fmt.Println(foo.Num) // ... foo.Num++ // ... x, _ := c.Get("foo") foo := x.(*MyStruct) foo.Println(foo.Num) // will print: // 1 // 2 } ### Reference `godoc` or [http://godoc.org/github.com/pmylund/go-cache](http://godoc.org/github.com/pmylund/go-cache) golang-go-cache-0.0~git20150304/sharded.go0000644000175000000620000001077412524013210017266 0ustar jenkinsstaffpackage cache 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 } golang-go-cache-0.0~git20150304/sharded_test.go0000644000175000000620000000222012524013210020310 0ustar jenkinsstaffpackage cache import ( "strconv" "sync" "testing" ) // 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 BenchmarkShardedCacheGet(b *testing.B) { b.StopTimer() tc := unexportedNewSharded(DefaultExpiration, 0, 10) tc.Set("foobarba", "zquux", DefaultExpiration) b.StartTimer() for i := 0; i < b.N; i++ { tc.Get("foobarba") } } func BenchmarkShardedCacheGetManyConcurrent(b *testing.B) { b.StopTimer() n := 10000 tsc := unexportedNewSharded(DefaultExpiration, 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() }