Deeply understand the use of go cache library freecache

func main() {
   cacheSize := 100 * 1024 * 1024
   cache := (cacheSize)

   for i := 0; i < N; i++ {
      str := (i)
      _ = ([]byte(str), []byte(str), 1)
   }

   now := ()
   ()
   ("freecache, GC took: %s\n", (now))
   _, _ = ([]byte("aa"))

   now = ()
   for i := 0; i < N; i++ {
      str := (i)
      _, _ = ([]byte(str))
   }
   ("freecache, Get took: %s\n\n", (now))
}

type segment struct {
   rb            RingBuf // ring buffer that stores data
   segId         int
   _             uint32  // Placeholder   missCount     int64
   hitCount      int64
   entryCount    int64
   totalCount    int64      // number of entries in ring buffer, including deleted entries.
   totalTime     int64      // used to calculate least recent used entry.
   timer         Timer      // Timer giving current time
   totalEvacuate int64      // used for debug
   totalExpired  int64      // used for debug
   overwrites    int64      // used for debug
   touched       int64      // used for debug
   vacuumLen     int64      // up to vacuumLen, new data can be written without overwriting old data.
   slotLens      [256]int32 // The actual length for every slot.
   slotCap       int32      // max number of entry pointers a slot can hold.
   slotsData     []entryPtr // Index pointer}

func NewCacheCustomTimer(size int, timer Timer) (cache *Cache) {
    cache = new(Cache)
    for i := 0; i < segmentCount; i++ {
        [i] = newSegment(size/segmentCount, i, timer)
    }
}
func newSegment(bufSize int, segId int, timer Timer) (seg segment) {
     = NewRingBuf(bufSize, 0)
     = segId
     = timer
     = int64(bufSize)
     = 1
     = make([]entryPtr, 256*) // Each slotData initializes 256 unit sizes}

_ = ([]byte(str), []byte(str), 1)

func (cache *Cache) Set(key, value []byte, expireSeconds int) (err error) {
   hashVal := hashFunc(key)
   segID := hashVal & segmentAndOpVal // Lower 8 digits   [segID].Lock() // Add lock   err = [segID].set(key, value, hashVal, expireSeconds)
   [segID].Unlock()
}

func (seg *segment) set(key, value []byte, hashVal uint64, expireSeconds int) (err error) {
   slotId := uint8(hashVal >> 8)
   hash16 := uint16(hashVal >> 16)
   slot := (slotId)
   idx, match := (slot, hash16, key)

   var hdrBuf [ENTRY_HDR_SIZE]byte
   hdr := (*entryHdr)((&hdrBuf[0]))
   if match { // There is a data update operation      matchedPtr := &slot[idx]
      (hdrBuf[:], )
       = slotId
      hdr.hash16 = hash16
       = uint16(len(key))
      originAccessTime := 
       = now
       = expireAt
       = uint32(len(value))
      if  >=  {
         // The existing data value space can save the value size this time         atomic.AddInt64(&, int64()-int64(originAccessTime))
         (hdrBuf[:], )
         (value, +ENTRY_HDR_SIZE+int64())
         atomic.AddInt64(&, 1)
         return
      }
      // Delete the corresponding entryPtr, which involves slotsData memory copy, and ringbug just marks to delete      (slotId, slot, idx)
      match = false
      // increase capacity and limit entry len.
      for  <  {
          *= 2
      }
      if  > uint32(maxKeyValLen-len(key)) {
          = uint32(maxKeyValLen - len(key))
      }
   } else { // No data       = slotId
      hdr.hash16 = hash16
       = uint16(len(key))
       = now
       = expireAt
       = uint32(len(value))
       = uint32(len(value))
      if  == 0 { // avoid infinite loop when increasing capacity.
          = 1
      }
   }
   
   // The actual length of the data is ENTRY_HDR_SIZE=24 + the length of key and value   entryLen := ENTRY_HDR_SIZE + int64(len(key)) + int64()
   slotModified := (entryLen, slotId, now)
   if slotModified {
      // the slot has been modified during evacuation, we need to looked up for the 'idx' again.
      // otherwise there would be index out of bound error.
      slot = (slotId)
      idx, match = (slot, hash16, key)
      // assert(match == false)
   }
   newOff := ()
   (slotId, hash16, newOff, idx, )
   (hdrBuf[:])
   (key)
   (value)
   (int64( - ))
   atomic.AddInt64(&, int64(now))
   atomic.AddInt64(&, 1)
    -= entryLen
   return
}

func (seg *segment) evacuate(entryLen int64, slotId uint8, now uint32) (slotModified bool) {
   var oldHdrBuf [ENTRY_HDR_SIZE]byte
   consecutiveEvacuate := 0
   for  < entryLen {
      oldOff := () +  - ()
      (oldHdrBuf[:], oldOff)
      oldHdr := (*entryHdr)((&oldHdrBuf[0]))
      oldEntryLen := ENTRY_HDR_SIZE + int64() + int64()
      if  { // Deleted         consecutiveEvacuate = 0
         atomic.AddInt64(&, -int64())
         atomic.AddInt64(&, -1)
          += oldEntryLen
         continue
      }
      expired :=  != 0 &&  < now
      leastRecentUsed := int64()*atomic.LoadInt64(&) <= atomic.LoadInt64(&)
      if expired || leastRecentUsed || consecutiveEvacuate > 5 {
      // Can be recycled         (, oldHdr.hash16, oldOff)
         if  == slotId {
            slotModified = true
         }
         consecutiveEvacuate = 0
         atomic.AddInt64(&, -int64())
         atomic.AddInt64(&, -1)
          += oldEntryLen
         if expired {
            atomic.AddInt64(&, 1)
         } else {
            atomic.AddInt64(&, 1)
         }
      } else {
         // evacuate an old entry that has been accessed recently for better cache hit rate.
         newOff := (oldOff, int(oldEntryLen))
         (, oldHdr.hash16, oldOff, newOff)
         consecutiveEvacuate++
         atomic.AddInt64(&, 1)
      }
   }
}

func (cache *Cache) Get(key []byte) (value []byte, err error) {
   hashVal := hashFunc(key)
   segID := hashVal & segmentAndOpVal
   [segID].Lock()
   value, _, err = [segID].get(key, nil, hashVal, false)
   [segID].Unlock()
   return
}
func (seg *segment) get(key, buf []byte, hashVal uint64, peek bool) (value []byte, expireAt uint32, err error) {
   hdr, ptr, err := (key, hashVal, peek) // hash+localization search   if err != nil {
      return
   }
   expireAt = 
   if cap(buf) >= int() {
      value = buf[:]
   } else {
      value = make([]byte, )
   }

   (value, +ENTRY_HDR_SIZE+int64())
}