From ea4f14cf2bb525eb0cedee2c6bb97dfd3f761ab3 Mon Sep 17 00:00:00 2001 From: Austin Clements Date: Mon, 12 Jan 2015 13:45:40 -0500 Subject: [PATCH] runtime: rename var checkmark to checkmarkphase The old name was too ambiguous (is it a verb? is it a predicate? is it a constant?) and too close to debug.gccheckmark. Hopefully the new name conveys that this variable indicates that we are currently doing mark checking. Change-Id: I031cd48b0906cdc7774f5395281d3aeeb8ef3ec9 Reviewed-on: https://go-review.googlesource.com/2656 Reviewed-by: Rick Hudson --- src/runtime/mgc.go | 46 +++++++++++++++++++++++----------------------- 1 file changed, 23 insertions(+), 23 deletions(-) diff --git a/src/runtime/mgc.go b/src/runtime/mgc.go index 5f5e51d8899..3b086db9b43 100644 --- a/src/runtime/mgc.go +++ b/src/runtime/mgc.go @@ -233,10 +233,10 @@ func have_cgo_allocate() bool { // there are no more pointers in the object. This information is held // in the second nibble. -// When marking an object if the bool checkmark is true one uses the above +// When marking an object if the bool checkmarkphase is true one uses the above // encoding, otherwise one uses the bitMarked bit in the lower two bits // of the nibble. -var checkmark = false +var checkmarkphase = false // inheap reports whether b is a pointer into a (potentially dead) heap object. // It returns false for pointers into stack spans. @@ -380,7 +380,7 @@ func gcmarknewobject_m(obj uintptr) { if gcphase != _GCmarktermination { throw("marking new object while not in mark termination phase") } - if checkmark { // The world should be stopped so this should not happen. + if checkmarkphase { // The world should be stopped so this should not happen. throw("gcmarknewobject called while doing checkmark") } @@ -408,7 +408,7 @@ func greyobject(obj uintptr, base, off uintptr, mbits *markbits, wbuf *workbuf) throw("greyobject: obj not pointer-aligned") } - if checkmark { + if checkmarkphase { if !ismarked(mbits) { print("runtime:greyobject: checkmarks finds unexpected unmarked object obj=", hex(obj), ", mbits->bits=", hex(mbits.bits), " *mbits->bitp=", hex(*mbits.bitp), "\n") print("runtime: found obj at *(", hex(base), "+", hex(off), ")\n") @@ -452,7 +452,7 @@ func greyobject(obj uintptr, base, off uintptr, mbits *markbits, wbuf *workbuf) atomicor8(mbits.bitp, bitMarked<>(mbits.shift+2))&_BitsMask == _BitsDead { + if !checkmarkphase && (mbits.xbits>>(mbits.shift+2))&_BitsMask == _BitsDead { return wbuf // noscan object } @@ -534,7 +534,7 @@ func scanobject(b, n uintptr, ptrmask *uint8, wbuf *workbuf) *workbuf { } if bits&_BitsPointer != _BitsPointer { - print("gc checkmark=", checkmark, " b=", hex(b), " ptrmask=", ptrmask, " mbits.bitp=", mbits.bitp, " mbits.xbits=", hex(mbits.xbits), " bits=", hex(bits), "\n") + print("gc checkmarkphase=", checkmarkphase, " b=", hex(b), " ptrmask=", ptrmask, " mbits.bitp=", mbits.bitp, " mbits.xbits=", hex(mbits.xbits), " bits=", hex(bits), "\n") throw("unexpected garbage collection bits") } @@ -546,7 +546,7 @@ func scanobject(b, n uintptr, ptrmask *uint8, wbuf *workbuf) *workbuf { continue } - if mheap_.shadow_enabled && debug.wbshadow >= 2 && debug.gccheckmark > 0 && checkmark { + if mheap_.shadow_enabled && debug.wbshadow >= 2 && debug.gccheckmark > 0 && checkmarkphase { checkwbshadow((*uintptr)(unsafe.Pointer(b + i))) } @@ -682,7 +682,7 @@ func markroot(desc *parfor, i uint32) { if s.state != mSpanInUse { continue } - if !checkmark && s.sweepgen != sg { + if !checkmarkphase && s.sweepgen != sg { // sweepgen was updated (+2) during non-checkmark GC pass print("sweep ", s.sweepgen, " ", sg, "\n") throw("gc: unswept span") @@ -1038,7 +1038,7 @@ func shaded(slot uintptr) bool { return true } - if checkmark { + if checkmarkphase { return ischeckmarked(&mbits) } @@ -1274,7 +1274,7 @@ func mSpan_EnsureSwept(s *mspan) { // caller takes care of it. //TODO go:nowritebarrier func mSpan_Sweep(s *mspan, preserve bool) bool { - if checkmark { + if checkmarkphase { throw("MSpan_Sweep: checkmark only runs in STW and after the sweep") } @@ -1735,14 +1735,14 @@ func clearcheckmarkbitsspan(s *mspan) { // 10 - BitsPointer // 11 - unused, for us BitsPointerMarked // - // When called to prepare for the checkmark phase (checkmark==1), + // When called to prepare for the checkmark phase (checkmarkphase==true), // we change BitsDead to BitsScalar, so that there are no BitsScalarMarked // type bits anywhere. // // The checkmark phase marks by changing BitsScalar to BitsScalarMarked // and BitsPointer to BitsPointerMarked. // - // When called to clean up after the checkmark phase (checkmark==0), + // When called to clean up after the checkmark phase (checkmarkphase==false), // we unmark by changing BitsScalarMarked back to BitsScalar and // BitsPointerMarked back to BitsPointer. // @@ -1778,7 +1778,7 @@ func clearcheckmarkbitsspan(s *mspan) { throw("missing bitBoundary") } b := (*bitp & bitPtrMask) >> 2 - if !checkmark && (b == _BitsScalar || b == _BitsScalarMarked) { + if !checkmarkphase && (b == _BitsScalar || b == _BitsScalarMarked) { *bitp &^= 0x0c // convert to _BitsDead } else if b == _BitsScalarMarked || b == _BitsPointerMarked { *bitp &^= _BitsCheckMarkXor << 2 @@ -1788,7 +1788,7 @@ func clearcheckmarkbitsspan(s *mspan) { throw("missing bitBoundary") } b = ((*bitp >> gcBits) & bitPtrMask) >> 2 - if !checkmark && (b == _BitsScalar || b == _BitsScalarMarked) { + if !checkmarkphase && (b == _BitsScalar || b == _BitsScalarMarked) { *bitp &^= 0xc0 // convert to _BitsDead } else if b == _BitsScalarMarked || b == _BitsPointerMarked { *bitp &^= _BitsCheckMarkXor << (2 + gcBits) @@ -1802,12 +1802,12 @@ func clearcheckmarkbitsspan(s *mspan) { } b := (*bitp & bitPtrMask) >> 2 - if checkmark && b == _BitsDead { + if checkmarkphase && b == _BitsDead { // move BitsDead into second word. // set bits to BitsScalar in preparation for checkmark phase. *bitp &^= 0xc0 *bitp |= _BitsScalar << 2 - } else if !checkmark && (b == _BitsScalar || b == _BitsScalarMarked) && *bitp&0xc0 == 0 { + } else if !checkmarkphase && (b == _BitsScalar || b == _BitsScalarMarked) && *bitp&0xc0 == 0 { // Cleaning up after checkmark phase. // First word is scalar or dead (we forgot) // and second word is dead. @@ -1847,13 +1847,13 @@ func gccheckmark_m(startTime int64, eagersweep bool) { return } - if checkmark { - throw("gccheckmark_m, entered with checkmark already true") + if checkmarkphase { + throw("gccheckmark_m, entered with checkmarkphase already true") } - checkmark = true + checkmarkphase = true clearcheckmarkbits() // Converts BitsDead to BitsScalar. - gc_m(startTime, eagersweep) // turns off checkmark + calls clearcheckmarkbits + gc_m(startTime, eagersweep) // turns off checkmarkphase + calls clearcheckmarkbits } //go:nowritebarrier @@ -1963,7 +1963,7 @@ func gc(start_time int64, eagersweep bool) { t1 = nanotime() } - if !checkmark { + if !checkmarkphase { // TODO(austin) This is a noop beceause we should // already have swept everything to the current // sweepgen. @@ -2088,12 +2088,12 @@ func gc(start_time int64, eagersweep bool) { } if debug.gccheckmark > 0 { - if !checkmark { + if !checkmarkphase { // first half of two-pass; don't set up sweep unlock(&mheap_.lock) return } - checkmark = false // done checking marks + checkmarkphase = false // done checking marks clearcheckmarkbits() }