GoSuda

Ce este un Managed Language?

By Lee Yunjin
views ...

Ce este un limbaj managed?

Un limbaj managed este un limbaj care, spre deosebire de limbajele unmanaged — adică acelea care execută logică fără a se abate semnificativ de la instrucțiunile programatorului — automatizează procese precum GC (Garbage Collection), optimizarea runtime, green threads și gestionarea concurenței la nivel de runtime, eliminând necesitatea ca utilizatorul să efectueze gestionări riscante de nivel scăzut. În cazul acestor limbaje, avantajul constă în posibilitatea de a vă concentra exclusiv pe logica de business, însă, pe de altă parte, deoarece programul poate funcționa diferit față de intuiția programatorului, uneori este necesară o ajustare (tuning) fină a runtime-ului. Mai întâi, vom examina limbajul Go, care este cel mai fidel filosofiei minimaliste și al cărui limbaj assembly este transparent.

Structura binară a limbajului Go

.text.data.gopclntab, .typelink etc.
Cod mașină ce va fi executatDate ce vor fi stocateSecțiuni de runtime ale limbajului

Deoarece limbajul Go nu traduce codul sursă în cod mașină într-o manieră 1:1, logica din secțiunea .text este strâns legată de secțiunile de runtime ale limbajului. De asemenea, funcții precum runtime.printnl(), pe care utilizatorul nu le scrie explicit, sunt adăugate în assembly-ul secțiunii .text. Prin această inserare automată de cod, limbajul Go ajută dezvoltatorul să se elibereze de gestionarea manuală.

Examinarea funcției main în Go

În primul rând, să scriem un exemplu simplu, main.go, și să analizăm funcția main pe o arhitectură AMD64.

 1package main
 2
 3func sayHello(msg string) {
 4    println(msg)
 5}
 6
 7func main() {
 8    sayHello("Hello World")
 9}
10

Ulterior, compilăm astfel:

1go build main.go
2

Go oferă utilitarul go tool pentru a facilita depanarea (debugging) de nivel scăzut. Pentru a vizualiza doar assembly-ul corespunzător funcției main din pachetul main în cadrul go tool, se introduce următoarea comandă:

1go tool objdump -s "main\.main" ./main
2

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)
19
  • Se compară prin CMPQ spațiul curent al frame-ului de stivă al goroutinei cu valoarea de protecție a stivei din interiorul registrului blocului de control al goroutinei (R14) și indicatorul curent al stivei (SP); dacă spațiul este insuficient, se sare (JBE) la adresa 0x468f95, punctul de intrare pentru extinderea stivei.
  • Se salvează pointerul de bază anterior prin inserarea acestuia în stivă folosind PUSHQ BP.
  • Se copiază indicatorul curent al stivei (SP) în registrul pointerului de bază (BP) pentru a fixa punctul de referință al stivei la începutul funcției.
  • Ulterior, se alocă 16 octeți de spațiu pe stivă pentru variabilele locale (SUBQ $0x10, SP) și se utilizează NOPL pentru a completa cu instrucțiuni virtuale în vederea alinierii cache-ului CPU.
  • Se apelează runtime.printlock(SB) pentru a bloca (lock) sincronizarea ieșirii standard a șirurilor de caractere interne în runtime-ul Go.
  • Se utilizează instrucțiunea LEAQ pentru a stoca adresa de început a șirului de caractere constant ("Hello World") în registrul AX, utilizat ca prim parametru conform convenției Go ABI.
  • Apoi, se stochează valoarea reprezentând lungimea șirului în al doilea registru de parametri, BX (MOVL $0xb, BX, adică 11 în sistem zecimal).
  • Se apelează runtime.printstring(SB) pentru a afișa pe consolă informațiile bazate pe AX (adresa datelor) și BX (lungimea) transmise.
  • Se apelează runtime.printnl(SB) pentru gestionarea trecerii la linie nouă.
  • Deoarece afișarea a fost finalizată, se eliberează blocarea prin runtime.printunlock(SB).
  • Se recuperează memoria stivei de 16 octeți alocată anterior prin ADDQ $0x10, SP.
  • Se restaurează pointerul de bază anterior prin POPQ BP.
  • Se returnează controlul către punctul de apelare a funcției prin RET.
  • Dacă la verificarea inițială a stivei s-a constatat un spațiu insuficient, se apelează runtime.morestack_noctxt.abi0(SB) de la adresa 0x468f95 pentru a extinde dinamic runtime-ul stivei, conform naturii unui limbaj managed.
  • După finalizarea extinderii stivei, se revine (JMP) la punctul de intrare main.main(SB).

După cum se poate observa, assembly-ul logicii de business este destul de clar, având adăugată doar o gestionare minimă de runtime.

În absența optimizării

Forma de mai sus este rezultatul optimizării automate a compilatorului Go prin inlining-ul a două funcții separate. Totuși, în scop educativ, vom preveni inlining-ul funcției sayHello în acest caz. Pentru a realiza acest lucru, compilăm sursa cu următorul flag:

1go build -gcflags="-l" main.go
2

Dacă examinăm rezultatul în shell, vom observa un assembly duplicat.

 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)
27

Dacă dezactivăm inlining-ul, sunt inserate operații MOVQ care reîncarcă valorile în offset-ul pointerului de stivă, cum ar fi 0x20(SP), pentru a conserva parametrii (AX, BX) în conformitate cu specificațiile de apelare a funcțiilor. Cu alte cuvinte, s-a confirmat faptul că optimizarea realizată de compilator vizează eliminarea acestor operații inutile de mutare a memoriei și a overhead-ului de apelare.

Data viitoare

În data viitoare, vom aborda instrucțiunile if și switch în limbajul Go. Dacă timpul va permite, intenționăm să analizăm și secțiunile de runtime ale Go.