Goでの構造体のスタックとヒープの割り当て、およびガベージコレクションとの関係

私はGoを始めたばかりで、自動変数がスタックに存在し、割り当てられたメモリがヒープに存在するCスタイルのスタックベースのプログラミングと、Pythonスタイルのスタックベースのプログラミングが、スタック上に存在するものだけが、ヒープ上のオブジェクトへの参照/ポインターです。

私の知る限り、次の2つの関数は同じ出力を提供します。

func myFunction() (*MyStructType, error) {
    var chunk *MyStructType = new(HeaderChunk)

    ...

    return chunk, nil
}


func myFunction() (*MyStructType, error) {
    var chunk MyStructType

    ...

    return &chunk, nil
}

つまり、新しい構造体を割り当ててそれを返します。

それをCで書いた場合、最初のオブジェクトはヒープにオブジェクトを配置し、2番目のオブジェクトはスタックにオブジェクトを配置します。1つ目はヒープへのポインターを返し、2つ目はスタックへのポインターを返します。これは、関数が戻ったときまでに蒸発していたものであり、これは悪いことです。

Python（またはC＃を除く他の多くの現代言語）で記述した場合、例2は不可能でした。

Goガベージは両方の値を収集するので、上記の両方の形式で問題ありません。

引用するには：

Cとは異なり、ローカル変数のアドレスを返すことはまったく問題ありません。変数に関連付けられたストレージは、関数が戻った後も存続します。実際、複合リテラルのアドレスを取得すると、評価されるたびに新しいインスタンスが割り当てられるため、これらの最後の2行を組み合わせることができます。

http://golang.org/doc/effective_go.html#functions

しかし、それはいくつかの質問を提起します。

1-例1では、構造体はヒープで宣言されています。例2はどうですか？それはCの場合と同じようにスタックで宣言されていますか、それともヒープに移動しますか？

2-例2がスタックで宣言されている場合、関数が戻った後、例2はどのように利用可能のままですか？

3-例2が実際にヒープで宣言されている場合、構造体は参照ではなく値で渡されるのはなぜですか。この場合のポインタのポイントは何ですか？

「スタック」と「ヒープ」という言葉が言語仕様のどこにも現れていないことは注目に値します。あなたの質問は「...はスタックで宣言されています」と「...はヒープで宣言されています」という言葉で書かれていますが、Go宣言の構文はスタックやヒープについては何も述べていないことに注意してください。

それは技術的にあなたのすべての質問への答えを実装依存にします。もちろん、実際には（goroutineごとに）スタックとヒープがあり、スタック上にあるものとヒープ上にあるものがあります。コンパイラーは厳格なルール（「new常にヒープに割り当てる」など）に従う場合と、オブジェクトがスタックに存在できるかどうか、またはヒープに割り当てる必要があるかどうかを判断するために「エスケープ分析」を行う場合があります。

例2では、​​エスケープ分析は構造体へのポインタのエスケープを示すため、コンパイラは構造体を割り当てる必要があります。この場合、Goの現在の実装は厳密な規則に従っていると思います。つまり、アドレスが構造体のいずれかの部分から取得された場合、その構造体はヒープに配置されます。

質問3では、用語について混乱する恐れがあります。Goのすべては値で渡され、参照渡しはありません。ここでは、ポインタ値を返しています。ポインタのポイントは何ですか？次の例の変更を検討してください。

type MyStructType struct{}

func myFunction1() (*MyStructType, error) {
    var chunk *MyStructType = new(MyStructType)
    // ...
    return chunk, nil
}

func myFunction2() (MyStructType, error) {
    var chunk MyStructType
    // ...
    return chunk, nil
}

type bigStruct struct {
    lots [1e6]float64
}

func myFunction3() (bigStruct, error) {
    var chunk bigStruct
    // ...
    return chunk, nil
}

myFunction2を変更して、構造体のアドレスではなく構造体を返すようにしました。ここで、myFunction1とmyFunction2のアセンブリ出力を比較します。

--- prog list "myFunction1" ---
0000 (s.go:5) TEXT    myFunction1+0(SB),$16-24
0001 (s.go:6) MOVQ    $type."".MyStructType+0(SB),(SP)
0002 (s.go:6) CALL    ,runtime.new+0(SB)
0003 (s.go:6) MOVQ    8(SP),AX
0004 (s.go:8) MOVQ    AX,.noname+0(FP)
0005 (s.go:8) MOVQ    $0,.noname+8(FP)
0006 (s.go:8) MOVQ    $0,.noname+16(FP)
0007 (s.go:8) RET     ,

--- prog list "myFunction2" ---
0008 (s.go:11) TEXT    myFunction2+0(SB),$0-16
0009 (s.go:12) LEAQ    chunk+0(SP),DI
0010 (s.go:12) MOVQ    $0,AX
0011 (s.go:14) LEAQ    .noname+0(FP),BX
0012 (s.go:14) LEAQ    chunk+0(SP),BX
0013 (s.go:14) MOVQ    $0,.noname+0(FP)
0014 (s.go:14) MOVQ    $0,.noname+8(FP)
0015 (s.go:14) RET     ,

ここでのmyFunction1の出力がpeterSOの（優れた）回答とは異なることを心配しないでください。明らかに異なるコンパイラを実行しています。それ以外の場合は、* myStructTypeではなくmyStructTypeを返すようにmyFunction2を変更したことを確認してください。runtime.newの呼び出しはなくなりました。これは、場合によっては良いことです。ちょっと待って、これがmyFunction3です。

