Return By Reference / Return By Value ?

---

Benarkah return by reference (pointer) lebih bagus dibandingkan return by value ?

Banyak programmer golang yang ketika membuat fungsi atau method selalu menggunakan return by reference. Ketika saya tanya "kenapa menggunakan return by reference ?", kebanyakan dari mereka menjawab "lebih bagus, karena kita menggunakan alamat memory yang sama". Apakah benar seperti itu?

Jika saya diberi pertanyaan seperti itu, maka jawaban saya adalah Tergantung cara penggunaan.

Golang memiliki memory manajement yang bisa dibilang sangat bagus. Golang memiliki gerbage collector (GC), tetapi penggunaan GC disini tidaklah gratis seperti yang kita banyangkan. Biaya yang kita bayarkan seperti resource, latency dan sebagainya.

Secara default, GC di golang running setiap 2 menit sekali (source bisa dibaca disini). Jadi selama GC itu belum dijalankan semua alamat memory akan terus bertambah di heap.

Lalu apakah semua alamat memory akan masuk di heap untuk dibersikhan oleh GC?. Di golang tidak semua alamat memory masuk kedalam heap, golang akan memvalidate lifetime dari setiap alamat memory tersebut apakah melebihi lifetime dari fungsi yang membuatnya atau tidak, bila lebih dari fungsi yang membuatnya maka akan masuk kedalam heap.

example:

code pertama

func Hello() string {
    s := "hello"
    return s
}

func main() {
    print(Hello())
}

Dari contoh kode di atas, kita dapat melihat bahwa variable s s := "hello lifetimenya tidak melebihi dari fungsi Hello().

code kedua

func Hello() *string {
    s := "hello"
    return &s
}

func main() {
    print(Hello())
}

Jika kita lihat dari contoh kode di atas, kita dapat melihat bahwa variable s s := "hello lifetimenya melebihi dari fungsi Hello() maka alamat memory s tersebut akan disimpan kedalam heap.

Apakah benar seperti itu ?, oke.., mari kita berbicara dengan compiler.

Kita dapat tahu bahwa pada command go build memiliki options -gcflags

-gcflags '[pattern=]arg list'

arguments to pass on each go tool compile invocation.

Sekarang pada command go tool compile memiliki option -l dan -m

-m print optimization decisions

-l disable inlining

lalu kita jalan kan perintah

go build -gcflags "-l -m" .

Pada kode pertama kita akan mendapatkan output:

# command-line-arguments
./main.go:14:13: ... argument does not escape
./main.go:14:19: Hello() escapes to heap

Dan pada kode kedua mendapatkan output:

# command-line-arguments
./main.go:9:6: moved to heap: s
./main.go:14:13: ... argument does not escape

Dari sini kita dapat melihat pada hasil kode ke 2, bahwa alamat memory dari s dipindahkan kedalam heap untuk selanjutnya di bersihkan oleh GC bila tidak lagi digunakan, sementara pada kode pertama golang akan langsung menghapus alamat memory tersebut setelah fungsi Hello() selesai.

Oke kita coba lihat kode assemblynya,

pada kode pertama kita akan menghasilkan output:

main.Hello STEXT nosplit size=13 args=0x0 locals=0x0 funcid=0x0 align=0x0
    0x0000      TEXT    main.Hello(SB), NOSPLIT|ABIInternal, $0-0
    0x0000      FUNCDATA    $0, gclocals·g2BeySu+wFnoycgXfElmcg==(SB)
    0x0000      FUNCDATA    $1, gclocals·g2BeySu+wFnoycgXfElmcg==(SB)
    0x0000      LEAQ    go.string."hello"(SB), AX
    0x0007      MOVL    $5, BX
    0x000c      RET
    0x0000 48 8d 05 00 00 00 00 bb 05 00 00 00 c3           H............
    rel 3+4 t=14 go.string."hello"+0
main.main STEXT size=71 args=0x0 locals=0x18 funcid=0x0 align=0x0
    0x0000      TEXT    main.main(SB), ABIInternal, $24-0
    0x0000      CMPQ    SP, 16(R14)
    0x0004      PCDATA    $0, $-2
    0x0004      JLS    62
    0x0006      PCDATA    $0, $-1
    0x0006      SUBQ    $24, SP
    0x000a      MOVQ    BP, 16(SP)
    0x000f      LEAQ    16(SP), BP
    0x0014      FUNCDATA    $0, gclocals·g2BeySu+wFnoycgXfElmcg==(SB)
    0x0014      FUNCDATA    $1, gclocals·g2BeySu+wFnoycgXfElmcg==(SB)
    0x0014      PCDATA    $1, $0
    0x0014      CALL    runtime.printlock(SB)
    0x0019      LEAQ    go.string."hello"(SB), AX
    0x0020      MOVL    $5, BX
    0x0025      CALL    runtime.printstring(SB)
    0x002a      CALL    runtime.printnl(SB)
    0x002f      CALL    runtime.printunlock(SB)
    0x0034      MOVQ    16(SP), BP
    0x0039      ADDQ    $24, SP
    0x003d      RET
    0x003e      NOP
    0x003e      PCDATA    $1, $-1
    0x003e      PCDATA    $0, $-2
    0x003e      NOP
    0x0040      CALL    runtime.morestack_noctxt(SB)
    0x0045      PCDATA    $0, $-1
    0x0045      JMP    0

