add code

cch123 · cch123 · commit ca9802f893f8 · 2018-07-03T20:52:26.000+08:00
diff --git a/map.md b/map.md
@@ -360,8 +360,226 @@ done:
 
 ## 删除
 
+```go
+func mapdelete(t *maptype, h *hmap, key unsafe.Pointer) {
+    if h == nil || h.count == 0 {
+        return
+    }
+    if h.flags&hashWriting != 0 {
+        throw("concurrent map writes")
+    }
+
+    alg := t.key.alg
+    hash := alg.hash(key, uintptr(h.hash0))
+
+    // Set hashWriting after calling alg.hash, since alg.hash may panic,
+    // in which case we have not actually done a write (delete).
+    h.flags |= hashWriting
+
+    bucket := hash & bucketMask(h.B)
+    if h.growing() {
+        growWork(t, h, bucket)
+    }
+    b := (*bmap)(add(h.buckets, bucket*uintptr(t.bucketsize)))
+    top := tophash(hash)
+search:
+    for ; b != nil; b = b.overflow(t) {
+        for i := uintptr(0); i < bucketCnt; i++ {
+            if b.tophash[i] != top {
+                continue
+            }
+            k := add(unsafe.Pointer(b), dataOffset+i*uintptr(t.keysize))
+            k2 := k
+            if t.indirectkey {
+                k2 = *((*unsafe.Pointer)(k2))
+            }
+            if !alg.equal(key, k2) {
+                continue
+            }
+            // Only clear key if there are pointers in it.
+            if t.indirectkey {
+                *(*unsafe.Pointer)(k) = nil
+            } else if t.key.kind&kindNoPointers == 0 {
+                memclrHasPointers(k, t.key.size)
+            }
+            v := add(unsafe.Pointer(b), dataOffset+bucketCnt*uintptr(t.keysize)+i*uintptr(t.valuesize))
+            if t.indirectvalue {
+                *(*unsafe.Pointer)(v) = nil
+            } else if t.elem.kind&kindNoPointers == 0 {
+                memclrHasPointers(v, t.elem.size)
+            } else {
+                memclrNoHeapPointers(v, t.elem.size)
+            }
+            b.tophash[i] = empty
+            h.count--
+            break search
+        }
+    }
+
+    if h.flags&hashWriting == 0 {
+        throw("concurrent map writes")
+    }
+    h.flags &^= hashWriting
+}
+```
+
 ## 扩容
 