--- prog list "myFunction3" ---
0016 (s.go:21) TEXT    myFunction3+0(SB),$8000000-8000016
0017 (s.go:22) LEAQ    chunk+-8000000(SP),DI
0018 (s.go:22) MOVQ    $0,AX
0019 (s.go:22) MOVQ    $1000000,CX
0020 (s.go:22) REP     ,
0021 (s.go:22) STOSQ   ,
0022 (s.go:24) LEAQ    chunk+-8000000(SP),SI
0023 (s.go:24) LEAQ    .noname+0(FP),DI
0024 (s.go:24) MOVQ    $1000000,CX
0025 (s.go:24) REP     ,
0026 (s.go:24) MOVSQ   ,
0027 (s.go:24) MOVQ    $0,.noname+8000000(FP)
0028 (s.go:24) MOVQ    $0,.noname+8000008(FP)
0029 (s.go:24) RET     ,

それでもruntime.newへの呼び出しはなく、はい、実際には値によって8MBのオブジェクトを返すように機能します。それは機能しますが、通常はしたくありません。ここでのポインタのポイントは、8MBのオブジェクトをプッシュしないようにすることです。

type MyStructType struct{}

func myFunction1() (*MyStructType, error) {
    var chunk *MyStructType = new(MyStructType)
    // ...
    return chunk, nil
}

func myFunction2() (*MyStructType, error) {
    var chunk MyStructType
    // ...
    return &chunk, nil
}

どちらの場合でも、Goの現在の実装では、ヒープ上structの型のメモリを割り当てMyStructType、そのアドレスを返します。関数は同等です。コンパイラのasmソースは同じです。

--- prog list "myFunction1" ---
0000 (temp.go:9) TEXT    myFunction1+0(SB),$8-12
0001 (temp.go:10) MOVL    $type."".MyStructType+0(SB),(SP)
0002 (temp.go:10) CALL    ,runtime.new+0(SB)
0003 (temp.go:10) MOVL    4(SP),BX
0004 (temp.go:12) MOVL    BX,.noname+0(FP)
0005 (temp.go:12) MOVL    $0,AX
0006 (temp.go:12) LEAL    .noname+4(FP),DI
0007 (temp.go:12) STOSL   ,
0008 (temp.go:12) STOSL   ,
0009 (temp.go:12) RET     ,

--- prog list "myFunction2" ---
0010 (temp.go:15) TEXT    myFunction2+0(SB),$8-12
0011 (temp.go:16) MOVL    $type."".MyStructType+0(SB),(SP)
0012 (temp.go:16) CALL    ,runtime.new+0(SB)
0013 (temp.go:16) MOVL    4(SP),BX
0014 (temp.go:18) MOVL    BX,.noname+0(FP)
0015 (temp.go:18) MOVL    $0,AX
0016 (temp.go:18) LEAL    .noname+4(FP),DI
0017 (temp.go:18) STOSL   ,
0018 (temp.go:18) STOSL   ,
0019 (temp.go:18) RET     ,

呼び出し

関数呼び出しでは、関数値と引数は通常の順序で評価されます。それらが評価された後、呼び出しのパラメーターが値によって関数に渡され、呼び出された関数が実行を開始します。関数の戻りパラメーターは、関数が戻るときに値によって呼び出し元の関数に戻されます。

すべての関数と戻りパラメーターは値で渡されます。タイプ付きの戻りパラメーター値*MyStructTypeはアドレスです。

GoのFAQによると：

関数が戻った後に変数が参照されていないことをコンパイラーが証明できない場合、コンパイラーはガベージコレクションされたヒープに変数を割り当てて、ダングリングポインターエラーを回避する必要があります。

変数がスタックまたはヒープに割り当てられているかどうかは常にわかりません。
...
変数がどこに割り当てられているかを知る必要がある場合は、「-m」gcフラグを「ビルド」または「実行」に渡します（例：）go run -gcflags -m app.go。

_{ソース：http : //devs.cloudimmunity.com/gotchas-and-common-mistakes-in-go-golang/index.html#stack_heap_vars}

func Function1() (*MyStructType, error) {
    var chunk *MyStructType = new(HeaderChunk)

    ...

    return chunk, nil
}


func Function2() (*MyStructType, error) {
    var chunk MyStructType

    ...

    return &chunk, nil
}

Function1とFunction2はインライン関数の場合があります。そして、戻り変数はエスケープしません。ヒープに変数を割り当てる必要はありません。

私のサンプルコード：

 1  package main
 2  
 3  type S struct {
 4          x int
 5  }
 6  
 7  func main() {
 8          F1()
 9          F2()
10          F3()
11  }
12  
13  func F1() *S {
14          s := new(S)
15          return s
16  }
17  
18  func F2() *S {
19          s := S{x: 10}
20          return &s
21  }
22  
23  func F3() S {
24          s := S{x: 9}
25          return s
26  }

cmdの出力によると：

go run -gcflags -m test.go

出力：

# command-line-arguments
./test.go:13:6: can inline F1
./test.go:18:6: can inline F2
./test.go:23:6: can inline F3
./test.go:7:6: can inline main
./test.go:8:4: inlining call to F1
./test.go:9:4: inlining call to F2
./test.go:10:4: inlining call to F3
/var/folders/nr/lxtqsz6x1x1gfbyp1p0jy4p00000gn/T/go-build333003258/b001/_gomod_.go:6:6: can inline init.0
./test.go:8:4: main new(S) does not escape
./test.go:9:4: main &s does not escape
./test.go:14:10: new(S) escapes to heap
./test.go:20:9: &s escapes to heap
./test.go:19:2: moved to heap: s

コンパイラが十分に賢い場合、F1（） F2（） F3（）は呼び出されない可能性があります。意味がないからです。

変数がヒープまたはスタックに割り当てられているかどうかは気にせず、それを使用してください。必要に応じて、ミューテックスまたはチャネルで保護してください。