GO Scheduler: ¿Ahora no es cooperativo?

Requisitos del sistema

• comprensión de los principios del planificador (aunque trataré de explicar a continuación, "en los dedos")
• entender cómo funciona el recolector de basura
• entendiendo qué es el ensamblador GO

Brevemente sobre el planificador

• P - procesadores lógicos (podemos cambiar su número con el tiempo de ejecución. Función GOMAXPROCS), en cada procesador lógico se puede ejecutar una rutina de forma independiente a la vez.
• M: subprocesos del sistema operativo. Cada P se ejecuta en un subproceso de M. Tenga en cuenta que P no siempre es igual a M, por ejemplo, un subproceso puede ser bloqueado por syscall y luego se asignará otro subproceso para su P. Y hay CGO y otros y otros matices.
• G - gorutinas. Bueno, aquí está claro, G debe ejecutarse en cada P y el planificador lo monitorea.

¿Y cuál es el problema en realidad?

func main() {
	runtime.GOMAXPROCS(1)
	go func() {
		var u int
		for {
			u -= 2
			if u == 1 {
				break
			}
		}
	}()
	<-time.After(time.Millisecond * 5) //    main   ,         

	fmt.Println("go 1.13 has never been here")
}

Propuesta Parse

¿Fuiste allí, GC?

j := &someStruct{}
p := unsafe.Pointer(j)
// unsafe-point start
u := uintptr(p)
//do some stuff here
p = unsafe.Pointer(u)
// unsafe-point end

Pasemos a practicar

15.652 ( 0.003 ms): main/29614 tgkill(tgid: 29613 (main), pid: 29613 (main), sig: URG                ) = 0

func signalM(mp *m, sig int) {
	tgkill(getpid(), int(mp.procid), sig)
}

1. cuando goroutine se suspende, si está en estado de ejecución. La solicitud de suspensión proviene del recolector de basura. Aquí, quizás, no agregaré código, pero se puede encontrar en el archivo runtime / preempt.go (suspendG)
2. si el programador decide que goroutine funciona demasiado tiempo, runtime / proc.go (retomar)
   

   
   if pd.schedwhen+forcePreemptNS <= now {
   	signalM(_p_)
   }
   

   
   forcePreemptNS: constante igual a 10 ms, pd.schedwhen: hora en que se llamó por última vez al programador de la secuencia pd
   
3. Además de todas las transmisiones, esta señal se envía durante un pánico, StopTheWorld (GC) y algunos casos más (que tengo que omitir, porque el tamaño del artículo ya irá más allá de los límites)

func doSigPreempt(gp *g, ctxt *sigctxt) {
	if wantAsyncPreempt(gp) && isAsyncSafePoint(gp, ctxt.sigpc(), ctxt.sigsp(), ctxt.siglr()) {
		// Inject a call to asyncPreempt.
		ctxt.pushCall(funcPC(asyncPreempt))
	}
}

1. wantAsyncPreempt: verificamos si G quiere ser expulsado, aquí, por ejemplo, se verificará la validez del estado actual de la rutina.
2. isAsyncSafePoint: compruebe si se puede desplazar en este momento. Lo más interesante de las comprobaciones aquí es si G está en un punto seguro o inseguro. Además, debemos estar seguros de que el subproceso en el que se ejecuta G también está listo para evitar G.

Y más sobre inseguro

//go:nosplit
func infiniteLoop() {
	var u int
	for {
		u -= 2
		if u == 1 {
			break
		}
	}
}

func main() {
	runtime.GOMAXPROCS(1)
	go infiniteLoop()
	<-time.After(time.Millisecond * 5)

	fmt.Println("go 1.13 and 1.14 has never been here")
}

        0x0000 00000 (main.go:10)   TEXT    "".infiniteLoop(SB), NOSPLIT|ABIInternal, $0-0
        0x0000 00000 (main.go:10)   PCDATA  $0, $-2
        0x0000 00000 (main.go:10)   PCDATA  $1, $-2
        0x0000 00000 (main.go:10)   FUNCDATA        $0, gclocals·33cdeccccebe80329f1fdbee7f5874cb(SB)
        0x0000 00000 (main.go:10)   FUNCDATA        $1, gclocals·33cdeccccebe80329f1fdbee7f5874cb(SB)
        0x0000 00000 (main.go:10)   FUNCDATA        $2, gclocals·33cdeccccebe80329f1fdbee7f5874cb(SB)
        0x0000 00000 (main.go:10)   XORL    AX, AX
        0x0002 00002 (main.go:12)   JMP     8
        0x0004 00004 (main.go:13)   ADDQ    $-2, AX
        0x0008 00008 (main.go:14)   CMPQ    AX, $3
        0x000c 00012 (main.go:14)   JNE     4
        0x000e 00014 (main.go:15)   PCDATA  $0, $-1
        0x000e 00014 (main.go:15)   PCDATA  $1, $-1
        0x000e 00014 (main.go:15)   RET

	smi := pcdatavalue(f, _PCDATA_RegMapIndex, pc, nil)
	if smi == -2 {
		return false
	}

Conclusión