1. func gcBgMarkWorker(_p_ *p) {
    2.     gp := getg()
    4.     type parkInfo struct {
    5.         m      muintptr // Release this m on park.
    6.         attach puintptr // If non-nil, attach to this p on park.
    7.     }
    8.     // We pass park to a gopark unlock function, so it can't be on
    9.     // the stack (see gopark). Prevent deadlock from recursively
    10.     // starting GC by disabling preemption.
    11.     gp.m.preemptoff = "GC worker init"
    12.     park := new(parkInfo)
    13.     gp.m.preemptoff = ""
    15.     park.m.set(acquirem())
    16.     park.attach.set(_p_)
    17.     // Inform gcBgMarkStartWorkers that this worker is ready.
    18.     // After this point, the background mark worker is scheduled
    19.     // cooperatively by gcController.findRunnable. Hence, it must
    20.     // never be preempted, as this would put it into _Grunnable
    21.     // and put it on a run queue. Instead, when the preempt flag
    22.     // is set, this puts itself into _Gwaiting to be woken up by
    23.     // gcController.findRunnable at the appropriate time.
    24.     notewakeup(&work.bgMarkReady)
    26.     for {
    27.         // Go to sleep until woken by gcController.findRunnable.
    28.         // We can't releasem yet since even the call to gopark
    29.         // may be preempted.
    30.         gopark(func(g *g, parkp unsafe.Pointer) bool {
    31.             park := (*parkInfo)(parkp)
    33.             // The worker G is no longer running, so it's
    34.             // now safe to allow preemption.
    35.             releasem(park.m.ptr())
    37.             // If the worker isn't attached to its P,
    38.             // attach now. During initialization and after
    39.             // a phase change, the worker may have been
    40.             // running on a different P. As soon as we
    41.             // attach, the owner P may schedule the
    42.             // worker, so this must be done after the G is
    43.             // stopped.
    44.             if park.attach != 0 {
    45.                 p := park.attach.ptr()
    46.                 park.attach.set(nil)
    47.                 // cas the worker because we may be
    48.                 // racing with a new worker starting
    49.                 // on this P.
    50.                 if !p.gcBgMarkWorker.cas(0, guintptr(unsafe.Pointer(g))) {
    51.                     // The P got a new worker.
    52.                     // Exit this worker.
    53.                     return false
    54.                 }
    55.             }
    56.             return true
    57.         }, unsafe.Pointer(park), waitReasonGCWorkerIdle, traceEvGoBlock, 0)
    59.         // Loop until the P dies and disassociates this
    60.         // worker (the P may later be reused, in which case
    61.         // it will get a new worker) or we failed to associate.
    62.         if _p_.gcBgMarkWorker.ptr() != gp {
    63.             break
    64.         }
    66.         // Disable preemption so we can use the gcw. If the
    67.         // scheduler wants to preempt us, we'll stop draining,
    68.         // dispose the gcw, and then preempt.
    69.         park.m.set(acquirem())
    70.         (...)
    72.         startTime := nanotime()
    73.         _p_.gcMarkWorkerStartTime = startTime
    75.         decnwait := atomic.Xadd(&work.nwait, -1)
    76.         (...)
    78.         systemstack(func() {
    79.             // Mark our goroutine preemptible so its stack
    80.             // can be scanned. This lets two mark workers
    81.             // scan each other (otherwise, they would
    82.             // deadlock). We must not modify anything on
    83.             // the G stack. However, stack shrinking is
    84.             // disabled for mark workers, so it is safe to
    85.             // read from the G stack.
    86.             casgstatus(gp, _Grunning, _Gwaiting)
    87.             switch _p_.gcMarkWorkerMode {
    88.             (...)
    89.             case gcMarkWorkerDedicatedMode:
    90.                 gcDrain(&_p_.gcw, gcDrainUntilPreempt|gcDrainFlushBgCredit)
    91.                 if gp.preempt {
    92.                     // We were preempted. This is
    93.                     // a useful signal to kick
    94.                     // everything out of the run
    95.                     // queue so it can run
    96.                     // somewhere else.
    97.                     lock(&sched.lock)
    98.                     for {
    99.                         gp, _ := runqget(_p_)
    100.                         if gp == nil {
    101.                             break
    102.                         }
    103.                         globrunqput(gp)
    104.                     }
    105.                     unlock(&sched.lock)
    106.                 }
    107.                 // Go back to draining, this time
    108.                 // without preemption.
    109.                 gcDrain(&_p_.gcw, gcDrainFlushBgCredit)
    110.             case gcMarkWorkerFractionalMode:
    111.                 gcDrain(&_p_.gcw, gcDrainFractional|gcDrainUntilPreempt|gcDrainFlushBgCredit)
    112.             case gcMarkWorkerIdleMode:
    113.                 gcDrain(&_p_.gcw, gcDrainIdle|gcDrainUntilPreempt|gcDrainFlushBgCredit)
    114.             }
    115.             casgstatus(gp, _Gwaiting, _Grunning)
    116.         })
    118.         // Account for time.
    119.         duration := nanotime() - startTime
    120.         switch _p_.gcMarkWorkerMode {
    121.         case gcMarkWorkerDedicatedMode:
    122.             atomic.Xaddint64(&gcController.dedicatedMarkTime, duration)
    123.             atomic.Xaddint64(&gcController.dedicatedMarkWorkersNeeded, 1)
    124.         case gcMarkWorkerFractionalMode:
    125.             atomic.Xaddint64(&gcController.fractionalMarkTime, duration)
    126.             atomic.Xaddint64(&_p_.gcFractionalMarkTime, duration)
    127.         case gcMarkWorkerIdleMode:
    128.             atomic.Xaddint64(&gcController.idleMarkTime, duration)
    129.         }
    131.         // Was this the last worker and did we run out
    132.         // of work?
    133.         incnwait := atomic.Xadd(&work.nwait, +1)
    134.         if incnwait > work.nproc {
    135.             (...)
    136.         }
    138.         // If this worker reached a background mark completion
    139.         // point, signal the main GC goroutine.
    140.         if incnwait == work.nproc && !gcMarkWorkAvailable(nil) {
    141.             // Make this G preemptible and disassociate it
    142.             // as the worker for this P so
    143.             // findRunnableGCWorker doesn't try to
    144.             // schedule it.
    145.             _p_.gcBgMarkWorker.set(nil)
    146.             releasem(park.m.ptr())
    148.             gcMarkDone()
    150.             // Disable preemption and prepare to reattach
    151.             // to the P.
    152.             //
    153.             // We may be running on a different P at this
    154.             // point, so we can't reattach until this G is
    155.             // parked.
    156.             park.m.set(acquirem())
    157.             park.attach.set(_p_)
    158.         }
    159.     }
    160. }