+```go
+func growWork(t *maptype, h *hmap, bucket uintptr) {
+    // make sure we evacuate the oldbucket corresponding
+    // to the bucket we're about to use
+    evacuate(t, h, bucket&h.oldbucketmask())
+
+    // evacuate one more oldbucket to make progress on growing
+    if h.growing() {
+        evacuate(t, h, h.nevacuate)
+    }
+}
+```
+
+```go
+func evacuate(t *maptype, h *hmap, oldbucket uintptr) {
+    b := (*bmap)(add(h.oldbuckets, oldbucket*uintptr(t.bucketsize)))
+    newbit := h.noldbuckets()
+    if !evacuated(b) {
+        // TODO: reuse overflow buckets instead of using new ones, if there
+        // is no iterator using the old buckets.  (If !oldIterator.)
+
+        // xy contains the x and y (low and high) evacuation destinations.
+        var xy [2]evacDst
+        x := &xy[0]
+        x.b = (*bmap)(add(h.buckets, oldbucket*uintptr(t.bucketsize)))
+        x.k = add(unsafe.Pointer(x.b), dataOffset)
+        x.v = add(x.k, bucketCnt*uintptr(t.keysize))
+
+        if !h.sameSizeGrow() {
+            // Only calculate y pointers if we're growing bigger.
+            // Otherwise GC can see bad pointers.
+            y := &xy[1]
+            y.b = (*bmap)(add(h.buckets, (oldbucket+newbit)*uintptr(t.bucketsize)))
+            y.k = add(unsafe.Pointer(y.b), dataOffset)
+            y.v = add(y.k, bucketCnt*uintptr(t.keysize))
+        }
+
+        for ; b != nil; b = b.overflow(t) {
+            k := add(unsafe.Pointer(b), dataOffset)
+            v := add(k, bucketCnt*uintptr(t.keysize))
+            for i := 0; i < bucketCnt; i, k, v = i+1, add(k, uintptr(t.keysize)), add(v, uintptr(t.valuesize)) {
+                top := b.tophash[i]
+                if top == empty {
+                    b.tophash[i] = evacuatedEmpty
+                    continue
+                }
+                if top < minTopHash {
+                    throw("bad map state")
+                }
+                k2 := k
+                if t.indirectkey {
+                    k2 = *((*unsafe.Pointer)(k2))
+                }
+                var useY uint8
+                if !h.sameSizeGrow() {
+                    // Compute hash to make our evacuation decision (whether we need
+                    // to send this key/value to bucket x or bucket y).
+                    hash := t.key.alg.hash(k2, uintptr(h.hash0))
+                    if h.flags&iterator != 0 && !t.reflexivekey && !t.key.alg.equal(k2, k2) {
+                        // If key != key (NaNs), then the hash could be (and probably
+                        // will be) entirely different from the old hash. Moreover,
+                        // it isn't reproducible. Reproducibility is required in the
+                        // presence of iterators, as our evacuation decision must
+                        // match whatever decision the iterator made.
+                        // Fortunately, we have the freedom to send these keys either
+                        // way. Also, tophash is meaningless for these kinds of keys.
+                        // We let the low bit of tophash drive the evacuation decision.
+                        // We recompute a new random tophash for the next level so
+                        // these keys will get evenly distributed across all buckets
+                        // after multiple grows.
+                        useY = top & 1
+                        top = tophash(hash)
+                    } else {
+                        if hash&newbit != 0 {
+                            useY = 1
+                        }
+                    }
+                }
+
+                if evacuatedX+1 != evacuatedY {
+                    throw("bad evacuatedN")
+                }
+
+                b.tophash[i] = evacuatedX + useY // evacuatedX + 1 == evacuatedY
+                dst := &xy[useY]                 // evacuation destination
+
+                if dst.i == bucketCnt {
+                    dst.b = h.newoverflow(t, dst.b)
+                    dst.i = 0
+                    dst.k = add(unsafe.Pointer(dst.b), dataOffset)
+                    dst.v = add(dst.k, bucketCnt*uintptr(t.keysize))
+                }
+                dst.b.tophash[dst.i&(bucketCnt-1)] = top // mask dst.i as an optimization, to avoid a bounds check
+                if t.indirectkey {
+                    *(*unsafe.Pointer)(dst.k) = k2 // copy pointer
+                } else {
+                    typedmemmove(t.key, dst.k, k) // copy value
+                }
+                if t.indirectvalue {
+                    *(*unsafe.Pointer)(dst.v) = *(*unsafe.Pointer)(v)
+                } else {
+                    typedmemmove(t.elem, dst.v, v)
+                }
+                dst.i++
+                // These updates might push these pointers past the end of the
+                // key or value arrays.  That's ok, as we have the overflow pointer
+                // at the end of the bucket to protect against pointing past the
+                // end of the bucket.
+                dst.k = add(dst.k, uintptr(t.keysize))
+                dst.v = add(dst.v, uintptr(t.valuesize))
+            }
+        }
+        // Unlink the overflow buckets & clear key/value to help GC.
+        if h.flags&oldIterator == 0 && t.bucket.kind&kindNoPointers == 0 {
+            b := add(h.oldbuckets, oldbucket*uintptr(t.bucketsize))
+            // Preserve b.tophash because the evacuation
+            // state is maintained there.
+            ptr := add(b, dataOffset)
+            n := uintptr(t.bucketsize) - dataOffset
+            memclrHasPointers(ptr, n)
+        }
+    }
+
+    if oldbucket == h.nevacuate {
+        advanceEvacuationMark(h, t, newbit)
+    }
+}
+```
+
+```go
+func advanceEvacuationMark(h *hmap, t *maptype, newbit uintptr) {
+    h.nevacuate++
+    // Experiments suggest that 1024 is overkill by at least an order of magnitude.
+    // Put it in there as a safeguard anyway, to ensure O(1) behavior.
+    stop := h.nevacuate + 1024
+    if stop > newbit {
+        stop = newbit
+    }
+    for h.nevacuate != stop && bucketEvacuated(t, h, h.nevacuate) {
+        h.nevacuate++
+    }
+    if h.nevacuate == newbit { // newbit == # of oldbuckets
+        // Growing is all done. Free old main bucket array.
+        h.oldbuckets = nil
+        // Can discard old overflow buckets as well.
+        // If they are still referenced by an iterator,
+        // then the iterator holds a pointers to the slice.
+        if h.extra != nil {
+            h.extra.oldoverflow = nil
+        }
+        h.flags &^= sameSizeGrow
+    }
+}
+```
+
 ## 其它
 
 针对 32 位、64 位 和 string 类型的 map 元素的访问、赋值、删除、扩容，Go 内部有都有对应的优化函数，比如 mapaccess1 对应有 mapaccess1_fast64，mapaccess1_fast32，mapaccess1_faststr。mapassign 对应有 mapassign_fast64，mapassign_fast32 和 mapassign_faststr。
