...

パッケージ runtime

概要 ▾

runtime パッケージは,ゴルーチンを制御する関数のような, Go のランタイムシステムと相互作用する操作を含みます。 reflect パッケージで使われる低レベルの型情報も含んでいます。 ランタイム型システムのプログラム可能なインターフェースについては,reflect のドキュメントをご覧ください。

環境変数

以下の環境変数 (ホストオペレーティングシステムに応じて $name または %name%) は, Go プログラムの実行時の動作を制御します。 意味と用途はリリースごとに変わるかもしれません。

GOGC 変数は,初期のガベージコレクションの目標パーセンテージを設定します。 前の収集後に残っているライブデータに対する新しく割り当てられたデータの比率がこの割合に達すると,コレクションがトリガーされます。 デフォルトは GOGC=100 です。 GOGC=off を設定すると,ガベージコレクタは完全に無効になります。 ランタイム / デバッグパッケージの SetGCPercent 関数を使用すると,実行時にこの割合を変更できます。 https://golang.org/pkg/runtime/debug/#SetGCPercent を参照してください。

GODEBUG 変数はランタイム内のデバッグ変数を制御します。 それはこれらの名前付き変数を設定する name=val ペアのコンマ区切りのリストです :

allocfreetrace: allocfreetrace=1 を設定すると,すべての割り当てがプロファイリングされ,各オブジェクトの割り当てについてスタックトレースが表示され,解放されます。

clobberfree: clobberfree=1 に設定すると,ガベージコレクタは,オブジェクトを解放するときに,内容の悪いオブジェクトのメモリ内容を削除します。

cgocheck: cgocheck=0 に設定すると, cgo を使用したパッケージに対するすべてのチェックが無効になり, Go ポインタが誤って Go 以外のコードに渡されます。
cgocheck=1 (デフォルト) を設定すると,いくつかのエラーを見逃す可能性がある比較的安価なチェックが有効になります。
cgocheck=2 を設定すると,エラーを見逃すことはないはずの高価なチェックが可能になりますが,プログラムの実行速度は遅くなります。

efence: efence=1 に設定すると,アロケータは各オブジェクトが一意のページに割り当てられ,アドレスがリサイクルされないモードで実行されます。

gccheckmark: gccheckmark=1 を設定すると,ワールドが停止している間に 2 回目のマークパスを実行することで,ガベージコレクタの平行マークフェーズを検証できます。
2 回目のパスで,並行マークで見つからなかった到達可能なオブジェクトが見つかった場合,ガベージコレクタはパニックします。

gcpacertrace: gcpacertrace=1 を設定すると,ガベージコレクタは並行ペーサの内部状態に関する情報を出力します。

gcshrinkstackoff: gcshrinkstackoff=1 に設定すると,ゴルーチンを小さなスタックに移動できなくなります。
このモードでは,ゴルーチンのスタックは大きくなることしかできません。

gcstoptheworld: gcstoptheworld=1 に設定すると,平行ガベージコレクションが無効になり,すべてのガベージコレクションが世界を止めるイベントになります。
gcstoptheworld=2 を設定すると,ガベージコレクションが終了した後の平行スイープも無効になります。

gctrace: gctrace=1 に設定すると,ガベージコレクタは各コレクションで標準エラーに 1 行を出力し,収集されたメモリの量と一時停止の長さを要約します。
この行のフォーマットは変更されることがあります。
現在は,次のとおりです。
	gc # @#s #%: #+#+# ms clock, #+#/#/#+# ms cpu, #->#-># MB, # MB goal, # P
ここで,
	gc #        GC ナンバー,各 GC でインクリメントされます。
	@#s         プログラム開始からの秒数
	#%          プログラム開始から GC で費やされた時間の割合
	#+...+#     GC のフェーズのウォールクロック/CPU 時間
	#->#-># MB  GC の開始時, GC の終了時,およびライブヒープのヒープサイズ
	# MB goal   目標ヒープサイズ
	# P         使用されたプロセッサの数
フェーズはストップ・ザ・ワールド (STW) スイープ終了,マークとスキャンの平行実行,および STW マークの終了。
マーク / スキャンの CPU 時間は,時間 (割り当てに合わせて GC を実行) ,バックグラウンド GC 時間,およびアイドル GC 時間を補助するために分類されています。
行が "(forced)" で終わっている場合,この GC は runtime.GC() 呼び出しによって強制されています。

gctrace を 0 より大きい任意の値に設定すると,メモリがシステムに解放されたときにガベージコレクタがサマリーを発行します。
システムにメモリを戻すこのプロセスは,スキャベンジングと呼ばれます。
この要約の形式は変更されることがあります。
現在は次のとおりです。
	scvg#: # MB 解放された。ゼロ以外の場合にのみ表示される
	scvg#: inuse: # idle: # sys: # released: # consumed: # (MB)
フィールドは次の意味です。
	scvg#        スキャンベンジサイクルナンバー,毎回のスキャンベンジでインクリメントされます
	inuse: #     使用されたスパンまたは部分的に使用されたスパン (MB)
	idle: #      スキャンベンジが未処理のスパン (MB)
	sys: #       システムからマップされた (MB)
	released: #  システムに解放された (MB)
	consumed: #  システムから割り当てられた (MB)

madvdontneed: madvdontneed=1 に設定すると,
Linux でメモリをカーネルに戻すときに MADV_FREE の代わりに MADV_DONTNEED が使用されます。
これはあまり効率的ではありませんが,
RSS 番号をもっと早く落とします。

memprofilerate: memprofilerate=X と設定すると,
runtime.MemProfileRate の値が更新されます。
0 に設定すると,メモリプロファイリングは無効になります。
デフォルト値については MemProfileRate の説明を参照してください。

invalidptr: デフォルトは invalidptr=1 で,
無効なポインタ値 (たとえば 1) がポインタ型の場所に見つかった場合,
ガベージコレクタとスタックコピー機はプログラムをクラッシュさせます。
invalidptr=0 に設定すると,このチェックは無効になります。
これはバグのあるコードを診断するための一時的な回避策としてのみ使用されるべきです。
本当の解決策は,ポインタ型の場所に整数を格納しないことです。

sbrk:sbrk=1 に設定すると,メモリアロケータとガベージコレクタは,オペレーティングシステムからメモリを取得してメモリを回収することのない簡単なアロケータに置き換えられます。

scavenge: scavenge=1 は,ヒープスカベンジャーのデバッグモードを有効にします。

scheddetail: schedtrace=X および scheddetail=1 を設定すると,スケジューラは X ミリ秒ごとに詳細な複数行の情報を出力し,スケジューラ,プロセッサ,スレッド,およびゴルーチンの状態を記述します。

schedtrace: schedtrace=X を設定すると,スケジューラは X ミリ秒ごとに標準エラーに 1 行を出力し,スケジューラの状態を要約します。

tracebackancestors: tracebackancestors=N を設定すると,ゴルーチンが作成されたスタックでトレースバックが拡張されます。
ここで, N は,レポートする先祖ゴルーチンの数を制限します。
これは runtime.Stack によって返される情報も拡張します。
先祖のゴルーチン ID は作成時のゴルーチンの ID を参照します。
この ID を別のゴルーチンに再利用することは可能です。
N を 0 に設定すると,先祖情報は報告されません。

