围观 Roblox 持续三天的故障

func (f *freelist) arrayAllocate(txid txid, n int) pgid {
  ......
 var initial, previd pgid
 for i, id := range f.ids {
    ......
  // Reset initial page if this is not contiguous.
  if previd == 0 || id-previd != 1 {
   initial = id
  }

  // If we found a contiguous block then remove it and return it.
  if (id-initial)+1 == pgid(n) {
   // If we're allocating off the beginning then take the fast path
   // and just adjust the existing slice. This will use extra memory
   // temporarily but the append() in free() will realloc the slice
   // as is necessary.
   if (i + 1) == n {
    f.ids = f.ids[i+1:]
   } else {
    copy(f.ids[i-n+1:], f.ids[i+1:])
    f.ids = f.ids[:len(f.ids)-n]
   }

   // Remove from the free cache.
   for i := pgid(0); i < pgid(n); i++ {
    delete(f.cache, initial+i)
   }
   f.allocs[initial] = txid
   return initial
  }
  previd = id
 }
 return 0
}

// pidSet holds the set of starting pgids which have the same span size
type pidSet map[pgid]struct{}

type freelist struct {
  ...
    freemaps map[uint64]pidSet // key is the size of continuous pages(span), value is a set which contains the starting pgids of same size
    forwardMap map[pgid]uint64 // key is start pgid, value is its span size
    backwardMap map[pgid]uint64 // key is end pgid, value is its span size
    ...
}

// mergeWithExistingSpan merges pid to the existing free spans, try to merge it backward and forward
func (f *freelist) mergeWithExistingSpan(pid pgid) {
 prev := pid - 1
 next := pid + 1

 preSize, mergeWithPrev := f.backwardMap[prev]
 nextSize, mergeWithNext := f.forwardMap[next]
 newStart := pid
 newSize := uint64(1)

 if mergeWithPrev {
  //merge with previous span
  start := prev + 1 - pgid(preSize)
  f.delSpan(start, preSize)

  newStart -= pgid(preSize)
  newSize += preSize
 }

 if mergeWithNext {
  // merge with next span
  f.delSpan(next, nextSize)
  newSize += nextSize
 }

 f.addSpan(newStart, newSize)
}

func (f *freelist) addSpan(start pgid, size uint64) {
 f.backwardMap[start-1+pgid(size)] = size
 f.forwardMap[start] = size
 if _, ok := f.freemaps[size]; !ok {
  f.freemaps[size] = make(map[pgid]struct{})
 }

 f.freemaps[size][start] = struct{}{}
}

func (f *freelist) delSpan(start pgid, size uint64) {
 delete(f.forwardMap, start)
 delete(f.backwardMap, start+pgid(size-1))
 delete(f.freemaps[size], start)
 if len(f.freemaps[size]) == 0 {
  delete(f.freemaps, size)
 }
}

// hashmapAllocate serves the same purpose as arrayAllocate, but use hashmap as backend
func (f *freelist) hashmapAllocate(txid txid, n int) pgid {
  ......
 // if we have a exact size match just return short path
 if bm, ok := f.freemaps[uint64(n)]; ok {
  for pid := range bm {
   // remove the span
   f.delSpan(pid, uint64(n))

   f.allocs[pid] = txid

   for i := pgid(0); i < pgid(n); i++ {
    delete(f.cache, pid+i)
   }
   return pid
  }
 }

 // lookup the map to find larger span
 for size, bm := range f.freemaps {
  if size < uint64(n) {
   continue
  }

  for pid := range bm {
   // remove the initial
   f.delSpan(pid, size)

   f.allocs[pid] = txid

   remain := size - uint64(n)

   // add remain span
   f.addSpan(pid+pgid(n), remain)

   for i := pgid(0); i < pgid(n); i++ {
    delete(f.cache, pid+i)
   }
   return pid
  }
 }

 return 0
}