Programador GO: agora não é cooperativo?

requisitos de sistema

• compreensão dos princípios do agendador (embora eu tentarei explicar abaixo, “nos dedos”)
• entendendo como o coletor de lixo funciona
• entender o que é o assembler GO

Brevemente sobre o planejador

• Processadores P - lógicos (podemos alterar seu número com a função runtime.GOMAXPROCS), em cada processador lógico uma goroutine pode ser executada independentemente de cada vez.
• Threads do M - OS. Cada P é executado em um encadeamento de M. Observe que P nem sempre é igual a M; por exemplo, um encadeamento pode ser bloqueado por syscall e, em seguida, outro encadeamento será alocado para seu P. E há CGO e outras e outras nuances.
• G - gorutinas. Bem, aqui está claro, G deve ser executado em cada P e o planejador monitora isso.

E qual é o problema realmente?

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")
}

Analisar proposta

Você foi lá, GC?

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

Vamos seguir praticando

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. quando a goroutine for suspensa, se estiver em um estado de execução. A solicitação de suspensão vem do coletor de lixo. Aqui, talvez, não adicionarei código, mas ele pode ser encontrado no arquivo runtime / preempt.go (suspendG)
2. se o planejador decidir que a goroutine está funcionando por muito tempo, runtime / proc.go (retoke)
   

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

   
   forcePreemptNS - constante igual a 10ms, pd.schedwhen - horário em que o agendador do fluxo pd foi chamado pela última vez
   
3. além de todos os fluxos, esse sinal é enviado durante um pânico, StopTheWorld (GC) e mais alguns casos (que eu tenho que ignorar, porque o tamanho do artigo já vai além dos limites)

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 se G quer ser forçado a sair, aqui, por exemplo, a validade do status atual da goroutina será verificada.
2. isAsyncSafePoint - verifique se ele pode estar lotado no momento. A verificação mais interessante aqui é se G está em um ponto seguro ou não. Além disso, devemos ter certeza de que o encadeamento no qual G está executando também está pronto para antecipar G.

E mais sobre inseguros

//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
	}

Conclusão