net, net/http ,および crypto/tls パッケージも GODEBUG のデバッグ変数を参照しています。 詳細はそれらのパッケージのドキュメントを参照してください。

GOMAXPROCS 変数は,ユーザーレベルの Go コードを平行に実行できるオペレーティングシステムスレッドの数を制限します。 Go コードの代わりにシステムコールでブロックできるスレッドの数に制限はありません。 それらは GOMAXPROCS 制限にはカウントされません。 このパッケージの GOMAXPROCS 関数は制限をクエリて変更します。

GORACE 変数は, -race を使用してビルドされたプログラムの競合検出器を構成します。詳細については, https://golang.org/doc/articles/race_detector.html を参照する。

GOTRACEBACK 変数は,回復されなかったパニックまたは予期しないランタイム状態が原因で Go プログラムが失敗したときに生成される出力の量を制御します。 デフォルトでは,失敗は現在のゴルーチンのスタックトレースを表示し,ランタイムシステムの内部関数を取り除き,終了コード 2 で終了します。 現在のゴルーチンがないか失敗した場合,失敗はすべてのゴルーチンのスタックトレースを表示します。 ランタイムの内部 GOTRACEBACK=none はゴルーチンスタックトレースを完全に省略します。 GOTRACEBACK=single (デフォルト) は上記のように動作します。 GOTRACEBACK=all は,ユーザーが作成したすべてのゴルーチンのスタックトレースを追加します。 GOTRACEBACK=system は “all” に似ていますが,ランタイム関数用のスタックフレームを追加し,ランタイムによって内部的に作成されたゴルーチンを表示します。 GOTRACEBACK=crash は " システム " と似ていますが,終了するのではなく,オペレーティングシステム固有の方法でクラッシュします。 たとえば, UNIX システムでは,クラッシュによって SIGABRT が発生してコアダンプが引き起こされます。 歴史的な理由から, GOTRACEBACK の設定 0, 1 ,および 2 は,それぞれ none, all ,および system の同義語です。 ランタイム / デバッグパッケージの SetTraceback 関数では,実行時に出力量を増やすことができますが,環境変数で指定された量よりも少なくすることはできません。 https://golang.org/pkg/runtime/debug/#SetTraceback を参照してください。

