runtime: mark map bucket slots as empty during map clear

So iterators that are in progress can know entries have been deleted and
terminate the iterator properly.

Update #55002
Update #56351
Fixes #59411

Change-Id: I924f16a00fe4ed6564f730a677348a6011d3fb67
Reviewed-on: https://go-review.googlesource.com/c/go/+/481935
Reviewed-by: Keith Randall <khr@golang.org>
Auto-Submit: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Run-TryBot: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Reviewed-by: Michael Knyszek <mknyszek@google.com>
Reviewed-by: Keith Randall <khr@google.com>
TryBot-Result: Gopher Robot <gobot@golang.org>

diff --git a/src/runtime/map.go b/src/runtime/map.go
index 273e315ea0d116a18b01b773d30991859f21fdb9..9c3a7e2b8cee5c39614e9248062de9e19ad15274 100644 (file)
--- a/src/runtime/map.go
+++ b/src/runtime/map.go
@@ -1008,6 +1008,22 @@ func mapclear(t *maptype, h *hmap) {
 
        h.flags ^= hashWriting
 
+       // Mark buckets empty, so existing iterators can be terminated, see issue #59411.
+       markBucketsEmpty := func(bucket unsafe.Pointer, mask uintptr) {
+               for i := uintptr(0); i <= mask; i++ {
+                       b := (*bmap)(add(bucket, i*uintptr(t.bucketsize)))
+                       for ; b != nil; b = b.overflow(t) {
+                               for i := uintptr(0); i < bucketCnt; i++ {
+                                       b.tophash[i] = emptyRest
+                               }
+                       }
+               }
+       }
+       markBucketsEmpty(h.buckets, bucketMask(h.B))
+       if oldBuckets := h.oldbuckets; oldBuckets != nil {
+               markBucketsEmpty(oldBuckets, h.oldbucketmask())
+       }
+
        h.flags &^= sameSizeGrow
        h.oldbuckets = nil
        h.nevacuate = 0

diff --git a/test/fixedbugs/issue59411.go b/test/fixedbugs/issue59411.go
new file mode 100644 (file)
index 0000000..fc35c98
--- /dev/null
+++ b/test/fixedbugs/issue59411.go
@@ -0,0 +1,77 @@
+// run
+
+// Copyright 2023 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package main
+
+import (
+       "math"
+       "reflect"
+)
+
+func main() {
+       for i := 0; i < 100; i++ {
+               f()
+               g()
+       }
+}
+
+func f() {
+       // Allocate map.
+       m := map[float64]int{}
+       // Fill to just before a growth trigger.
+       const N = 13 << 4 // 6.5 * 2 * 2^k
+       for i := 0; i < N; i++ {
+               m[math.NaN()] = i
+       }
+       // Trigger growth.
+       m[math.NaN()] = N
+
+       // Iterate through map.
+       i := 0
+       for range m {
+               if i == 6 {
+                       // Partway through iteration, clear the map.
+                       clear(m)
+               } else if i > 6 {
+                       // If we advance to the next iteration, that's a bug.
+                       panic("BAD")
+               }
+               i++
+       }
+       if len(m) != 0 {
+               panic("clear did not empty the map")
+       }
+}
+
+func g() {
+       // Allocate map.
+       m := map[float64]int{}
+       // Fill to just before a growth trigger.
+       const N = 13 << 4 // 6.5 * 2 * 2^k
+       for i := 0; i < N; i++ {
+               m[math.NaN()] = i
+       }
+       // Trigger growth.
+       m[math.NaN()] = N
+
+       // Iterate through map.
+       i := 0
+       v := reflect.ValueOf(m)
+       iter := v.MapRange()
+       for iter.Next() {
+               if i == 6 {
+                       // Partway through iteration, clear the map.
+                       v.Clear()
+               } else if i > 6 {
+                       // If we advance to the next iteration, that's a bug.
+                       panic("BAD")
+               }
+               i++
+       }
+       if v.Len() != 0 {
+               panic("clear did not empty the map")
+       }
+}