web-dev-qa-db-ja.com

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番目のオブジェクトはオブジェクトをスタックに配置します。最初の関数はヒープへのポインタを返し、2番目の関数はスタックへのポインタを返します。スタックは関数が返されるまでに蒸発し、悪いことになるでしょう。

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

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

引用するには：

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

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

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

1-例1では、構造体がヒープで宣言されています。例2はどうですか？それはCでの場合と同じ方法でスタック上で宣言されていますか、それともヒープ上で行われますか？

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

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

goheap-memorystack-memory
141
Joe

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

技術的には、すべての質問への答えが実装に依存します。もちろん実際には、スタック（ゴルーチンごとに）とヒープがあり、いくつかはスタックに、いくつかはヒープに置かれます。場合によっては、コンパイラは厳格な規則（「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のオブジェクトをプッシュすることを避けることです。

149
Sonia
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の戻りパラメーター値はアドレスです。

55
peterSO

GoのFAQ によると：

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

25
gchain

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

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

9
user
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（）は呼び出されません。意味がないからです。

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

0
g10guang