breve introducción

apilar

La pila inicial hilo OS es de 2 MB. idiomas Go, cada modo goroutine dinámica expansión, el 2KB inicial, crecimiento de la demanda, máximo 1G. Además GC se encogerá espacio de pila.
Por cierto, la extensión del crecimiento tiene un precio, es necesario copiar los datos a la nueva pila, por lo que el 2 KB inicial puede haber algunos problemas de rendimiento.
Más detalles acerca de la pila, se puede ver el hermano mayor del artículo. goroutine pila de chat

administración

Programación y gestión del ciclo de vida de los subprocesos de usuario son a nivel de usuario, Ir lenguaje de darse cuenta de su cuenta, sin la ayuda de las llamadas del sistema del sistema operativo, reducir el consumo de recursos del sistema.

GMP

modelo de lenguaje Go usando dos hilos, es decir, hilos de usuario y núcleo hilos KSE (entidad de planificación kernel) es M: N de. Goroutine o, eventualmente, será entregado a la ejecución de la hebra de OS, sino que requiere un intermediario para proporcionar un contexto. Este es el modelo GMP

G: goroutine, similar al bloque de control de proceso, la información de las tiendas de la pila, el estado, identificación, y otras funciones. P G puede estar unido a ser programado.
M: máquina, hilo OS, después de la unión P eficaz, en el horario.
P: procesador lógico, almacena varios colas de G. Para G, P es el núcleo de la CPU. Para M, P es el contexto. El número de P por GOMAXPROCSestablecer el máximo 256.
sched: planificador, excepto GRQ, cola desocupada M midle, cola P inactivo PReposo y la información de bloqueo

Aquí Insertar imagen Descripción

cola

Ir programador tiene dos cola de ejecución diferente:

El GRQ, cola de ejecución global, sin asignación al G P
El LRQ, cola de ejecución local, el LRQ Cada uno tiene un P, P a G se asignan a gestionar la ejecución

estado

go1.10\src\runtime\runtime2.go

_Gidle: dispensar el G, pero no inicializado
_Grunnable: En la cola de ejecución cola de ejecución, LRQ o GRQ
_Grunning: comando de ejecución tiene su propia pila. Cola de ejecución ejecute cola no se asigna a la M y P
_Gsyscall: la ejecución de la llamada al sistema, no la instrucción de usuario, no la cola de ejecución, apunta a M, P M para encontrar el ralentí
_Gwaiting: bloque. No RQ, pero puede esperar en la cola de espera del canal de cola
_Gdead: no utilizado. En la lista gfree P, no cola de ejecución. inactivo inactivo
_Gcopystack: expansión pila o GC contracción

El cambio de contexto

Ir Los eventos cambio de contexto planificador.

ir de palabras clave, crear goroutine
recolección de basura GC, GC es goroutine, por lo que toma tiempo rebanada
sistema de llamada de la llamada al sistema, bloque G actual
sincronización de sincronización, bloque G actual

despacho

Programación de propósitos es prevenir la obstrucción de M, de ocio, de conmutación de procesos del sistema.
Ver Golang - [Parte II] Análisis Programación

llamada asincrónica

Linux puede ser invocado por el epoll red logra colectivamente poller red N (Net Poller).

carreras G1 en M, P LRQ los otros tres G, N inactivo;
G1 red IO, De este modo se mueve a la N, M G continúa la ejecución de tomar otra LRQ. G2 fue tal cambio de contexto a M;
solicitud de red extremo G1, se recibe la respuesta, el G1 LRQ se mueve hacia atrás, a la espera de ejecución interruptor para M.

llamada sincrónica

Presentar las operaciones de IO

carreras G1 en M1, P LRQ los otros tres G;
llamadas síncronas G1, congestión M;
Programador de M1 y P se separa, en este momento sólo M1 G1, no P.
El M2 vinculante inactivo P, y G2 del interruptor de selección LRQ
final G1 operación de enchufar, LRQ volver movido. M1 de espera de inactividad.

tarea robar

Por encima de todo para evitar la obstrucción de M, M es tarea vacía para evitar robos

Dos P, P1, P2
Si P1 se ejecutan G-terminado, LRQ vaciar, P1 comenzó a robar tarea.
El primer caso, hay LRQ P2 G, P2 de P1 es la mitad del robado LRQ G
El segundo caso, P2 no LRQ, P1 robado de GRQ.

g0

Cada uno tiene una especial M G, g0. Se utiliza para ejecutar la programación, gc, gestión de la pila y otras tareas, por lo que la pila g0 llama pila programación. g0 pila no aumenta de forma automática, no gc, conjunto del sistema operativo de la rosca.

código

go1.10 \ src \ runtime \ proc.go

nuevo

// The minimum size of stack used by Go code
    var _StackMin = 2048

func newproc1(fn *funcval, argp *uint8, narg int32, callerpc uintptr) {
    _g_ := getg()
    _p_ := _g_.m.p.ptr()
    
    newg := gfget(_p_)
    if newg == nil {
        newg = malg(_StackMin)
    }    
    
    newg.startpc = fn.fn
    
    runqput(_p_, newg, true)
    
    if atomic.Load(&sched.npidle) != 0 && atomic.Load(&sched.nmspinning) == 0 && mainStarted {
        wakep()
    }
}

Obtener el G actual
Obtener actual P G,
G adquirió de gfree P, para evitar la re-crear un pequeño charco de significado
Si G no es reutilizable, el parámetro re-creado indica tamaño de la pila, a partir de 2KB, el apoyo para la expansión dinámica
El enqueue G, P colocado en el LRQ; debido a trabajos de robar mecanismo puede robar otra P P G de esta
Si cola de ejecución completo (longitud 256), se coloca en el GRQ, en el sched
intentos adicionales para ejecutar G P

comienzo

G no puede funcionar por sí mismo, debe ser dirigido por M

func mstart() {
    mstart1(0)
    
    mexit(osStack)
}

func mstart1(dummy int32) {
    _g_ := getg()

    if _g_ != _g_.m.g0 {
        throw("bad runtime·mstart")
    }    
    
    schedule()    
}

La adopción de la programación M, ejecución G

schdule

// One round of scheduler: find a runnable goroutine and execute it.
// Never returns.
func schedule() {
    _g_ := getg()
    
    var gp *g
    
    gp, inheritTime = runqget(_g_.m.p.ptr())
    
    execute(gp, inheritTime)
}