¿Qué es un Managed Language?
¿Qué es un lenguaje gestionado?
Un lenguaje gestionado es aquel que, a diferencia de un lenguaje no gestionado —es decir, uno que simplemente ejecuta la lógica definida por el programador sin desviarse significativamente de ella—, ejecuta en tiempo de ejecución (runtime) procesos como el GC, optimizaciones del runtime, green threads y el manejo de concurrencia, permitiendo que el usuario no tenga que realizar una gestión de bajo nivel potencialmente peligrosa.
Este tipo de lenguajes ofrece la ventaja de permitir al desarrollador concentrarse exclusivamente en la lógica de negocio; sin embargo, existe la contrapartida de que el programa real puede comportarse de manera distinta a la intuición del programador, lo que en ocasiones requiere una sintonización precisa del runtime.
En primer lugar, examinaremos el lenguaje Go, que es uno de los lenguajes gestionados más fieles a la filosofía minimalista y cuyo assembly es transparente.
Estructura binaria del lenguaje Go
| .text | .data | .gopclntab, .typelink, etc. |
|---|---|---|
| Código máquina a ejecutar | Datos a almacenar | Secciones del runtime del lenguaje |
Dado que el lenguaje Go no traduce el código a lenguaje máquina en una relación 1:1 según lo ingresado por el usuario, la lógica en la sección .text está estrechamente relacionada con las secciones del runtime del lenguaje.
Además, funciones como runtime.printnl(), que el usuario no escribió explícitamente, se añaden al assembly de la sección .text. A través de esta inserción automática de código, el lenguaje Go ayuda a liberar al desarrollador de la gestión manual.
Visualización solo de la función main en Go
Primero, escribamos un código de ejemplo sencillo, main.go, para observar la función main en una máquina AMD64.
1package main
2
3func sayHello(msg string) {
4 println(msg)
5}
6
7func main() {
8 sayHello("Hello World")
9}
A continuación, se compila de la siguiente manera:
1go build main.go
Go proporciona go tool para facilitar la depuración de bajo nivel.
Para visualizar únicamente el assembly correspondiente a la función main dentro del paquete main utilizando go tool, se ingresa la siguiente instrucción:
1go tool objdump -s "main\.main" ./main
Assembly
1TEXT main.main(SB) /home/yjlee/compare-assembly/go/main.go
2 main.go:7 0x468f60 493b6610 CMPQ SP, 0x10(R14)
3 main.go:7 0x468f64 762f JBE 0x468f95
4 main.go:7 0x468f66 55 PUSHQ BP
5 main.go:7 0x468f67 4889e5 MOVQ SP, BP
6 main.go:7 0x468f6a 4883ec10 SUBQ $0x10, SP
7 main.go:8 0x468f6e 90 NOPL
8 main.go:4 0x468f6f e8cca3fcff CALL runtime.printlock(SB)
9 main.go:4 0x468f74 488d05da290100 LEAQ 0x129da(IP), AX
10 main.go:4 0x468f7b bb0b000000 MOVL $0xb, BX
11 main.go:4 0x468f80 e83bacfcff CALL runtime.printstring(SB)
12 main.go:4 0x468f85 e8f6a5fcff CALL runtime.printnl(SB)
13 main.go:4 0x468f8a e811a4fcff CALL runtime.printunlock(SB)
14 main.go:9 0x468f8f 4883c410 ADDQ $0x10, SP
15 main.go:9 0x468f93 5d POPQ BP
16 main.go:9 0x468f94 c3 RET
17 main.go:7 0x468f95 e8e6afffff CALL runtime.morestack_noctxt.abi0(SB)
18 main.go:7 0x468f9a ebc4 JMP main.main(SB)
- Tras comparar con CMPQ si se ha ingresado en el hilo actual, si es correcto, salta al punto de entrada 0x468f95.
- Se inserta el punto de entrada en la pila con
PUSHQ BP. - Se asigna el inicio de la pila al comienzo de la función en el registro SP, donde se cargaron los datos más recientemente, fijando así el punto de entrada para la referencia de variables locales.
- Posteriormente, se reserva una pila de 16 bytes para variables locales (
SUBQ $0x10, SP) y se utiliza NOPL para rellenar varios bytes y realizar la alineación de la caché de la CPU. - El runtime de Go bloquea la salida del buffer de cadena llamando a
runtime.printlock(SB). - Utilizando la instrucción LEAQ, se almacena la dirección de inicio de la cadena asignada en AX, el acumulador utilizado para almacenar datos entre los registros de propósito general.
- Luego, se guarda la longitud de la cadena, 11, en el registro BX, utilizado para asistencia en cálculos y almacenamiento temporal de datos. (
MOVL $0Xb, BX) - Se imprime la información del acumulador hacia SB mediante runtime.printstring(SB).
- También se escribe un salto de línea en SB mediante runtime.printnl(SB).
- Se libera el buffer de cadena con runtime.printunlock(SB).
- Se devuelve la memoria de pila de 16 bytes prestada con ADDQ $0x10, SP. - Dado que el punto de entrada se informó al inicio al colocarlo en la pila, ahora se retira con POPQ BP y se envía la señal de retorno.
- Posteriormente, se asigna suficiente pila y se configura el runtime (como el GC), propio de un lenguaje gestionado, mediante runtime.morestack_noctxt.abi0(SB).
- Se desplaza a la dirección gestionada main.main(SB).
Como se observa, el assembly de la lógica de negocio es bastante claro y tiene una forma en la que solo se añade una ligera gestión del runtime.
En ausencia de optimización
La forma anterior es el resultado de que el compilador de Go optimizara automáticamente dos funciones separadas mediante inlining. Sin embargo, para fines de aprendizaje, en este caso no realizaremos el inlining de sayHello.
Para lograr esto, compilamos el código fuente con el siguiente flag:
1 go build -gcflags="-l" main.go
Al imprimir los resultados en la terminal, se detecta código assembly duplicado.
1yjlee@elegant:~/compare-assembly/go$ go build -gcflags="-l" main.go
2
3go tool objdump -s "main\.sayHello" ./main
4TEXT main.sayHello(SB) /home/yjlee/compare-assembly/go/main.go
5 main.go:3 0x468f60 493b6610 CMPQ SP, 0x10(R14)
6 main.go:3 0x468f64 7636 JBE 0x468f9c
7 main.go:3 0x468f66 55 PUSHQ BP
8 main.go:3 0x468f67 4889e5 MOVQ SP, BP
9 main.go:3 0x468f6a 4883ec10 SUBQ $0x10, SP
10 main.go:5 0x468f6e 4889442420 MOVQ AX, 0x20(SP)
11 main.go:5 0x468f73 48895c2428 MOVQ BX, 0x28(SP)
12 main.go:4 0x468f78 e8c3a3fcff CALL runtime.printlock(SB)
13 main.go:4 0x468f7d 488b442420 MOVQ 0x20(SP), AX
14 main.go:4 0x468f82 488b5c2428 MOVQ 0x28(SP), BX
15 main.go:4 0x468f87 e834acfcff CALL runtime.printstring(SB)
16 main.go:4 0x468f8c e8efa5fcff CALL runtime.printnl(SB)
17 main.go:4 0x468f91 e80aa4fcff CALL runtime.printunlock(SB)
18 main.go:5 0x468f96 4883c410 ADDQ $0x10, SP
19 main.go:5 0x468f9a 5d POPQ BP
20 main.go:5 0x468f9b c3 RET
21 main.go:3 0x468f9c 4889442408 MOVQ AX, 0x8(SP)
22 main.go:3 0x468fa1 48895c2410 MOVQ BX, 0x10(SP)
23 main.go:3 0x468fa6 e8d5afffff CALL runtime.morestack_noctxt.abi0(SB)
24 main.go:3 0x468fab 488b442408 MOVQ 0x8(SP), AX
25 main.go:3 0x468fb0 488b5c2410 MOVQ 0x10(SP), BX
26 main.go:3 0x468fb5 eba9 JMP main.sayHello(SB)
27yjlee@elegant:~/compare-assembly/go$ go tool objdump -s "main\.sayHello" ./main
28TEXT main.sayHello(SB) /home/yjlee/compare-assembly/go/main.go
29 main.go:3 0x468f60 493b6610 CMPQ SP, 0x10(R14)
30 main.go:3 0x468f64 7636 JBE 0x468f9c
31 main.go:3 0x468f66 55 PUSHQ BP
32 main.go:3 0x468f67 4889e5 MOVQ SP, BP
33 main.go:3 0x468f6a 4883ec10 SUBQ $0x10, SP
34 main.go:5 0x468f6e 4889442420 MOVQ AX, 0x20(SP)
35 main.go:5 0x468f73 48895c2428 MOVQ BX, 0x28(SP)
36 main.go:4 0x468f78 e8c3a3fcff CALL runtime.printlock(SB)
37 main.go:4 0x468f7d 488b442420 MOVQ 0x20(SP), AX
38 main.go:4 0x468f82 488b5c2428 MOVQ 0x28(SP), BX
39OVQ 0x20(SP), AX
40 main.go:4 0x468f82 488b5c2428 MOVQ 0x28(SP), BX
41 main.go:4 0x468f87 e834acfcff CALL runtime.printstring(SB)
42 main.go:4 0x468f8c e8efa5fcff CALL runtime.printnl(SB)
43 main.go:4 0x468f91 e80aa4fcff CALL runtime.printunlock(SB)
44 main.go:5 0x468f96 4883c410 ADDQ $0x10, SP
45 main.go:5 0x468f9a 5d POPQ BP
46 main.go:5 0x468f9b c3 RET
47 main.go:3 0x468f9c 4889442408 MOVQ AX, 0x8(SP)
48 main.go:3 0x468fa1 48895c2410 MOVQ BX, 0x10(SP)
49 main.go:3 0x468fa6 e8d5afffff CALL runtime.morestack_noctxt.abi0(SB)
50 main.go:3 0x468fab 488b442408 MOVQ 0x8(SP), AX
51 main.go:3 0x468fb0 488b5c2410 MOVQ 0x10(SP), BX
52 main.go:3 0x468fb5 eba9 JMP main.sayHello(SB)
53yjlee@elegant:~/compare-assembly/go$
Es decir, se ha confirmado que lo que optimiza el compilador son precisamente estas operaciones duplicadas, el desenrollado ineficiente de bucles, entre otros aspectos.
Próxima sesión
En la próxima sesión trataremos las sentencias if y switch en el lenguaje Go. Si el tiempo lo permite, más adelante también analizaremos las secciones del runtime de Go.