内存分配

func nextFreeFast(s *mspan) gclinkptr {
    // 第几位开始不是0,从0位开始,从右边开始数。
    theBit := sys.Ctz64(s.allocCache) // Is there a free object in the allocCache?
    // 超过了说明没可用的了
    if theBit < 64 {
        result := s.freeindex + uintptr(theBit)
        // 超过了表明无可用的
        if result < s.nelems {
            // 可能有可用的
            freeidx := result + 1
            if freeidx%64 == 0 && freeidx != s.nelems {
                // 不是最后一个，且整除64，返回0
                return 0
            }
            // 真的有可用的
            // 更新一下
            s.allocCache >>= uint(theBit + 1)
            s.freeindex = freeidx
            s.allocCount++
            return gclinkptr(result*s.elemsize + s.base())
        }
    }
    return 0
}

func (s *mspan) nextFreeIndex() uintptr {//这个函数有硬件优化，性能极高。
    sfreeindex := s.freeindex
    snelems := s.nelems
    if sfreeindex == snelems { // 没有空闲的对象了
        return sfreeindex
    }
    aCache := s.allocCache
    bitIndex := sys.Ctz64(aCache)
    for bitIndex == 64 { //allocCache为0，没有一个空闲对象，说么要更新一下allocCache了
        // 找到下一个缓存的地址。这个是吧sfreeindex取向上64的倍数
        sfreeindex = (sfreeindex + 64) &^ (64 - 1)
        if sfreeindex >= snelems {
            // 说明真的没了
            s.freeindex = snelems
            return snelems
        }
        // 只是缓存的值不行了，更新一下allocCache就好
        whichByte := sfreeindex / 8 // sfreeindex是64的倍数,不需要担心整除的问题
        s.refillAllocCache(whichByte)
        aCache = s.allocCache
        bitIndex = sys.Ctz64(aCache)
    }
    result := sfreeindex + uintptr(bitIndex)
    if result >= snelems {
        s.freeindex = snelems
        return snelems
    }
    s.allocCache >>= uint(bitIndex + 1)
    sfreeindex = result + 1
    if sfreeindex%64 == 0 && sfreeindex != snelems {
        whichByte := sfreeindex / 8
        s.refillAllocCache(whichByte)
    }
    s.freeindex = sfreeindex
    return result
}

retry:
    for s = c.nonempty.first; s != nil; s = s.next {
        if s.sweepgen == sg-2 && atomic.Cas(&s.sweepgen, sg-2, sg-1) {
            //至少有一个可以使用的对象。
            //待会分配完就不保证还有了，所以放入empty中。
            c.nonempty.remove(s)
            c.empty.insertBack(s)
            unlock(&c.lock)
            s.sweep(true)
            goto havespan
        }
        if s.sweepgen == sg-1 {
            // 正在清扫，下一个
            // the span is being swept by background sweeper, skip
            continue
        }
        // 请扫过了 可以直接用
        // we have a nonempty span that does not require sweeping, allocate from it
        c.nonempty.remove(s)
        c.empty.insertBack(s)
        unlock(&c.lock)
        goto havespan
    }

for s = c.empty.first; s != nil; s = s.next {
        // 需要清扫
        if s.sweepgen == sg-2 && atomic.Cas(&s.sweepgen, sg-2, sg-1) {
            //这个链表遍历操作很秀，下面的remove和inertBack
            c.empty.remove(s)
            c.empty.insertBack(s) //现在s是链表末尾且s.next=nil
            unlock(&c.lock)
            s.sweep(true)
            freeIndex := s.nextFreeIndex()
            if freeIndex != s.nelems {
                s.freeindex = freeIndex
                //找到空闲的就返回了。
                goto havespan
            }
            lock(&c.lock)
            //这里会回到函数开头。
            goto retry
        }
        if s.sweepgen == sg-1 {
            // the span is being swept by background sweeper, skip
            continue
        }
        // already swept empty span,
        // all subsequent ones must also be either swept or in process of sweeping
        break
    }

for i := int(npage); i < len(h.free); i++ {
        list = &h.free[i]
        if !list.isEmpty() {
            s = list.first
            list.remove(s)
            goto HaveSpan
        }
    }

for t != nil {
        if t.spanKey == nil {
            throw("treap node with nil spanKey found")
        }
        if t.npagesKey < npages {
            t = t.right
        } else if t.left != nil && t.left.npagesKey >= npages {
            t = t.left
        } else {
            result := t.spanKey
            root.removeNode(t)
            return result
        }
    }