Bisa kita lihat pada output diatas, main.Hello(SB), NOSPLIT|ABIInternal, $0-0 . NOSPLIT adalah sebuah opcode atau instruksi pada assembly yang digunakan untuk menghindari pembuatan stack frame pada saat fungsi dipanggil. Pembuatan stack frame dapat memakan waktu dan ruang yang cukup besar pada memori, sehingga NOSPLIT digunakan untuk mengoptimalkan kinerja program dengan menghindari pembuatan stack frame.

pada kode kedua kita akan menghasilkan output :

main.Hello STEXT size=72 args=0x0 locals=0x18 funcid=0x0 align=0x0
    0x0000      TEXT    main.Hello(SB), ABIInternal, $24-0
    0x0000      CMPQ    SP, 16(R14)
    0x0004      PCDATA    $0, $-2
    0x0004      JLS    65
    0x0006      PCDATA    $0, $-1
    0x0006      SUBQ    $24, SP
    0x000a      MOVQ    BP, 16(SP)
    0x000f      LEAQ    16(SP), BP
    0x0014      FUNCDATA    $0, gclocals·g2BeySu+wFnoycgXfElmcg==(SB)
    0x0014      FUNCDATA    $1, gclocals·g2BeySu+wFnoycgXfElmcg==(SB)
    0x0014      LEAQ    type.string(SB), AX
    0x001b      PCDATA    $1, $0
    0x001b      NOP
    0x0020      CALL    runtime.newobject(SB)
    0x0025      MOVQ    $5, 8(AX)
    0x002d      LEAQ    go.string."hello"(SB), CX
    0x0034      MOVQ    CX, (AX)
    0x0037      MOVQ    16(SP), BP
    0x003c      ADDQ    $24, SP
    0x0040      RET
    0x0041      NOP
    0x0041      PCDATA    $1, $-1
    0x0041      PCDATA    $0, $-2
    0x0041      CALL    runtime.morestack_noctxt(SB)
    0x0046      PCDATA    $0, $-1
    0x0046      JMP    0
main.main STEXT size=86 args=0x0 locals=0x20 funcid=0x0 align=0x0
    0x0000      TEXT    main.main(SB), ABIInternal, $32-0
    0x0000      CMPQ    SP, 16(R14)
    0x0004      PCDATA    $0, $-2
    0x0004      JLS    79
    0x0006      PCDATA    $0, $-1
    0x0006      SUBQ    $32, SP
    0x000a      MOVQ    BP, 24(SP)
    0x000f      LEAQ    24(SP), BP
    0x0014      FUNCDATA    $0, gclocals·J5F+7Qw7O7ve2QcWC7DpeQ==(SB)
    0x0014      FUNCDATA    $1, gclocals·u97U1TPSCOlmat2W1oBl9Q==(SB)
    0x0014      FUNCDATA    $2, main.main.stkobj(SB)
    0x0014  (<unknown line number>)    NOP
    0x0014      LEAQ    go.string."hello"(SB), AX
    0x001b      MOVQ    AX, main.s+8(SP)
    0x0020      MOVQ    $5, main.s+16(SP)
    0x0029      PCDATA    $1, $1
    0x0029         CALL    runtime.printlock(SB)
    0x002e         LEAQ    main.s+8(SP), AX
    0x0033         PCDATA    $1, $0
    0x0033         CALL    runtime.printpointer(SB)
    0x0038         CALL    runtime.printnl(SB)
    0x003d         NOP
    0x0040         CALL    runtime.printunlock(SB)
    0x0045      MOVQ    24(SP), BP
    0x004a      ADDQ    $32, SP
    0x004e      RET
    0x004f      NOP
    0x004f      PCDATA    $1, $-1
    0x004f      PCDATA    $0, $-2
    0x004f      CALL    runtime.morestack_noctxt(SB)
    0x0054      PCDATA    $0, $-1
    0x0054      JMP    0

Dari output diatas kita dapat melihat kode, CALL runtime.newobject(SB) yang berfungsi untuk mengalokasikan memory pada heap untuk objek yang baru dibuat.

Sekian artikel kali ini, bila bermanfaat silahkan share.