1 // Copyright 2009 The Go Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style
3 // license that can be found in the LICENSE file.
5 // Garbage collector: sweeping
7 // The sweeper consists of two different algorithms:
9 // * The object reclaimer finds and frees unmarked slots in spans. It
10 // can free a whole span if none of the objects are marked, but that
11 // isn't its goal. This can be driven either synchronously by
12 // mcentral.cacheSpan for mcentral spans, or asynchronously by
13 // sweepone, which looks at all the mcentral lists.
15 // * The span reclaimer looks for spans that contain no marked objects
16 // and frees whole spans. This is a separate algorithm because
17 // freeing whole spans is the hardest task for the object reclaimer,
18 // but is critical when allocating new spans. The entry point for
19 // this is mheap_.reclaim and it's driven by a sequential scan of
20 // the page marks bitmap in the heap arenas.
22 // Both algorithms ultimately call mspan.sweep, which sweeps a single
28 "runtime/internal/atomic"
34 // State of background sweep.
35 type sweepdata struct {
44 // active tracks outstanding sweepers and the sweep
45 // termination condition.
48 // centralIndex is the current unswept span class.
49 // It represents an index into the mcentral span
50 // sets. Accessed and updated via its load and
51 // update methods. Not protected by a lock.
53 // Reset at mark termination.
54 // Used by mheap.nextSpanForSweep.
55 centralIndex sweepClass
58 // sweepClass is a spanClass and one bit to represent whether we're currently
59 // sweeping partial or full spans.
60 type sweepClass uint32
63 numSweepClasses = numSpanClasses * 2
64 sweepClassDone sweepClass = sweepClass(^uint32(0))
67 func (s *sweepClass) load() sweepClass {
68 return sweepClass(atomic.Load((*uint32)(s)))
71 func (s *sweepClass) update(sNew sweepClass) {
72 // Only update *s if its current value is less than sNew,
73 // since *s increases monotonically.
75 for sOld < sNew && !atomic.Cas((*uint32)(s), uint32(sOld), uint32(sNew)) {
78 // TODO(mknyszek): This isn't the only place we have
79 // an atomic monotonically increasing counter. It would
80 // be nice to have an "atomic max" which is just implemented
81 // as the above on most architectures. Some architectures
82 // like RISC-V however have native support for an atomic max.
85 func (s *sweepClass) clear() {
86 atomic.Store((*uint32)(s), 0)
89 // split returns the underlying span class as well as
90 // whether we're interested in the full or partial
91 // unswept lists for that class, indicated as a boolean
92 // (true means "full").
93 func (s sweepClass) split() (spc spanClass, full bool) {
94 return spanClass(s >> 1), s&1 == 0
97 // nextSpanForSweep finds and pops the next span for sweeping from the
98 // central sweep buffers. It returns ownership of the span to the caller.
99 // Returns nil if no such span exists.
100 func (h *mheap) nextSpanForSweep() *mspan {
102 for sc := sweep.centralIndex.load(); sc < numSweepClasses; sc++ {
103 spc, full := sc.split()
104 c := &h.central[spc].mcentral
107 s = c.fullUnswept(sg).pop()
109 s = c.partialUnswept(sg).pop()
112 // Write down that we found something so future sweepers
113 // can start from here.
114 sweep.centralIndex.update(sc)
118 // Write down that we found nothing.
119 sweep.centralIndex.update(sweepClassDone)
123 const sweepDrainedMask = 1 << 31
125 // activeSweep is a type that captures whether sweeping
126 // is done, and whether there are any outstanding sweepers.
128 // Every potential sweeper must call begin() before they look
129 // for work, and end() after they've finished sweeping.
130 type activeSweep struct {
131 // state is divided into two parts.
133 // The top bit (masked by sweepDrainedMask) is a boolean
134 // value indicating whether all the sweep work has been
135 // drained from the queue.
137 // The rest of the bits are a counter, indicating the
138 // number of outstanding concurrent sweepers.
142 // begin registers a new sweeper. Returns a sweepLocker
143 // for acquiring spans for sweeping. Any outstanding sweeper blocks
144 // sweep termination.
146 // If the sweepLocker is invalid, the caller can be sure that all
147 // outstanding sweep work has been drained, so there is nothing left
148 // to sweep. Note that there may be sweepers currently running, so
149 // this does not indicate that all sweeping has completed.
151 // Even if the sweepLocker is invalid, its sweepGen is always valid.
152 func (a *activeSweep) begin() sweepLocker {
154 state := a.state.Load()
155 if state&sweepDrainedMask != 0 {
156 return sweepLocker{mheap_.sweepgen, false}
158 if a.state.CompareAndSwap(state, state+1) {
159 return sweepLocker{mheap_.sweepgen, true}
164 // end deregisters a sweeper. Must be called once for each time
165 // begin is called if the sweepLocker is valid.
166 func (a *activeSweep) end(sl sweepLocker) {
167 if sl.sweepGen != mheap_.sweepgen {
168 throw("sweeper left outstanding across sweep generations")
171 state := a.state.Load()
172 if (state&^sweepDrainedMask)-1 >= sweepDrainedMask {
173 throw("mismatched begin/end of activeSweep")
175 if a.state.CompareAndSwap(state, state-1) {
176 if state != sweepDrainedMask {
179 if debug.gcpacertrace > 0 {
180 print("pacer: sweep done at heap size ", gcController.heapLive>>20, "MB; allocated ", (gcController.heapLive-mheap_.sweepHeapLiveBasis)>>20, "MB during sweep; swept ", mheap_.pagesSwept.Load(), " pages at ", mheap_.sweepPagesPerByte, " pages/byte\n")
187 // markDrained marks the active sweep cycle as having drained
188 // all remaining work. This is safe to be called concurrently
189 // with all other methods of activeSweep, though may race.
191 // Returns true if this call was the one that actually performed
193 func (a *activeSweep) markDrained() bool {
195 state := a.state.Load()
196 if state&sweepDrainedMask != 0 {
199 if a.state.CompareAndSwap(state, state|sweepDrainedMask) {
205 // sweepers returns the current number of active sweepers.
206 func (a *activeSweep) sweepers() uint32 {
207 return a.state.Load() &^ sweepDrainedMask
210 // isDone returns true if all sweep work has been drained and no more
211 // outstanding sweepers exist. That is, when the sweep phase is
213 func (a *activeSweep) isDone() bool {
214 return a.state.Load() == sweepDrainedMask
217 // reset sets up the activeSweep for the next sweep cycle.
219 // The world must be stopped.
220 func (a *activeSweep) reset() {
225 // finishsweep_m ensures that all spans are swept.
227 // The world must be stopped. This ensures there are no sweeps in
231 func finishsweep_m() {
234 // Sweeping must be complete before marking commences, so
235 // sweep any unswept spans. If this is a concurrent GC, there
236 // shouldn't be any spans left to sweep, so this should finish
237 // instantly. If GC was forced before the concurrent sweep
238 // finished, there may be spans to sweep.
239 for sweepone() != ^uintptr(0) {
243 // Make sure there aren't any outstanding sweepers left.
244 // At this point, with the world stopped, it means one of two
245 // things. Either we were able to preempt a sweeper, or that
246 // a sweeper didn't call sweep.active.end when it should have.
247 // Both cases indicate a bug, so throw.
248 if sweep.active.sweepers() != 0 {
249 throw("active sweepers found at start of mark phase")
252 // Reset all the unswept buffers, which should be empty.
253 // Do this in sweep termination as opposed to mark termination
254 // so that we can catch unswept spans and reclaim blocks as
256 sg := mheap_.sweepgen
257 for i := range mheap_.central {
258 c := &mheap_.central[i].mcentral
259 c.partialUnswept(sg).reset()
260 c.fullUnswept(sg).reset()
263 // Sweeping is done, so if the scavenger isn't already awake,
264 // wake it up. There's definitely work for it to do at this
268 nextMarkBitArenaEpoch()
271 func bgsweep(c chan int) {
274 lockInit(&sweep.lock, lockRankSweep)
278 goparkunlock(&sweep.lock, waitReasonGCSweepWait, traceEvGoBlock, 1)
281 for sweepone() != ^uintptr(0) {
285 for freeSomeWbufs(true) {
290 // This can happen if a GC runs between
291 // gosweepone returning ^0 above
292 // and the lock being acquired.
297 goparkunlock(&sweep.lock, waitReasonGCSweepWait, traceEvGoBlock, 1)
301 // sweepLocker acquires sweep ownership of spans.
302 type sweepLocker struct {
303 // sweepGen is the sweep generation of the heap.
308 // sweepLocked represents sweep ownership of a span.
309 type sweepLocked struct {
313 // tryAcquire attempts to acquire sweep ownership of span s. If it
314 // successfully acquires ownership, it blocks sweep completion.
315 func (l *sweepLocker) tryAcquire(s *mspan) (sweepLocked, bool) {
317 throw("use of invalid sweepLocker")
319 // Check before attempting to CAS.
320 if atomic.Load(&s.sweepgen) != l.sweepGen-2 {
321 return sweepLocked{}, false
323 // Attempt to acquire sweep ownership of s.
324 if !atomic.Cas(&s.sweepgen, l.sweepGen-2, l.sweepGen-1) {
325 return sweepLocked{}, false
327 return sweepLocked{s}, true
330 // sweepone sweeps some unswept heap span and returns the number of pages returned
331 // to the heap, or ^uintptr(0) if there was nothing to sweep.
332 func sweepone() uintptr {
335 // Increment locks to ensure that the goroutine is not preempted
336 // in the middle of sweep thus leaving the span in an inconsistent state for next GC
339 // TODO(austin): sweepone is almost always called in a loop;
340 // lift the sweepLocker into its callers.
341 sl := sweep.active.begin()
347 // Find a span to sweep.
348 npages := ^uintptr(0)
351 s := mheap_.nextSpanForSweep()
353 noMoreWork = sweep.active.markDrained()
356 if state := s.state.get(); state != mSpanInUse {
357 // This can happen if direct sweeping already
358 // swept this span, but in that case the sweep
359 // generation should always be up-to-date.
360 if !(s.sweepgen == sl.sweepGen || s.sweepgen == sl.sweepGen+3) {
361 print("runtime: bad span s.state=", state, " s.sweepgen=", s.sweepgen, " sweepgen=", sl.sweepGen, "\n")
362 throw("non in-use span in unswept list")
366 if s, ok := sl.tryAcquire(s); ok {
367 // Sweep the span we found.
370 // Whole span was freed. Count it toward the
371 // page reclaimer credit since these pages can
372 // now be used for span allocation.
373 mheap_.reclaimCredit.Add(npages)
375 // Span is still in-use, so this returned no
376 // pages to the heap and the span needs to
377 // move to the swept in-use list.
386 // The sweep list is empty. There may still be
387 // concurrent sweeps running, but we're at least very
388 // close to done sweeping.
390 // Move the scavenge gen forward (signaling
391 // that there's new work to do) and wake the scavenger.
393 // The scavenger is signaled by the last sweeper because once
394 // sweeping is done, we will definitely have useful work for
395 // the scavenger to do, since the scavenger only runs over the
396 // heap once per GC cycle. This update is not done during sweep
397 // termination because in some cases there may be a long delay
398 // between sweep done and sweep termination (e.g. not enough
399 // allocations to trigger a GC) which would be nice to fill in
400 // with scavenging work.
403 mheap_.pages.scavengeStartGen()
413 // isSweepDone reports whether all spans are swept.
415 // Note that this condition may transition from false to true at any
416 // time as the sweeper runs. It may transition from true to false if a
417 // GC runs; to prevent that the caller must be non-preemptible or must
418 // somehow block GC progress.
419 func isSweepDone() bool {
420 return sweep.active.isDone()
423 // Returns only when span s has been swept.
426 func (s *mspan) ensureSwept() {
427 // Caller must disable preemption.
428 // Otherwise when this function returns the span can become unswept again
429 // (if GC is triggered on another goroutine).
431 if _g_.m.locks == 0 && _g_.m.mallocing == 0 && _g_ != _g_.m.g0 {
432 throw("mspan.ensureSwept: m is not locked")
435 // If this operation fails, then that means that there are
436 // no more spans to be swept. In this case, either s has already
437 // been swept, or is about to be acquired for sweeping and swept.
438 sl := sweep.active.begin()
440 // The caller must be sure that the span is a mSpanInUse span.
441 if s, ok := sl.tryAcquire(s); ok {
449 // Unfortunately we can't sweep the span ourselves. Somebody else
450 // got to it first. We don't have efficient means to wait, but that's
451 // OK, it will be swept fairly soon.
453 spangen := atomic.Load(&s.sweepgen)
454 if spangen == sl.sweepGen || spangen == sl.sweepGen+3 {
461 // Sweep frees or collects finalizers for blocks not marked in the mark phase.
462 // It clears the mark bits in preparation for the next GC round.
463 // Returns true if the span was returned to heap.
464 // If preserve=true, don't return it to heap nor relink in mcentral lists;
465 // caller takes care of it.
466 func (sl *sweepLocked) sweep(preserve bool) bool {
467 // It's critical that we enter this function with preemption disabled,
468 // GC must not start while we are in the middle of this function.
470 if _g_.m.locks == 0 && _g_.m.mallocing == 0 && _g_ != _g_.m.g0 {
471 throw("mspan.sweep: m is not locked")
476 // We'll release ownership of this span. Nil it out to
477 // prevent the caller from accidentally using it.
481 sweepgen := mheap_.sweepgen
482 if state := s.state.get(); state != mSpanInUse || s.sweepgen != sweepgen-1 {
483 print("mspan.sweep: state=", state, " sweepgen=", s.sweepgen, " mheap.sweepgen=", sweepgen, "\n")
484 throw("mspan.sweep: bad span state")
488 traceGCSweepSpan(s.npages * _PageSize)
491 mheap_.pagesSwept.Add(int64(s.npages))
496 // The allocBits indicate which unmarked objects don't need to be
497 // processed since they were free at the end of the last GC cycle
498 // and were not allocated since then.
499 // If the allocBits index is >= s.freeindex and the bit
500 // is not marked then the object remains unallocated
501 // since the last GC.
502 // This situation is analogous to being on a freelist.
504 // Unlink & free special records for any objects we're about to free.
505 // Two complications here:
506 // 1. An object can have both finalizer and profile special records.
507 // In such case we need to queue finalizer for execution,
508 // mark the object as live and preserve the profile special.
509 // 2. A tiny object can have several finalizers setup for different offsets.
510 // If such object is not marked, we need to queue all finalizers at once.
511 // Both 1 and 2 are possible at the same time.
512 hadSpecials := s.specials != nil
513 siter := newSpecialsIter(s)
515 // A finalizer can be set for an inner byte of an object, find object beginning.
516 objIndex := uintptr(siter.s.offset) / size
517 p := s.base() + objIndex*size
518 mbits := s.markBitsForIndex(objIndex)
519 if !mbits.isMarked() {
520 // This object is not marked and has at least one special record.
521 // Pass 1: see if it has at least one finalizer.
523 endOffset := p - s.base() + size
524 for tmp := siter.s; tmp != nil && uintptr(tmp.offset) < endOffset; tmp = tmp.next {
525 if tmp.kind == _KindSpecialFinalizer {
526 // Stop freeing of object if it has a finalizer.
527 mbits.setMarkedNonAtomic()
532 // Pass 2: queue all finalizers _or_ handle profile record.
533 for siter.valid() && uintptr(siter.s.offset) < endOffset {
534 // Find the exact byte for which the special was setup
535 // (as opposed to object beginning).
537 p := s.base() + uintptr(special.offset)
538 if special.kind == _KindSpecialFinalizer || !hasFin {
539 siter.unlinkAndNext()
540 freeSpecial(special, unsafe.Pointer(p), size)
542 // The object has finalizers, so we're keeping it alive.
543 // All other specials only apply when an object is freed,
544 // so just keep the special record.
549 // object is still live
550 if siter.s.kind == _KindSpecialReachable {
551 special := siter.unlinkAndNext()
552 (*specialReachable)(unsafe.Pointer(special)).reachable = true
553 freeSpecial(special, unsafe.Pointer(p), size)
555 // keep special record
560 if hadSpecials && s.specials == nil {
564 if debug.allocfreetrace != 0 || debug.clobberfree != 0 || raceenabled || msanenabled || asanenabled {
565 // Find all newly freed objects. This doesn't have to
566 // efficient; allocfreetrace has massive overhead.
567 mbits := s.markBitsForBase()
568 abits := s.allocBitsForIndex(0)
569 for i := uintptr(0); i < s.nelems; i++ {
570 if !mbits.isMarked() && (abits.index < s.freeindex || abits.isMarked()) {
571 x := s.base() + i*s.elemsize
572 if debug.allocfreetrace != 0 {
573 tracefree(unsafe.Pointer(x), size)
575 if debug.clobberfree != 0 {
576 clobberfree(unsafe.Pointer(x), size)
579 racefree(unsafe.Pointer(x), size)
582 msanfree(unsafe.Pointer(x), size)
585 asanpoison(unsafe.Pointer(x), size)
593 // Check for zombie objects.
594 if s.freeindex < s.nelems {
595 // Everything < freeindex is allocated and hence
596 // cannot be zombies.
598 // Check the first bitmap byte, where we have to be
599 // careful with freeindex.
601 if (*s.gcmarkBits.bytep(obj / 8)&^*s.allocBits.bytep(obj / 8))>>(obj%8) != 0 {
604 // Check remaining bytes.
605 for i := obj/8 + 1; i < divRoundUp(s.nelems, 8); i++ {
606 if *s.gcmarkBits.bytep(i)&^*s.allocBits.bytep(i) != 0 {
612 // Count the number of free objects in this span.
613 nalloc := uint16(s.countAlloc())
614 nfreed := s.allocCount - nalloc
615 if nalloc > s.allocCount {
616 // The zombie check above should have caught this in
618 print("runtime: nelems=", s.nelems, " nalloc=", nalloc, " previous allocCount=", s.allocCount, " nfreed=", nfreed, "\n")
619 throw("sweep increased allocation count")
622 s.allocCount = nalloc
623 s.freeindex = 0 // reset allocation index to start of span.
625 getg().m.p.ptr().traceReclaimed += uintptr(nfreed) * s.elemsize
628 // gcmarkBits becomes the allocBits.
629 // get a fresh cleared gcmarkBits in preparation for next GC
630 s.allocBits = s.gcmarkBits
631 s.gcmarkBits = newMarkBits(s.nelems)
633 // Initialize alloc bits cache.
634 s.refillAllocCache(0)
636 // The span must be in our exclusive ownership until we update sweepgen,
637 // check for potential races.
638 if state := s.state.get(); state != mSpanInUse || s.sweepgen != sweepgen-1 {
639 print("mspan.sweep: state=", state, " sweepgen=", s.sweepgen, " mheap.sweepgen=", sweepgen, "\n")
640 throw("mspan.sweep: bad span state after sweep")
642 if s.sweepgen == sweepgen+1 || s.sweepgen == sweepgen+3 {
643 throw("swept cached span")
646 // We need to set s.sweepgen = h.sweepgen only when all blocks are swept,
647 // because of the potential for a concurrent free/SetFinalizer.
649 // But we need to set it before we make the span available for allocation
650 // (return it to heap or mcentral), because allocation code assumes that a
651 // span is already swept if available for allocation.
653 // Serialization point.
654 // At this point the mark bits are cleared and allocation ready
655 // to go so release the span.
656 atomic.Store(&s.sweepgen, sweepgen)
658 if spc.sizeclass() != 0 {
659 // Handle spans for small objects.
661 // Only mark the span as needing zeroing if we've freed any
662 // objects, because a fresh span that had been allocated into,
663 // wasn't totally filled, but then swept, still has all of its
664 // free slots zeroed.
666 stats := memstats.heapStats.acquire()
667 atomic.Xadduintptr(&stats.smallFreeCount[spc.sizeclass()], uintptr(nfreed))
668 memstats.heapStats.release()
670 // Count the frees in the inconsistent, internal stats.
671 memstats.totalFree.Add(int64(nfreed) * int64(s.elemsize))
674 // The caller may not have removed this span from whatever
675 // unswept set its on but taken ownership of the span for
676 // sweeping by updating sweepgen. If this span still is in
677 // an unswept set, then the mcentral will pop it off the
678 // set, check its sweepgen, and ignore it.
680 // Free totally free span directly back to the heap.
684 // Return span back to the right mcentral list.
685 if uintptr(nalloc) == s.nelems {
686 mheap_.central[spc].mcentral.fullSwept(sweepgen).push(s)
688 mheap_.central[spc].mcentral.partialSwept(sweepgen).push(s)
691 } else if !preserve {
692 // Handle spans for large objects.
694 // Free large object span to heap.
696 // NOTE(rsc,dvyukov): The original implementation of efence
697 // in CL 22060046 used sysFree instead of sysFault, so that
698 // the operating system would eventually give the memory
699 // back to us again, so that an efence program could run
700 // longer without running out of memory. Unfortunately,
701 // calling sysFree here without any kind of adjustment of the
702 // heap data structures means that when the memory does
703 // come back to us, we have the wrong metadata for it, either in
704 // the mspan structures or in the garbage collection bitmap.
705 // Using sysFault here means that the program will run out of
706 // memory fairly quickly in efence mode, but at least it won't
707 // have mysterious crashes due to confused memory reuse.
708 // It should be possible to switch back to sysFree if we also
709 // implement and then call some kind of mheap.deleteSpan.
710 if debug.efence > 0 {
711 s.limit = 0 // prevent mlookup from finding this span
712 sysFault(unsafe.Pointer(s.base()), size)
717 // Count the free in the consistent, external stats.
718 stats := memstats.heapStats.acquire()
719 atomic.Xadduintptr(&stats.largeFreeCount, 1)
720 atomic.Xadduintptr(&stats.largeFree, size)
721 memstats.heapStats.release()
723 // Count the free in the inconsistent, internal stats.
724 memstats.totalFree.Add(int64(size))
729 // Add a large span directly onto the full+swept list.
730 mheap_.central[spc].mcentral.fullSwept(sweepgen).push(s)
735 // reportZombies reports any marked but free objects in s and throws.
737 // This generally means one of the following:
739 // 1. User code converted a pointer to a uintptr and then back
740 // unsafely, and a GC ran while the uintptr was the only reference to
743 // 2. User code (or a compiler bug) constructed a bad pointer that
744 // points to a free slot, often a past-the-end pointer.
746 // 3. The GC two cycles ago missed a pointer and freed a live object,
747 // but it was still live in the last cycle, so this GC cycle found a
748 // pointer to that object and marked it.
749 func (s *mspan) reportZombies() {
751 print("runtime: marked free object in span ", s, ", elemsize=", s.elemsize, " freeindex=", s.freeindex, " (bad use of unsafe.Pointer? try -d=checkptr)\n")
752 mbits := s.markBitsForBase()
753 abits := s.allocBitsForIndex(0)
754 for i := uintptr(0); i < s.nelems; i++ {
755 addr := s.base() + i*s.elemsize
757 alloc := i < s.freeindex || abits.isMarked()
763 if mbits.isMarked() {
768 zombie := mbits.isMarked() && !alloc
778 hexdumpWords(addr, addr+length, nil)
783 throw("found pointer to free object")
786 // deductSweepCredit deducts sweep credit for allocating a span of
787 // size spanBytes. This must be performed *before* the span is
788 // allocated to ensure the system has enough credit. If necessary, it
789 // performs sweeping to prevent going in to debt. If the caller will
790 // also sweep pages (e.g., for a large allocation), it can pass a
791 // non-zero callerSweepPages to leave that many pages unswept.
793 // deductSweepCredit makes a worst-case assumption that all spanBytes
794 // bytes of the ultimately allocated span will be available for object
797 // deductSweepCredit is the core of the "proportional sweep" system.
798 // It uses statistics gathered by the garbage collector to perform
799 // enough sweeping so that all pages are swept during the concurrent
800 // sweep phase between GC cycles.
802 // mheap_ must NOT be locked.
803 func deductSweepCredit(spanBytes uintptr, callerSweepPages uintptr) {
804 if mheap_.sweepPagesPerByte == 0 {
805 // Proportional sweep is done or disabled.
814 sweptBasis := mheap_.pagesSweptBasis.Load()
816 // Fix debt if necessary.
817 newHeapLive := uintptr(atomic.Load64(&gcController.heapLive)-mheap_.sweepHeapLiveBasis) + spanBytes
818 pagesTarget := int64(mheap_.sweepPagesPerByte*float64(newHeapLive)) - int64(callerSweepPages)
819 for pagesTarget > int64(mheap_.pagesSwept.Load()-sweptBasis) {
820 if sweepone() == ^uintptr(0) {
821 mheap_.sweepPagesPerByte = 0
824 if mheap_.pagesSweptBasis.Load() != sweptBasis {
825 // Sweep pacing changed. Recompute debt.
835 // clobberfree sets the memory content at x to bad content, for debugging
837 func clobberfree(x unsafe.Pointer, size uintptr) {
838 // size (span.elemsize) is always a multiple of 4.
839 for i := uintptr(0); i < size; i += 4 {
840 *(*uint32)(add(x, i)) = 0xdeadbeef
844 // gcPaceSweeper updates the sweeper's pacing parameters.
846 // Must be called whenever the GC's pacing is updated.
848 // The world must be stopped, or mheap_.lock must be held.
849 func gcPaceSweeper(trigger uint64) {
850 assertWorldStoppedOrLockHeld(&mheap_.lock)
852 // Update sweep pacing.
854 mheap_.sweepPagesPerByte = 0
856 // Concurrent sweep needs to sweep all of the in-use
857 // pages by the time the allocated heap reaches the GC
858 // trigger. Compute the ratio of in-use pages to sweep
859 // per byte allocated, accounting for the fact that
860 // some might already be swept.
861 heapLiveBasis := atomic.Load64(&gcController.heapLive)
862 heapDistance := int64(trigger) - int64(heapLiveBasis)
863 // Add a little margin so rounding errors and
864 // concurrent sweep are less likely to leave pages
865 // unswept when GC starts.
866 heapDistance -= 1024 * 1024
867 if heapDistance < _PageSize {
868 // Avoid setting the sweep ratio extremely high
869 heapDistance = _PageSize
871 pagesSwept := mheap_.pagesSwept.Load()
872 pagesInUse := mheap_.pagesInUse.Load()
873 sweepDistancePages := int64(pagesInUse) - int64(pagesSwept)
874 if sweepDistancePages <= 0 {
875 mheap_.sweepPagesPerByte = 0
877 mheap_.sweepPagesPerByte = float64(sweepDistancePages) / float64(heapDistance)
878 mheap_.sweepHeapLiveBasis = heapLiveBasis
879 // Write pagesSweptBasis last, since this
880 // signals concurrent sweeps to recompute
882 mheap_.pagesSweptBasis.Store(pagesSwept)