GOARCH, GOOS, GOPATH ,および GOROOT 環境変数は, Go 環境変数のセットを完成させます。 それらは Go プログラムの構築に影響を与えます (https://golang.org/cmd/go および https://golang.org/pkg/go/build を参照) 。 GOARCH, GOOS ,および GOROOT はコンパイル時に記録され,このパッケージの定数または関数によって使用可能になりますが,これらはランタイムシステムの実行には影響しません。

目次 ▾

定数
変数
func BlockProfile(p []BlockProfileRecord) (n int, ok bool)
func Breakpoint()
func CPUProfile() []byte
func Caller(skip int) (pc uintptr, file string, line int, ok bool)
func Callers(skip int, pc []uintptr) int
func GC()
func GOMAXPROCS(n int) int
func GOROOT() string
func Goexit()
func GoroutineProfile(p []StackRecord) (n int, ok bool)
func Gosched()
func KeepAlive(x interface{})
func LockOSThread()
func MemProfile(p []MemProfileRecord, inuseZero bool) (n int, ok bool)
func MutexProfile(p []BlockProfileRecord) (n int, ok bool)
func NumCPU() int
func NumCgoCall() int64
func NumGoroutine() int
func ReadMemStats(m *MemStats)
func ReadTrace() []byte
func SetBlockProfileRate(rate int)
func SetCPUProfileRate(hz int)
func SetCgoTraceback(version int, traceback, context, symbolizer unsafe.Pointer)
func SetFinalizer(obj interface{}, finalizer interface{})
func SetMutexProfileFraction(rate int) int
func Stack(buf []byte, all bool) int
func StartTrace() error
func StopTrace()
func ThreadCreateProfile(p []StackRecord) (n int, ok bool)
func UnlockOSThread()
func Version() string
type BlockProfileRecord
type Error
type Frame
type Frames
    func CallersFrames(callers []uintptr) *Frames
    func (ci *Frames) Next() (frame Frame, more bool)
type Func
    func FuncForPC(pc uintptr) *Func
    func (f *Func) Entry() uintptr
    func (f *Func) FileLine(pc uintptr) (file string, line int)
    func (f *Func) Name() string
type MemProfileRecord
    func (r *MemProfileRecord) InUseBytes() int64
    func (r *MemProfileRecord) InUseObjects() int64
    func (r *MemProfileRecord) Stack() []uintptr
type MemStats
type StackRecord
    func (r *StackRecord) Stack() []uintptr
type TypeAssertionError
    func (e *TypeAssertionError) Error() string
    func (*TypeAssertionError) RuntimeError()

Frames

パッケージファイル

alg.go atomic_pointer.go cgo.go cgocall.go cgocallback.go cgocheck.go chan.go compiler.go complex.go cpuflags.go cpuflags_amd64.go cpuprof.go cputicks.go debug.go debugcall.go debuglog.go debuglog_off.go defs_darwin_amd64.go env_posix.go error.go extern.go fastlog2.go fastlog2table.go float.go hash64.go heapdump.go iface.go lfstack.go lfstack_64bit.go lock_sema.go malloc.go map.go map_fast32.go map_fast64.go map_faststr.go mbarrier.go mbitmap.go mcache.go mcentral.go mem_darwin.go mfinal.go mfixalloc.go mgc.go mgclarge.go mgcmark.go mgcscavenge.go mgcstack.go mgcsweep.go mgcsweepbuf.go mgcwork.go mheap.go mprof.go msan0.go msize.go mstats.go mwbbuf.go netpoll.go netpoll_kqueue.go os_darwin.go os_nonopenbsd.go panic.go plugin.go print.go proc.go profbuf.go proflabel.go race0.go rdebug.go relax_stub.go runtime.go runtime1.go runtime2.go rwmutex.go select.go sema.go signal_amd64x.go signal_darwin.go signal_darwin_amd64.go signal_sighandler.go signal_unix.go sigqueue.go sizeclasses.go slice.go softfloat64.go stack.go string.go stubs.go stubs_amd64x.go stubs_nonlinux.go symtab.go sys_darwin.go sys_darwin_64.go sys_nonppc64x.go sys_x86.go time.go timestub.go trace.go traceback.go type.go typekind.go utf8.go vdso_in_none.go write_err.go

定数

Compiler は,実行中のバイナリをビルドしたコンパイラツールチェーンの名前です。 既知のツールチェーンは次のとおりです。

gccmd/ コンパイルとも呼ばれます。
gccgoGCC コンパイラスイートの一部である gccgo フロントエンド。
const Compiler = "gc"

GOARCH は実行中のプログラムのアーキテクチャターゲットです。 386, amd64, arm, s390x などです。

const GOARCH string = sys.GOARCH

GOOS は,実行中のプログラムのオペレーティングシステムのターゲットです。 Darwin , freebsd , linux などの 1 つです。 GOOS と GOARCH の可能な組み合わせを見るには, "go tool dist list" を実行してください。

const GOOS string = sys.GOOS

変数

MemProfileRate は,メモリプロファイルに記録および報告されるメモリ割り当ての割合を制御します。 プロファイラーは,割り当てられた MemProfileRate バイトごとに平均 1 つの割り当てをサンプリングすることを目的としています。

プロファイルに割り当てられたすべてのブロックを含めるには, MemProfileRate を 1 に設定します。 プロファイリングを完全に無効にするには, MemProfileRate を 0 に設定します。

メモリプロファイルを処理するツールは,プロファイルレートがプログラムの有効期間を通じて一定であり,現在の値と等しいと仮定します。 メモリプロファイリングレートを変更するプログラムは,プログラムの実行のできるだけ早い時期に (たとえば main の先頭に)1 回だけ実行する必要があります。

var MemProfileRate int = 512 * 1024

func BlockProfile 1.1

func BlockProfile(p []BlockProfileRecord) (n int, ok bool)

BlockProfile は,現在のブロッキングプロファイル内のレコード数 n を返します。 len(p) >= n の場合, BlockProfile はプロファイルを p にコピーし, n, true を返します。 len(p) < n の場合, BlockProfile は p を変更せずに n(false) を返します。

ほとんどのクライアントは, BlockProfile を直接呼び出すのではなく, runtime/pprof パッケージまたはテストパッケージの -test.blockprofileフラグを使用する必要があります。

func Breakpoint

func Breakpoint()

ブレークポイントは,ブレークポイントトラップを実行します。

func CPUProfile

func CPUProfile() []byte

CPUProfile パニック。 以前はランタイムによって生成された pprof 形式のプロファイルのチャンクへの生のアクセスを提供していました。 そのフォーマットの生成に関する詳細が変更されたため,この機能は削除されました。

非推奨 : 代わりに, runtime/pprof パッケージ, net/http/pprof パッケージのハンドラー,またはテストパッケージの -test.cpupro ファイルフラグを使用する。

func Caller

func Caller(skip int) (pc uintptr, file string, line int, ok bool)

呼び出し側は,呼び出し側のゴルーチンのスタック上の関数呼び出しに関するファイルと行番号の情報を報告します。 引数 skip は昇順にするスタックフレームの数です。 0 は Caller の呼び出し元を表します。 (歴史的な理由で, skip の意味は Caller と Callers の間では異なります。) 戻り値は,対応する呼び出しのプログラムカウンタ,ファイル名,およびファイル内の行番号を報告します。 情報を復元できなかった場合,ブール値 ok は false です。

func Callers

func Callers(skip int, pc []uintptr) int

呼び出し側は,呼び出し側 goroutine のスタック上の関数呼び出しの戻りプログラムカウンタでスライス pc を埋めます。 引数 skip は, pc に記録する前にスキップするスタックフレームの数です。 0 は呼び出し側自身のフレームを識別し, 1 は呼び出し側の呼び出し側を識別します。 pc に書き込まれたエントリ数を返します。

これらの PC を関数名や行番号などの記号情報に変換するには, CallersFrames を使用してください。 CallersFrames はインライン関数を考慮し,リターンプログラムカウンタをコールプログラムカウンタに調整します。 返された PC のいずれかで FuncForPC を使用する場合と同様に,返された PC のスライスを直接反復することはお勧めできません。 インライン化またはリターンプログラムカウンタの調整を考慮できないためです。 go:noinline

func GC

func GC()

GC はガベージコレクションを実行し,ガベージコレクションが完了するまで呼び出し元をブロックします。 プログラム全体をブロックすることもあります。

func GOMAXPROCS

func GOMAXPROCS(n int) int

GOMAXPROCS は平行に実行できる CPU の最大数を設定し,以前の設定を返します。 n < 1 の場合,現在の設定は変更されません。 ローカルマシン上の論理 CPU の数は NumCPU で知ることができます。 スケジューラが改善すると,この呼び出しはなくなります。

func GOROOT

func GOROOT() string

GOROOT は Go ツリーのルートを返します。 プロセスの開始時に設定されている場合は GOROOT 環境変数を使用し,それ以外の場合は Go ビルド中に使用されたルートを使用します。

func Goexit

func Goexit()

Goexit はそれを呼び出すゴルーチンを終了させます。 他のゴロチンは影響を受けません。 Goexit は,ゴルーチンを終了する前にすべての遅延呼び出しを実行します。 Goexit はパニックではないので,これらの遅延関数内の recover 呼び出しはすべて nil を返します。

メイン goroutine から Goexit を呼び出すと, func main が返されることなくその goroutine が終了します。 func main が戻ってこないので,プログラムは他のゴルーチンの実行を続けます。 他のすべてのゴルーチンが終了すると,プログラムはクラッシュします。

func GoroutineProfile

func GoroutineProfile(p []StackRecord) (n int, ok bool)

GoroutineProfile は,アクティブなゴルーチンスタックプロファイル内のレコード数 n を返します。 len(p) >= n の場合, GoroutineProfile はプロファイルを p にコピーし, n, true を返します。 len(p) < n の場合, GoroutineProfile は p を変更せずに n, false を返します。

ほとんどのクライアントは GoroutineProfile を直接呼び出す代わりに runtime/pprof パッケージを使うべきです。

func Gosched

func Gosched()

Gosched はプロセッサを生成し,他のゴルーチンを実行できるようにします。現在のゴルーチンを一時停止しないため,実行は自動的に再開されます。

func KeepAlive 1.7

func KeepAlive(x interface{})

KeepAlive はその引数を現在到達可能であるとマークします。 これにより, KeepAlive が呼び出されるプログラム内のポイントより前では,オブジェクトは解放されず,ファイナライザーは実行されません。

KeepAlive が必要な場所を示す非常に単純化された例:

type File struct { d int }
d, err := syscall.Open("/file/path", syscall.O_RDONLY, 0)
// ... err != nil なら何かをする ...
p := &File{d}
runtime.SetFinalizer(p, func(p *File) { syscall.Close(p.d) })
var buf [10]byte
n, err := syscall.Read(p.d, buf[:])
// Read が返るまで p がファイナライズされないようにする。
runtime.KeepAlive(p)
// この時点以降, p はこれ以上使用されません。

KeepAlive 呼び出しがないと,ファイナライザーは syscall.Read の開始時に実行され, syscall.Read が実際のシステム呼び出しを行う前にファイル記述子を閉じます。

func LockOSThread

func LockOSThread()

LockOSThread は,呼び出しゴルーチンを現在のオペレーティングシステムスレッドにワイヤリングします。呼び出しゴルーチンがロック OS スレッドに対して UnlockOSThread を呼び出すまで,呼び出しゴルーチンは常にそのスレッドで実行され,他のゴルーチンは実行されません。呼び出しゴルーチンがスレッドのロックを解除せずに終了すると,スレッドは終了します。

すべての初期化関数は,起動スレッドで実行されます。 init 関数から LockOSThread を呼び出すと,そのスレッドでメイン関数が呼び出されます。

ゴルーチンは, OS サービスまたはスレッドごとの状態に依存する非 Go ライブラリ関数を呼び出す前に, LockOSThread を呼び出す必要があります。

func MemProfile

func MemProfile(p []MemProfileRecord, inuseZero bool) (n int, ok bool)

MemProfile は,割り当てサイトごとに割り当てられ解放されたメモリのプロファイルを返します。

MemProfile は,現在のメモリプロファイル内のレコード数 n を返します。 len(p) >= n の場合, MemProfile はプロファイルを p にコピーし, n, true を返します。 len(p) < n の場合, MemProfile は p を変更せずに n, false を返します。

inuseZero が true の場合,プロファイルには r.AllocBytes > 0 だが r.AllocBytes == r.FreeBytes の割り当てレコードが含まれます。 これらはメモリが割り当てられたサイトですが,すべてランタイムに解放されています。

返されたプロファイルは,最大 2 回のガベージコレクションサイクルの古いものです。 これは,プロファイルが割り当てに偏るのを防ぐためです。 割り当てはリアルタイムで行われますが,解放はガベージコレクタがスイープを実行するまで遅延されるため,プロファイルは,ガベージコレクタによって解放される可能性がある割り当てのみを考慮します。

ほとんどのクライアントは, MemProfile を直接呼び出すのではなく, runtime/pprof パッケージまたはテストパッケージの -test.memprofileフラグを使用する必要があります。

func MutexProfile 1.8

func MutexProfile(p []BlockProfileRecord) (n int, ok bool)

MutexProfile は,現在のミューテックスプロファイル内のレコード数 n を返します。 len(p) >= n の場合, MutexProfile はプロファイルを p にコピーし, n, true を返します。 そうでなければ, MutexProfile は p を変更せず, n, false を返します。

ほとんどのクライアントは MutexProfile を直接呼び出す代わりに runtime/pprof パッケージを使用するべきです。

func NumCPU

func NumCPU() int

NumCPU は,現在のプロセスで使用可能な論理 CPU の数を返します。

使用可能な CPU のセットは,プロセスの起動時にオペレーティングシステムにクエリることによって確認されます。 プロセス起動後のオペレーティングシステムの CPU 割り当ての変更は反映されません。

func NumCgoCall

func NumCgoCall() int64

NumCgoCall は,現在のプロセスによって行われた cgo 呼び出しの数を返します。

func NumGoroutine

func NumGoroutine() int

NumGoroutine は現在存在するゴルーチンの数を返します。

func ReadMemStats

func ReadMemStats(m *MemStats)

ReadMemStats は m にメモリアロケータの統計情報を追加します。

返されたメモリアロケータの統計は, ReadMemStats の呼び出し時点で最新のものです。 これは,最後に完了したガベージコレクションサイクルの時点でのスナップショットであるヒーププロファイルとは対照的です。

func ReadTrace 1.5

func ReadTrace() []byte

ReadTrace は,バイナリトレースデータの次のチャンクを返し,データが利用可能になるまでブロックします。 トレースがオフになっていて,それがオンになっている間に累積されたすべてのデータが返された場合, ReadTrace は nil を返します。 呼び出し側は, ReadTrace を再度呼び出す前に,返されたデータをコピーする必要があります。 ReadTrace は一度に 1 つの goroutine から呼び出さなければなりません。

func SetBlockProfileRate 1.1

func SetBlockProfileRate(rate int)

SetBlockProfileRate は,ブロックプロファイルで報告されるゴルーチンブロックイベントの割合を制御します。 プロファイラは,ブロックされた 1 ナノ秒あたりに平均 1 つのブロッキングイベントをサンプリングすることを目的としています。

プロファイルにすべてのブロックイベントを含めるには,成功率 = 1 を指定します。 プロファイリングを完全に無効にするには,成功率 <= 0 を指定します。

func SetCPUProfileRate

func SetCPUProfileRate(hz int)

SetCPUProfileRate は, CPU プロファイリングレートを 1 秒あたり hz サンプルに設定します。 hz <= 0 の場合, SetCPUProfileRate はプロファイリングを無効にします。 プロファイラがオンの場合,最初にオフにしないとレートを変更できません。

ほとんどのクライアントは, SetCPUProfileRate を直接呼び出す代わりに, runtime/pprof パッケージまたはテスト用パッケージの -test.cpuprofileフラグを使用する必要があります。

func SetCgoTraceback 1.7

func SetCgoTraceback(version int, traceback, context, symbolizer unsafe.Pointer)

SetCgoTraceback は, C コードからトレースバック情報を収集し,そのトレースバック情報をシンボリック情報に変換するために使用する 3 つの C 関数を記録します。 これらは, cgo を使用するプログラムのスタックトレースを表示するときに使用されます。

トレースバックおよびコンテキスト関数はシグナルハンドラから呼び出すことができるので,非同期シグナルセーフ関数のみを使用しなければなりません。 プログラムがクラッシュしている間に symbolizer 関数が呼び出される可能性があるので,メモリの使用については注意が必要です。 どの関数も Go にコールバックすることはできません。

コンテキスト関数は, 1 つの引数,構造体へのポインタで呼び出されます。

struct {
	Context uintptr
}

C 構文では,この構造体は次のようになります。

struct {
	uintptr_t Context;
};

Context フィールドが 0 の場合,現在のトレースバックコンテキストを記録するためにコンテキスト関数が呼び出されています。 後でスタックトレースを生成するために現在の実行ポイントについて必要な情報,おそらくスタックポインタと PC を, Context フィールドに記録する必要があります。 この場合,コンテキスト関数は C コードから呼び出されます。

Context フィールドが 0 でない場合は,コンテキスト関数への前回の呼び出しによって返された値です。 このケースは,コンテキストが不要になったときに呼び出されます。 つまり, Go コードが C コードの呼び出し側に戻ってきたときです。 これにより,コンテキスト関数は関連リソースを解放できます。

コンテキスト関数が呼び出されるたびに完全なスタックトレースを記録し,単純にトレースバック関数にコピーアウトすることは正しいのですが,一般的なプログラムでは,コンテキスト関数はそのためのトレースバックを記録せずに何度も呼び出されます。 コンテキスト。 コンテキスト関数の呼び出しで完全なスタックトレースを記録するのは非効率的です。

トレースバック関数は, 1 つの引数,構造体へのポインタで呼び出されます。

struct {
	Context    uintptr
	SigContext uintptr
	Buf        *uintptr
	Max        uintptr
}

C 構文では,この構造体は次のようになります。

struct {
	uintptr_t  Context;
	uintptr_t  SigContext;
	uintptr_t* Buf;
	uintptr_t  Max;
};

現在のプログラム実行ポイントからトレースバックを収集するために, Context フィールドはゼロになります。 この場合,トレースバック関数は C コードから呼び出されます。

そうでなければ, Context は以前に context 関数への呼び出しによって返された値になります。 トレースバック関数は,プログラムの実行でその保存された場所からスタックトレースを収集する必要があります。 トレースバック関数は,コンテキストを記録したもの以外の実行スレッドから呼び出すことができますが,それはコンテキストが有効で不変であることがわかっている場合に限られます。 トレースバック関数は,コンテキストを記録したのと同じスレッド上の呼び出しスタック内でより深く呼び出すこともできます。 トレースバック関数は,同じ Context 値を使って複数回呼び出すことができます。 可能であれば,これが特定のコンテキスト値に対して初めて呼び出されるときに結果をキャッシュするのが通常適切です。

トレースバック関数が UNIX システム上のシグナルハンドラから呼び出された場合, SigContext はシグナルハンドラに渡されるシグナルコンテキスト引数になります (uintptr_t にキャストされた Cucontext_t*) 。 これはシグナルが発生した時点でトレースを開始するために使用されます。 トレースバック関数がシグナルハンドラから呼び出されなかった場合, SigContext はゼロになります。

Buf はトレースバック情報を格納する場所です。 Buf[0] が呼び出し元の PC , Buf[1] がその関数の呼び出し元の PC などのように, PC 値にする必要があります。 Max は保存するエントリの最大数です。 関数は,スタックの先頭を示すため,または呼び出し元が別のスタック,おそらく Go スタック上にあることを示すためにゼロを格納する必要があります。

runtime.Callers とは異なり,返される PC の値は,シンボライザ関数に渡されると,呼び出し命令のファイルまたは行を返します。 追加の減算は必要ないか,または適切ではありません。

すべてのプラットフォームで,トレースバック関数は, Go から C への呼び出しから Go への呼び出しがスタックトレースをリクエストしたときに呼び出されます。 linux/amd64, linux/ppc64le ,および freebsd/amd64 では, cgo 呼び出しを実行しているスレッドがシグナルを受信したときにもトレースバック関数が呼び出されます。 将来のバージョンの Go では追加の呼び出しが行われる可能性があるため,トレースバック関数はいつ呼び出されるのかを想定してはいけません。

シンボル化関数は, 1 つの引数,構造体へのポインタで呼び出されます。

struct {
	PC      uintptr // 情報を取得するプログラムカウンタ
	File    *byte   // ファイル名 (NUL 終端)
	Lineno  uintptr // 行番号
	Func    *byte   // 関数名 (NUL 終端)
	Entry   uintptr // 関数の入り口
	More    uintptr // この PC の詳細情報がある場合は,ゼロ以外に設定してください。
	Data    uintptr // 実行時には使用されず,関数に使用可能
}

C 構文では,この構造体は次のようになります。

struct {
	uintptr_t PC;
	char*     File;
	uintptr_t Lineno;
	char*     Func;
	uintptr_t Entry;
	uintptr_t More;
	uintptr_t Data;
};

PC フィールドは,トレースバック関数の呼び出しによって返される値になります。

関数が特定のトレースバックに対して最初に呼び出されたとき, PC を除くすべてのフィールドは 0 になります。 可能であれば関数は他のフィールドに記入し,情報が利用できない場合は 0/nil に設定します。 データフィールドは,複数のコールにまたがって有用な情報を格納するために使用できます。 この PC に関する詳細情報がある場合は, More フィールドをゼロ以外に設定し,それ以外の場合はゼロに設定します。 More が 0 以外に設定されている場合,関数は同じ PC で再度呼び出され,異なる情報を返す可能性があります (これはインライン関数での使用を目的としています) 。 More がゼロの場合,関数はトレースバック内の次の PC 値で呼び出されます。 トレースバックが完了すると, PC がゼロに設定された状態で関数がもう一度呼び出されます。 これはあらゆる情報を解放するために使用される可能性があります。 各呼び出しは, More フィールドがゼロのときの PC フィールドを除いて,構造体のフィールドには,戻ったときと同じ値を設定したままにします。 関数は呼び出し間で構造体ポインタのコピーを保持してはいけません。

SetCgoTraceback を呼び出すとき,バージョン引数は関数が受け取ることを期待する構造体のバージョン番号です。 現在これはゼロでなければなりません。

symbolizer 関数は nil でも構いません。 その場合,トレースバック関数の結果は数字として表示されます。 トレースバック関数が nil の場合,シンボライザ関数は呼び出されません。 コンテキスト関数は nil でも構いません。 その場合,トレースバック関数はコンテキストフィールドをゼロに設定して呼び出されるだけです。 コンテキスト関数が nil の場合, Go to C から Go への呼び出しでは,呼び出しスタックの C 部分のトレースバックは表示されません。

SetCgoTraceback は,理想的には init 関数から一度だけ呼び出されるべきです。

func SetFinalizer

func SetFinalizer(obj interface{}, finalizer interface{})

SetFinalizer は, obj に関連付けられているファイナライザを,渡されているファイナライザ関数に設定します。 ガベージコレクタは,関連付けられたファイナライザで到達不能なブロックを見つけると,関連付けを解除し,別のゴルーチンでファイナライザ (obj) を実行します。 これにより, obj は再び到達可能になりますが,関連付けられたファイナライザがなくなります。 SetFinalizer が再度呼び出されないと仮定すると,ガベージコレクタが次に obj にアクセスできないと認識したときに, obj を解放します。

SetFinalizer(obj, nil) は, obj に関連付けられているすべてのファイナライザをクリアします。

引数 obj は, new の呼び出し,複合リテラルのアドレスの取得,またはローカル変数のアドレスの取得によって割り当てられたオブジェクトへのポインタでなければなりません。 引数ファイナライザは, obj の型を代入できる 1 つの引数を取る関数でなければならず,任意の無視された戻り値を持つことができます。 これらのいずれかが当てはまらない場合, SetFinalizer はプログラムを中止する可能性があります。

ファイナライザは依存性の順序で実行されます。 A が B を指している場合,両方ともファイナライザを持ち,それ以外は到達不能な場合は, A のファイナライザのみが実行されます。 A が解放されると, B のファイナライザが実行できます。 巡回構造にファイナライザを含むブロックが含まれる場合,依存関係を考慮した順序付けがないため,そのサイクルはガベージコレクションされることは保証されず,ファイナライザは実行されることが保証されません。

プログラムが obj が指すオブジェクトに到達できなくなった後,ファイナライザは任意の時間に実行されるようにスケジュールされています。 プログラムが終了する前にファイナライザが実行されるという保証はありません。 そのため,通常,長期実行中にオブジェクトに関連付けられたメモリ以外のリソースを解放するためにのみ使用されます。 たとえば,プログラムが Close を呼び出さずに os.File を破棄した場合, os.File オブジェクトはファイナライザを使用して関連するオペレーティングシステムファイル記述子を閉じることができますが,メモリ内のフラッシュをファイナライザに依存させるのは誤りです。 バッファはプログラムの終了時にフラッシュされないため, bufio.Writer などの /O バッファ。

*obj のサイズがゼロバイトの場合にファイナライザが実行されることは保証されていません。

ファイナライザが,パッケージレベル変数のイニシャライザに割り当てられたオブジェクトに対して実行されることは保証されていません。 このようなオブジェクトは,ヒープ割り当てではなく,リンカ割り当てにすることができます。

ファイナライザは,オブジェクトが到達不能になるとすぐに実行されます。 ファイナライザを正しく使用するためには,プログラムはオブジェクトが不要になるまでそのオブジェクトが到達可能であることを確認する必要があります。 グローバル変数に格納されているオブジェクト,またはグローバル変数からポインタをトレースすることによって見つけることができるオブジェクトは,到達可能です。 他のオブジェクトの場合は,オブジェクトを KeepAlive 関数の呼び出しに渡して,オブジェクトが到達可能でなければならない関数内の最後の点をマークします。

たとえば, p がファイルディスクリプタ d を含む構造体を指し, p がそのファイルディスクリプタを閉じるファイナライザを持ち,関数内で p が最後に使用されたのが syscall.Write(pd , buf , size) の呼び出しである場合プログラムが syscall.Write に入るとすぐに p に到達できない可能性があります。 ファイナライザはその時点で実行して p.d を閉じ,閉じたファイルディスクリプタ (さらに悪いことには,別の goroutine によって開かれたまったく別のファイルディスクリプタ) に書き込んでいるため syscall.Write が失敗する原因となります。 この問題を回避するには, syscall.Write を呼び出した後に runtime.KeepAlive(p) を呼び出します。

1 つのゴルーチンは,プログラムのすべてのファイナライザを順番に実行します。 ファイナライザを長時間実行する必要がある場合は,新しいゴルーチンを起動することによって実行する必要があります。

func SetMutexProfileFraction 1.8

func SetMutexProfileFraction(rate int) int

SetMutexProfileFraction は,ミューテックスプロファイルで報告されるミューテックス競合イベントの割合を制御します。 平均 1/rate イベントが報告されています。 前のレートが返されます。

プロファイリングを完全にオフにするには, rate 0 を渡します。 現在の rate を読み取るには, pass rate < 0 を渡します (n>1 の場合,サンプリングの詳細が変わる場合があります) 。

func Stack

func Stack(buf []byte, all bool) int

Stack は,呼び出し側 goroutine のスタックトレースを buf にフォーマットし, buf に書き込まれたバイト数を返します。 すべて true の場合, Stack は,現在のゴルーチンのトレースの後に,他のすべてのゴルーチンのスタックトレースを buf にフォーマットします。

func StartTrace 1.5

func StartTrace() error

StartTrace は現在のプロセスのトレースを有効にします。 トレース中,データはバッファされ, ReadTrace を介して利用可能になります。 トレースがすでに有効になっている場合, StartTrace はエラーを返します。 ほとんどのクライアントは, StartTrace を直接呼び出すのではなく,ランタイム / トレースパッケージまたはテストパッケージの -test.trace フラグを使用する必要があります。

func StopTrace 1.5

func StopTrace()

StopTrace は,以前に有効になっていた場合はトレースを停止します。 StopTrace は,トレースに対するすべての読み取りが完了した後にのみ戻ります。

func ThreadCreateProfile

func ThreadCreateProfile(p []StackRecord) (n int, ok bool)

ThreadCreateProfile は,スレッド作成プロファイル内のレコード数 n を返します。 len(p) >= n の場合, ThreadCreateProfile はプロファイルを p にコピーし, n, true を返します。 len(p) < n の場合, ThreadCreateProfile は p を変更せずに n, false を返します。

ほとんどのクライアントは, ThreadCreateProfile を直接呼び出すのではなく, runtime/pprof パッケージを使用する必要があります。

func UnlockOSThread

func UnlockOSThread()

UnlockOSThread は, LockOSThread への以前の呼び出しを取り消します。これにより,呼び出しゴルーチンでのアクティブな LockOSThread 呼び出しの数がゼロになると,固定オペレーティングシステムスレッドから呼び出しゴルーチンが解放されます。アクティブな LockOSThread 呼び出しがない場合,これはノーオペレーションです。

UnlockOSThread を呼び出す前に,呼び出し元は OS スレッドが他のゴルーチンの実行に適していることを確認する必要があります。呼び出し元が他のゴルーチンに影響を与えるスレッドの状態に永続的な変更を加えた場合,この関数を呼び出してはならず,ゴルーチン (およびスレッド) が終了するまでゴルーチンを OS スレッドにロックしたままにする。

func Version

func Version() string

Version は Go ツリーのバージョン文字列を返します。 それは,ビルド時のコミットハッシュと日付か,可能であれば "go1.3" のようなリリースタグのどちらかです。

type BlockProfileRecord 1.1

BlockProfileRecord は,特定の呼び出しシーケンス (スタックトレース) で発生したブロックイベントを記述します。

type BlockProfileRecord struct {
    Count  int64
    Cycles int64
    StackRecord
}

type Error

Error インターフェースはランタイムエラーを識別します。

type Error interface {
    error

    // RuntimeError は何もしない関数ですが,ランタイムエラーの型と通常のエラーを区別するのに役立ちます。
    // RuntimeError メソッドがある場合,型はランタイムエラーです。
    RuntimeError()
}

type Frame 1.7

フレームは,各呼び出しフレームについてフレームによって返される情報です。

type Frame struct {
    // PC は,このフレーム内の場所のプログラムカウンタです。
    // 別のフレームを呼び出すフレームの場合,これは呼び出し命令のプログラムカウンターになります。
    // インライン化のため,複数のフレームは同じ PC 値を持ちますが,シンボル情報は異なります。
    PC uintptr

    // Func はこの呼び出しフレームの Func 値です。
    // これは, Go 以外のコードや完全にインライン化された関数では無効になります。
    Func *Func

    // Function は,この呼び出しフレームのパッケージパス修飾機能名です。
    // 空でない場合,この文字列はプログラム内の 1 つの機能を一意に識別します。
    // 不明な場合,これは空の文字列になる可能性があります。
    // Func が nil でなければ, Function == Func.Name() となります。
    Function string

    // ファイルと行は,このフレーム内の場所のファイル名と行番号です。
    // 非リーフフレームの場合,これはコールの場所になります。
    // 不明な場合,これらはそれぞれ空の文字列とゼロになります。
    File string
    Line int

    // 機能の入り口点プログラム・カウンター。
    // わからない場合はゼロになります。
    // Func が nil でなければ Entry==Func.Entry() となります。
    Entry uintptr
    // エクスポートされていないフィールドがあります
}

type Frames 1.7

フレームは,呼び出し元から返された PC 値のスライスの関数 / ファイル / 行情報を取得するために使用されることがあります。

type Frames struct {
    // エクスポートされていないフィールドがあります
}

コード:

c := func() {
    // runtime.Callers 自体を含め,最大 10 個まで runtime.Callers に依頼してください。
    pc := make([]uintptr, 10)
    n := runtime.Callers(0, pc)
    if n == 0 {
        // 利用可能な PC がありません。
        // 今やめてください。
        // これは, runtime.Callers への最初の引数が大きい場合に発生する可能性があります。
        return
    }

    pc = pc[:n] // 有効な PC だけを runtime.CallersFrames に渡す
    frames := runtime.CallersFrames(pc)

    // フレームを取得するためにループします。
    // 固定数の PC は無限数のフレームに拡張できます。
    for {
        frame, more := frames.Next()
        // テストパッケージに変更があってもこの例の出力を安定させるには,パッケージの実行時を離れたときに巻き戻しを中止します。
        if !strings.Contains(frame.File, "runtime/") {
            break
        }
        fmt.Printf("- more:%v | %s\n", more, frame.Function)
        if !more {
            break
        }
    }
}

b := func() { c() }
a := func() { b() }

a()

出力:

- more:true | runtime.Callers
- more:true | runtime_test.ExampleFrames.func1
- more:true | runtime_test.ExampleFrames.func2
- more:true | runtime_test.ExampleFrames.func3
- more:true | runtime_test.ExampleFrames

func CallersFrames 1.7

func CallersFrames(callers []uintptr) *Frames

CallersFrames は, Callers から返された PC 値のスライスを受け取り,関数 / ファイル / 行情報を返す準備をします。 フレームが完成するまでスライスを変更しないでください。

func (*Frames) Next 1.7

func (ci *Frames) Next() (frame Frame, more bool)

Next は,次の呼び出し元のためのフレーム情報を返します。 more が false の場合,呼び出し元はもういません (Frame 値は有効です) 。

type Func

Func は実行中のバイナリでは Go 関数を表します。

type Func struct {
    // エクスポートされていないフィールドがあります
}

func FuncForPC

func FuncForPC(pc uintptr) *Func

FuncForPC は与えられたプログラムカウンタアドレスを含む関数を記述する *Func を返すか,そうでなければ nil を返します。

インライン化のために pc が複数の関数を表している場合は,最も内側の関数を記述する a *Func を返しますが,最も外側の関数のエントリが含まれます。

func (*Func) Entry

func (f *Func) Entry() uintptr

Entry は関数のエントリアドレスを返します。

func (*Func) FileLine

func (f *Func) FileLine(pc uintptr) (file string, line int)

FileLine は,プログラムカウンタ pc に対応するソースコードのファイル名と行番号を返します。 pc が f 内のプログラムカウンタでない場合,結果は正確ではありません。

func (*Func) Name

func (f *Func) Name() string

Name は関数の名前を返します。

type MemProfileRecord

MemProfileRecord は,特定の呼び出しシーケンス (スタックトレース) によって割り当てられたライブオブジェクトを記述します。

type MemProfileRecord struct {
    AllocBytes, FreeBytes     int64       // 割り当てられた,解放されたバイト数
    AllocObjects, FreeObjects int64       // 割り当てられ,解放されたオブジェクトの数
    Stack0                    [32]uintptr // このレコードのスタックトレース。 最初の 0 エントリで終了
}

func (*MemProfileRecord) InUseBytes

func (r *MemProfileRecord) InUseBytes() int64

InUseBytes は使用中のバイト数を返します (AllocBytes - FreeBytes) 。

func (*MemProfileRecord) InUseObjects

func (r *MemProfileRecord) InUseObjects() int64

InUseObjects は,使用中のオブジェクトの数を返します (AllocObjects - FreeObjects) 。

func (*MemProfileRecord) Stack

func (r *MemProfileRecord) Stack() []uintptr

Stack は,レコードに関連付けられたスタックトレースを返します。 プレフィックスは r.Stack0 です。

type MemStats

MemStats は,メモリアロケータに関する統計を記録します。

type MemStats struct {

    // Alloc は,割り当てられたヒープオブジェクトのバイト数です。
    //
    // これは HeapAlloc と同じです (下記参照) 。
    Alloc uint64

    // TotalAlloc は,ヒープオブジェクトに割り当てられた累積バイト数です。
    //
    // TotalAlloc はヒープオブジェクトが割り当てられるにつれて増加しますが, Alloc や HeapAlloc とは異なり,オブジェクトが解放されても減少しません。
    TotalAlloc uint64

    // Sys は OS から取得したメモリの総バイト数です。
    //
    // Sys は,以下の XSys フィールドの合計です。
    // Sys は, Go ランタイムによってヒープ,スタック,その他の内部データ構造用に予約されている仮想アドレス空間を測定します。
    // 仮想アドレス空間のすべてが特定の瞬間に物理メモリによって確保されているわけではありませんが,一般的にはすべてがある時点にあります。
    Sys uint64

    // Lookups は,ランタイムによって実行されたポインタルックアップの数です。
    //
    // これは主にランタイム内部のデバッグに役立ちます。
    Lookups uint64

    // Mallocs は,割り当てられたヒープオブジェクトの累積数です。
    // ライブオブジェクトの数は Mallocs - Frees です。
    Mallocs uint64

    // Frees は解放されたヒープオブジェクトの累積数です。
    Frees uint64

    // HeapAlloc は,割り当てられたヒープオブジェクトのバイト数です。
    //
    // " 割り当てられた " ヒープオブジェクトには,到達可能なすべてのオブジェクトと,ガベージコレクタがまだ解放していない到達不可能なオブジェクトが含まれます。
    // 具体的には, HeapAlloc は,ヒープオブジェクトが割り当てられると増加し,ヒープが一掃されて到達不能なオブジェクトが解放されると減少します。
    // スイープは GC サイクル間で段階的に発生するため,これら 2 つのプロセスは平行に発生します。
    // その結果, HeapAlloc はスムーズに変化する傾向があります (世界的に停止するガベージコレクタの典型的なのこぎりとは対照的に) 。
    HeapAlloc uint64

    // HeapSys は, OS から取得したヒープメモリのバイト数です。
    //
    // HeapSys は,ヒープ用に予約されている仮想アドレススペースの量を測定します。
    // これには,予約されているがまだ使用されていない仮想アドレス空間,物理メモリを消費しないが小さい傾向があること,および物理メモリが未使用の後に OS に返された仮想アドレス空間が含まれます (HeapReleased を参照) 後者の測定のために) 。
    //
    // HeapSys は,ヒープの最大サイズを見積もります。
    HeapSys uint64

    // HeapIdle は,アイドル (未使用) スパンのバイト数です。
    //
    // アイドルスパンにはオブジェクトがありません。
    // これらのスパンは OS に返却される可能性があり (また既に返却されている可能性もあります) ,ヒープ割り当てに再利用することも,スタックメモリとして再利用することもできます。
    //
    // HeapIdle から HeapReleased を引いた値は, OS に返される可能性があるメモリの量を見積もりますが,ランタイムによって保持されているため, OS からさらにメモリをリクエストせずにヒープを増やすことができます。
    // この差がヒープサイズよりもかなり大きい場合は,ライブヒープサイズに最近の一時的な急上昇があったことを示しています。
    HeapIdle uint64

    // HeapInuse は,使用中のスパンのバイト数です。
    //
    // 使用中のスパンには,少なくとも 1 つのオブジェクトが含まれています。
    // これらのスパンは,ほぼ同じサイズの他のオブジェクトにしか使用できません。
    //
    // HeapInuse から HeapAlloc を引いた値は,特定のサイズクラス専用のメモリの量を見積もりますが,現在は使用されていません。
    // これは断片化の上限ですが,一般的にこのメモリは効率的に再利用できます。
    HeapInuse uint64

    // HeapReleased は, OS に返される物理メモリのバイト数です。
    //
    // これは, OS に返され,まだヒープ用に再取得されていないアイドルスパンからのヒープメモリをカウントします。
    HeapReleased uint64

    // HeapObjects は,割り当てられたヒープオブジェクトの数です。
    //
    // HeapAlloc と同様に,これはオブジェクトが割り当てられると増加し,ヒープが一掃されて到達不能なオブジェクトが解放されると減少します。
    HeapObjects uint64

    // StackInuse はスタックスパン内のバイトです。
    //
    // 使用中のスタックスパンには,少なくとも 1 つのスタックがあります。
    // これらのスパンは,同じサイズの他のスタックにしか使用できません。
    //
    // 未使用のスタックスパンがヒープに返される (したがって HeapIdle にカウントされる) ため, StackIdle はありません。
    StackInuse uint64

    // StackSys は, OS から取得したスタックメモリのバイト数です。
    //
    // StackSys は StackInuse であり, OS スレッドスタック用に OS から直接取得されたメモリ (これは最小限に抑えられます) です。
    StackSys uint64

    // MSpanInuse は,割り当てられた mspan 構造体のバイト数です。
    MSpanInuse uint64

    // MSpanSys は, mspan 構造体用に OS から取得したメモリのバイト数です。
    MSpanSys uint64

    // MCacheInuse は,割り当てられた mcache 構造体のバイト数です。
    MCacheInuse uint64

    // MCacheSys は, mcache 構造体用に OS から取得したメモリのバイト数です。
    MCacheSys uint64

    // BuckHashSys は,プロファイリングバケットハッシュテーブル内のメモリのバイト数です。
    BuckHashSys uint64

    // GCSys は,ガベージコレクションメタデータ内のメモリのバイト数です。
    GCSys uint64 // Go 1.2

    // OtherSys は,その他のオフヒープ実行時割り当てにおけるメモリのバイト数です。
    OtherSys uint64 // Go 1.2

    // NextGC は,次の GC サイクルの目標ヒープサイズです。
    //
    // ガベージコレクタの目標は, HeapAlloc ≤ NextGC を維持することです。
    // 各 GC サイクルの終わりに,次のサイクルのターゲットは到達可能なデータ量と GOGC の値に基づいて計算されます。
    NextGC uint64

    // LastGC は, 1970 年 (UNIX エポック) からの経過秒数で,最後のガベージコレクションが終了した時刻です。
    LastGC uint64

    // PauseTotalNs は,プログラムが開始されてからの GC 停止世界一時停止における累積ナノ秒です。
    //
    // 世界一時停止中は,すべてのゴルーチンが一時停止され,ガベージコレクタだけが実行できます。
    PauseTotalNs uint64

    // PauseNs は,最近の GC の世界一時停止時間 (ナノ秒単位) の循環バッファです。
    //
    // 最新の一時停止は PauseNs[(NumGC+255)%256] です。
    // 一般に, PauseNs[N%256] は最新の N%256 回目の GC サイクルで一時停止した時間を記録します。
    // GC サイクルごとに複数の休止がある場合があります。
    // これはサイクル中のすべての休止の合計です。
    PauseNs [256]uint64

    // PauseEnd は, 1970 年 (UNIX エポック) からのナノ秒単位で,最近の GC の一時停止終了時間を循環的にバッファしたものです。
    //
    // このバッファは PauseN と同じ方法で埋められます。
    // GC サイクルごとに複数の休止がある場合があります。
    // これはサイクルの最後の休止の終わりを記録します。
    PauseEnd [256]uint64 // Go 1.4

    // NumGC は完了した GC サイクル数です。
    NumGC uint32

    // NumForcedGC は,アプリケーションが GC 関数を呼び出すことによって強制された GC サイクルの数です。
    NumForcedGC uint32 // Go 1.8

    // GCCPUFraction は,プログラムの開始以降に GC によって使用された,このプログラムの使用可能な CPU 時間の割合です。
    //
    // GCCPUFraction は 0 から 1 までの数値で表されます。
    // 0 は GC がこのプログラムの CPU をまったく消費していないことを意味します。
    // プログラムの使用可能 CPU 時間は,プログラムが開始されてから GOMAXPROCS の整数として定義されています。
    // つまり, GOMAXPROCS が 2 で,プログラムが 10 秒間実行されている場合,その " 使用可能 CPU" は 20 秒です。
    // GCCPUFraction には,書き込みバリアー活動に使用された CPU 時間は含まれません。
    //
    // これは, GODEBUG=gctrace=1 によって報告された CPU の割合と同じです。
    GCCPUFraction float64 // Go 1.5

    // EnableGC は, GC が有効になっていることを示します。
    // GOGC=off であっても,それは常に真実です。
    EnableGC bool

    // DebugGC は現在未使用です。
    DebugGC bool

    // BySize は,サイズごとのクラス割り当て統計を報告します。
    //
    // BySize[N] は,サイズ S の割り当てに関する統計を示します。
    // ここで, BySize[N-1].Size < S ≤ BySize[N].Size です。
    //
    // これは, BySize[60].Size より大きい割り当てを報告しません。
    BySize [61]struct {
        // Size は,このサイズクラスのオブジェクトの最大バイトサイズです。
        Size uint32

        // Mallocs は,このサイズクラスに割り当てられているヒープオブジェクトの累積数です。
        // 累積割り当てバイト数は, Size*Mallocs です。
        // このサイズクラスのライブオブジェクトの数は Mallocs - Frees です。
        Mallocs uint64

        // Frees は,このサイズクラスで解放されたヒープオブジェクトの累積数です。
        Frees uint64
    }
}

type StackRecord

StackRecord は 1 つの実行スタックを記述します。

type StackRecord struct {
    Stack0 [32]uintptr // このレコードのスタックトレース。 最初の 0 エントリで終了
}

func (*StackRecord) Stack

func (r *StackRecord) Stack() []uintptr

Stack は,レコードに関連付けられたスタックトレースを返します。 プレフィックスは r.Stack0 です。

type TypeAssertionError

TypeAssertionError は失敗した型アサーションを説明します。

type TypeAssertionError struct {
    // エクスポートされていないフィールドがあります
}

func (*TypeAssertionError) Error

func (e *TypeAssertionError) Error() string

func (*TypeAssertionError) RuntimeError

func (*TypeAssertionError) RuntimeError()

サブディレクトリ

名前 概要
..
cgo cgo パッケージは,cgo ツールで生成されたコードのランタイムサポートを含んでいます。
debug debug パッケージは,プログラムを実行中に,自分自身をデバッグするための機能を含んでいます。
msan
pprof pprof パッケージは,pprof 視覚化ツールのフォーマットでランタイムプロファイルデータを出力します。
race race パッケージは,データレース検知ロジックを実装します。
trace trace パッケージは,Go 実行トレーサ用トレースを生成するプログラムのための機能を含みます。