core.memory

immutable size_t pageSize;

システム・ページのサイズ(バイト)。

この値はアプリケーションの起動時に設定される。この値はアプリケーションの起動時に設定される。 共有モジュールのコンストラクタや Dランタイム自体の初期化などで使用するのが安全である。

Examples:

ubyte[] buffer = new ubyte[pageSize];

struct GC;

この構造体は、D言語のすべてのガベージコレクション機能をカプセル化する。 プログラミング言語のすべてのガベージコレクション機能をカプセル化する。

struct Stats;

パブリックAPIを通じて公開されるGC統計情報の集約。

size_t usedSize;

GCヒープ上の使用バイト数(コレクション後にのみ更新されるかもしれない)

size_t freeSize;

GCヒープ上の空きバイト数(コレクション後にのみ更新されるかもしれない)

ulong allocatedInCurrentThread;

プログラム開始以降に現在のスレッドに割り当てられたバイト数

struct ProfileStats;

現在のプロファイル情報の集約

size_t numCollections;

GCサイクルの総数

Duration totalCollectionTime;

GCに費やされた合計時間

Duration totalPauseTime;

スレッドがGC中に一時停止した合計時間

Duration maxPauseTime;

1回のGCサイクルでスレッドが一時停止した最大時間

Duration maxCollectionTime;

1回のGCサイクルに費やされた最大の時間

static pure nothrow @safe void enable();

コレクションが以前に。 GC.disable() この関数は再入可能である。 この関数は再入可能であり、自動収集が有効になる前に、GC.disable() を呼び出すたびに1回呼び出されなければならない。 を呼び出すたびに1回呼び出されなければならない。

static pure nothrow @safe void disable();

プロセスのフットプリントを最小化するために実行される自動ガベージコレクションを無効にする。 プロセスのフットプリントを最小化するために実行される自動ガベージコレクションを無効にする。 コレクションは、実装が正しく動作させるために必要であると判断した プログラムの正しい動作のために必要であると実装が判断した場合、コレクションは発生し続ける、 例えば、メモリ不足の状態などである。 この関数はリエントラントである、 を呼び出すたびに、GC.enable() 。 GC.disable(). 属性とは異なり @nogc属性とは異なる、 GC.disable()属性とは異なり 属性とは異なり、すべてのスレッドでコレクションを停止するが、GCアロケーションはまだ可能である。 コレクションを無効にするとGCの一時停止がなくなる。

static pure nothrow @safe void collect();

完全なコレクションを開始する。 この意味は、ガベージコレクタの実装によって変わるかもしれないが ガベージコレクタの実装によって意味が変わるかもしれないが、典型的な動作は、すべてのスタックセグメントのルートをスキャンすることである。 すべてのスタックセグメントのルートをスキャンし、アクセス可能なメモリブロックを生きているものとしてマークする、 そして空き領域を取り戻す。 この動作は、すべての この動作は、収集プロセスの少なくとも一部のために、実行中のすべてのスレッドを一時停止する必要があるかもしれない。

static pure nothrow @safe void minimize();

空き物理メモリをオペレーティング・システムに返すことによって、管理されたメモリ空間を最小化することを示す。 物理メモリをオペレーティング・システムに返すことによって、管理されたメモリ空間を最小化することを示す。 返される空きメモリの量は アロケータ設計とプログラム動作に依存する。

enum BlkAttr: uint;

メモリ・ブロック属性を表すビット・フィールドの要素。 これらは これらはgetAttr、setAttr、clrAttr関数で操作される。

NONE

属性は設定されていない。

FINALIZE

collect時にこのブロックのデータを確定する。

NO_SCAN

collect時にこのブロックをスキャンしない。

NO_MOVE

collect時にこのメモリブロックを移動しない。

APPENDABLE

このブロックには、追加を許可する情報が含まれている。

これは手動でアレイを割り当てるために使用できる。初期スライスサイズは0である。

注釈: スライスの使用可能サイズはブロック・サイズと一致しない。使用する capacityを使う。

例:

// 基礎となる配列を割り当てる。
int*  pToArray = cast(int*)GC.malloc(10 * int.sizeof, GC.BlkAttr.NO_SCAN | GC.BlkAttr.APPENDABLE);
// sliceをバインドする。sliceに容量情報が含まれていることを確認する。
int[] slice = pToArray[0 .. 0];
assert(capacity(slice) > 0);
// sliceに追加しても、sliceの位置は変わらない。
slice.length = 5;
slice ~= 1;
assert(slice.ptr == p);

NO_INTERIOR

このブロックは、生きている間はベースへのポインタを持つことが保証されている。 を持つことが保証されている。 内部ポインタは安全に無視できる。 この属性は この属性は、非常に大きなデータ構造で偽のポインタを排除するのに便利である。 であり、少なくとも1ページの大きさのデータ構造に対してのみ実装される。

alias BlkInfo = .BlkInfo_;

管理されたメモリ・ブロックに関する集約情報を含む。 この この構造体の目的は、詳細な情報が必要な場合に、より効率的なクエリースタイルをサポートすることである。 詳細な情報が必要な場合に、より効率的なクエリースタイルをサポートするためである。

base = 対象ブロックのベースへのポインタ。 size = ベースから計算されるブロックのサイズ。 attr = メモリ・ブロックに設定されている属性ビット。

static nothrow uint getAttr(scope const void* p);

static pure nothrow uint getAttr(void* p);

pが参照しているメモリに設定されているすべてのブロック属性を表すビット・フィールドを返す。 pが、このガベージコレクタによって元々割り当てられていないメモリを参照している場合、そのメモリブロックに設定されているすべてのブロック属性を表すビットフィールドを返す。 このガベージコレクタによって元々割り当てられていないメモリを参照している場合、メモリブロックの内部を指している場合、または pがNULLの場合は、0が返される。

Parameters:

void* p

有効なメモリ・ブロックのルートへのポインタ、またはnullへのポインタ。

Returns:

で参照されるメモリ・ブロックに設定されているビットを含むビット・フィールド。 またはエラー時にゼロを返す。

static nothrow uint setAttr(scope const void* p, uint a);

static pure nothrow uint setAttr(void* p, uint a);

pが参照しているメモリに対して、指定されたビットを設定する。 このガベージコレクタによって元々割り当てられていないメモリを参照している場合、 メモリブロックの内部を指している。 メモリブロックの内部を指している場合、または p が NULL の場合、アクションは実行されない。 は実行されない。

Parameters:

void* p	有効なメモリブロックのルートへのポインタ、またはNULLへのポインタ。
uint a	このメモリ・ブロックに設定するビットを含むビット・フィールド。

Returns:

指定されたビットが設定された後のgetAttrの呼び出しの結果。 を呼び出した結果。

static nothrow uint clrAttr(scope const void* p, uint a);

static pure nothrow uint clrAttr(void* p, uint a);

pが参照しているメモリについて、指定されたビットをクリアする。 は、このガベージコレクタによって元々割り当てられていないメモリを参照している、 メモリブロックの内部を指している場合、または p が NULL の場合は、何もしない。 は実行されない。

Parameters:

void* p	有効なメモリブロックのルートへのポインタ、またはNULLへのポインタ。
uint a	このメモリ・ブロックのクリアすべきビットを含むビット・フィールド。

Returns:

指定されたビットがクリアされた後のgetAttrの呼び出しの結果。 を呼び出した結果である。

static pure nothrow void* malloc(size_t sz, uint ba = 0, scope const TypeInfo ti = null);

ガベージコレクタに、管理されたメモリのアラインされたブロックを要求する。 このメモリは、freeの呼び出しで自由に削除することができる。 コレクション実行中に自動的に破棄され、クリーンアップされる。 もし 割り当てに失敗した場合、この関数はonOutOfMemoryを呼び出す。 OutOfMemoryErrorをスローする。

Parameters:

size_t sz	希望のアロケーション・サイズをバイト単位で指定する。
uint ba	このブロックに設定する属性のビットマスク。
TypeInfo ti	メモリを説明するTypeInfo。GCはこの情報を使って ポインタのスキャンを改善したり、ファイナライザを呼び出したりする。

Returns:

割り当てられたメモリーへの参照。 への参照。

Throws:

割り当てに失敗するとOutOfMemoryError。

static pure nothrow BlkInfo qalloc(size_t sz, uint ba = 0, scope const TypeInfo ti = null);

ガベージコレクタに、アライメントされた管理メモリのブロックを要求する。 このメモリは、freeの呼び出しで自由に削除することもできるし、コレクション実行中に自動的に破棄されクリーンアップされることもある。 コレクション実行中に自動的に破棄され、クリーンアップされるかもしれない。 もし 割り当てに失敗した場合、この関数はonOutOfMemoryを呼び出す。 OutOfMemoryErrorをスローする。

Parameters:

size_t sz	希望のアロケーション・サイズをバイト単位で指定する。
uint ba	このブロックに設定する属性のビットマスク。
TypeInfo ti	メモリを説明するTypeInfo。GCはこの情報を使って ポインタのスキャンを改善したり、ファイナライザを呼び出したりする。

Returns:

割り当てられたメモリー・ブロックに関する情報、またはエラー時のBlkInfo.init。 エラーが発生した。

Throws:

割り当て失敗時に OutOfMemoryError。

static pure nothrow void* calloc(size_t sz, uint ba = 0, const TypeInfo ti = null);

ガベージコレクタに管理メモリのアラインされたブロックを要求する、 これはすべてのビットが0に設定されて初期化される。 このメモリは このメモリは、freeの呼び出しで自由に削除することができる。 コレクション実行中に自動的にクリーンアップされる。 割り当てに失敗した場合 関数はonOutOfMemoryを呼び出す。 OutOfMemoryErrorをスローする。

Parameters:

size_t sz	希望のアロケーション・サイズをバイト単位で指定する。
uint ba	このブロックに設定する属性のビットマスク。
TypeInfo ti	メモリを説明するTypeInfo。GCはこの情報を使って ポインタのスキャンを改善したり、ファイナライザを呼び出したりする。

Returns:

割り当てられたメモリーへの参照。 への参照。

Throws:

割り当てに失敗した場合は OutOfMemoryError。

static pure nothrow void* realloc(return scope void* p, size_t sz, uint ba = 0, const TypeInfo ti = null);

の内容を保持したまま、新しいメモリ・ブロックを拡張、縮小、または割り当てる。 既存のブロック

もし szがゼロの場合、pによって参照されるメモリは、あたかも の呼び出しによって確保されたかのように、確保解除される。 free を呼び出すことによって解放される。 もし pがnull の場合、malloc を介して新しいメモリが確保される。 もし pがGCから割り当てられていないメモリ、または割り当てられたメモリ・ブロックの内部を指している場合、操作は実行されず、新しいメモリが。 である場合、操作は実行されず、NULLが返される。

そうでなければ、サイズ szの新しいメモリブロックが割り当てられる。 malloc を呼び出すかのように、新しいサイズのメモリ・ブロックが割り当てられる。 を呼び出す。 新しいメモリブロックの内容は、古いメモリブロックの内容と同じになる。 新しいメモリ・ブロックの内容は、古いメモリ・ブロックの内容と同じである。

呼び出し側は、渡されたメモリ・ブロックへのライブ・ポインタが他にないことを保証する。 によってすぐに解放されないかもしれない。 realloc. ガベージ・コレクタは、メモリ・ブロックが未使用であれば、後のコレクションでそのメモリ・ブロックを取り戻すことができる。 で回収することができる。 割り当てに失敗した場合、この関数はOutOfMemoryError をスローする。

もし baがゼロ(デフォルト)の場合、既存のメモリ の属性が割り当てに使われる。 もし baがゼロでなく、新しいメモリが割り当てられない場合、ba のビットは現在のメモリブロックのものに置き換わる。 のビットが現在のメモリ・ブロックのビットを置き換える。

Parameters:

void* p	有効なメモリブロックのベースへのポインタ、またはnull へのポインタ。
size_t sz	希望のアロケーション・サイズ(バイト単位)。
uint ba	このブロックに設定するBlkAttr属性のビットマスク。
TypeInfo ti	メモリを説明するTypeInfo。GCはこの情報を使うかもしれない ポインタのスキャンを改善したり、ファイナライザを呼び出したりする。

Returns:

成功した場合は割り当てられたメモリーへの参照、null 。 szが ゼロであるか、ポインタがGCで割り当てられたメモリ・ブロックのベースを指していない場合、割り当てられたメモリへの参照。 メモリ・ブロックのベースを指していない。

Throws:

OutOfMemoryError 割り当てに失敗した場合

Examples:

enum size1 = 1 << 11 + 1; // 大規模オブジェクトプール内のページ
enum size2 = 1 << 22 + 1; // 大規模オブジェクトプールサイズよりも大きい

auto data1 = cast(ubyte*)GC.calloc(size1);
auto data2 = cast(ubyte*)GC.realloc(data1, size2);

GC.BlkInfo info = GC.query(data2);
assert(info.size >= size2);

static pure nothrow size_t extend(void* p, size_t mx, size_t sz, const TypeInfo ti = null);

pによって参照される管理メモリブロックを、少なくともmxバイト拡張するよう要求する。 szバイトの拡張を希望する。 もし 必要なサイズの拡張が不可能な場合、または p がこのガベージコレクタによって元々割り当てられていないメモリを参照している場合 を参照している場合は、何もしない。 されない。

Parameters:

void* p	有効なメモリブロックのルートへのポインタ、または null へのポインタ。
size_t mx	最小拡張サイズ(バイト)。
size_t sz	必要な拡張サイズ(バイト単位)。
TypeInfo ti	完全なメモリブロックを記述する TypeInfo。GCは この情報を使って、ポインタのスキャンを改善したり、ファイナライザを呼び出したりする。 ファイナライザを呼び出す。

Returns:

pが参照する拡張メモリブロックのバイト単位のサイズ。 またはゼロ。

注釈: 拡張は、スライス(またはメモリブロックを持つスライス)を拡張するために使用することもできる。 Extend は、スライス(または APPENDABLE情報)を拡張するためにも使うことができる。ただし、戻り値は成功の指標としてのみ使用すること。 を成功の指標としてのみ使用する。 capacityを使うべきである。 を使うべきである。

Examples:

標準拡張

size_t size = 1000;
int* p = cast(int*)GC.malloc(size * int.sizeof, GC.BlkAttr.NO_SCAN);

//割り当てられたデータを1000要素、できれば2000要素拡張してみる。
size_t u = GC.extend(p, 1000 * int.sizeof, 2000 * int.sizeof);
if (u != 0)
    size = u / int.sizeof;

Examples:

スライス拡張

int[] slice = new int[](1000);
int*  p     = slice.ptr;

//拡張を試みる前に、容量にアクセスできるかどうかを確認する
if (slice.capacity)
{
    //スライスを1000要素拡張してみてほしい。2000が望ましい。
    size_t u = GC.extend(p, 1000 * int.sizeof, 2000 * int.sizeof);
    if (u != 0)
    {
        slice.length = slice.capacity;
        assert(slice.length >= 2000);
    }
}

static pure nothrow size_t reserve(size_t sz);

オペレーティング・システムから少なくともszバイトのメモリを取得するよう要求する。 を要求する。

Parameters:

size_t sz

希望するサイズをバイト数で指定する。

Returns:

pが参照しているメモリを解放する。

static pure nothrow @nogc void free(void* p);

pがNULLの場合、何も起こらない。 pが、このガベージコレクタによって元々割り当てられていないメモリを参照している場合 コレクタによって元々割り当てられていないメモリを参照している場合、p がメモリブロックの内部を指している場合、またはこの メソッドがファイナライザから呼び出された場合は、何も起こらない。 ブロック は、FINALIZE属性が設定されているかどうかに関係なく、ファイナライズされない。 がセットされているかどうかに関係なく、ブロックはファイナライズされない。 ファイナライズしたい場合は destroyの前に GC.free.

Parameters:

void* p

有効なメモリ・ブロックのルートへのポインタ、またはnullへのポインタ。

static pure nothrow @nogc @trusted inout(void)* addrOf(inout(void)* p);

static pure nothrow @nogc @trusted void* addrOf(void* p);

pを含むメモリ・ブロックのベース・アドレスを返す。 この値は、pが内部ポインタであるかどうかを判断するのに便利である。 のようなルーチンに渡すことができる。 pが がこのガベージコレクタによって元々割り当てられていないメモリを参照している場合、pがNULLの場合、または pがNULLの場合、またはガベージコレクタがこの操作をサポートしていない場合、NULLが返される、 が返される。

Parameters:

inout(void)* p

有効なメモリ・ブロックのルートまたは内部へのポインタ、あるいは へのポインタである。

Returns:

pが参照するメモリ・ブロックのベース・アドレス、またはエラー時にはnull。

static nothrow @nogc size_t sizeOf(scope const void* p);

static pure nothrow @nogc size_t sizeOf(void* p);

pが参照するメモリブロックの真のサイズを返す。 この値は、reallocの呼び出しが既存のブロックのサイズを変更できる最大バイト数を表す。 の呼び出しが既存のブロックのサイズを変更できる最大バイト数を表す。 pが、このガベージコレクタによって元々割り当てられていないメモリを参照している場合 メモリブロックの内部を指している。 を指している場合、またはpがNULLの場合、0が返される。

Parameters:

void* p

有効なメモリ・ブロックのルートへのポインタ、またはnullへのポインタ。

Returns:

pが参照するメモリ・ブロックのサイズ(バイト単位)。

static nothrow BlkInfo query(return scope const void* p);

static pure nothrow BlkInfo query(return scope void* p);

pを含むメモリブロックに関する集約情報を返す。 がこのガベージコレクタによって元々割り当てられていないメモリを参照している場合、 pがNULLの場合、または pがNULLの場合、またはガベージコレクタがこの操作をサポートしていない場合、 BlkInfo.initが返される。 通常、この操作のサポートは addrOfのサポートに依存する。

Parameters:

void* p

有効なメモリブロックのルートまたは内部へのポインタ、あるいは へのポインタである。

Returns:

pまたはBlkInfo.initによって参照されるメモリブロックに関する情報。 によって参照されるメモリブロックに関する情報。

static nothrow @nogc @safe Stats stats();

現在アクティブなGC実装のランタイム統計情報を返す。 利用可能なメトリクスのリストについては、core.memory.GC.Stats を参照のこと。

static nothrow @nogc @safe ProfileStats profileStats();

現在アクティブなGC実装のランタイム・プロファイル統計を返す。 利用可能なメトリクスのリストについては、core.memory.GC.ProfileStats を参照のこと。

static pure nothrow @nogc void addRoot(const void* p);

pによって参照されるGCメモリブロックを指す内部ルートを追加する。 その結果、pによって参照されるブロック自身と、それを介してアクセス可能なすべてのブロックは、pによって参照されるまでライブとみなされる。 ルートが再び削除されるまで、ライブとみなされる。

pがNULLの場合、操作は実行されない。

Parameters:

void* p

GCが管理するメモリ・ブロックへのポインタ、またはnullである。

例:

// 典型的なC言語のスタイルのコールバックメカニズム; 。渡された関数は、
// 後でユーザが指定したコンテキストポインタとともに
// 呼び出される。
extern(C) void addCallback(void function(void*), void*);

// GCヒープ上にオブジェクトを割り当てる(これは通常は
// アプリケーション固有のコンテキストデータとなる)。
auto context = new Object;

// Dコード(スタック、GCヒープなど)から参照されなくなった場合でも、
// 収集されないようにする。
GC.addRoot(cast(void*)context);

// また、移動するコレクタがオブジェクトを
// 再配置しないようにする。
GC.setAttr(cast(void*)context, GC.BlkAttr.NO_MOVE);

// これで、コンテキストをCライブラリに安全に渡すことができる。
addCallback(&myHandler, cast(void*)context);

extern(C) void myHandler(void* ctx)
{
    // コールバックが一度だけ呼び出されると仮定すると、
    // 追加したルートを今削除して、後でGCが
    // それを収集できるようにすることができる。
    GC.removeRoot(ctx);
    GC.clrAttr(ctx, GC.BlkAttr.NO_MOVE);

    auto context = cast(Object)ctx;
    // ここでcontextを使う…
}

static pure nothrow @nogc void removeRoot(const void* p);

pによって参照されるメモリブロックを、コレクション中にスキャンされるルート の内部リストからpで参照されるメモリブロックを削除する。 p が NULL または以前に addRoot() に渡された値でない場合は、操作は実行されない。 でない場合、操作は実行されない。

Parameters:

void* p

GCが管理するメモリ・ブロックへのポインタ、またはnull。

static pure nothrow @nogc void addRange(const void* p, size_t sz, const TypeInfo ti = null);

収集中にポインタをスキャンするメモリ範囲のリストにp[0 .. sz] を追加する。 ポインタをスキャンするメモリ範囲のリストに追加する。pがnullの場合、操作は実行されない。

p[0 .. sz] は、呼び出しによって適切に管理されると想定されるメモリの不透明な範囲として扱われることに注釈: する。 として扱われることに注意。特に、pが を指している場合、addRangeはこのブロックをライブとマークしない。

Parameters:

void* p	有効なメモリアドレスへのポインタ、またはnullへのポインタ。
size_t sz	追加するブロックのバイト単位のサイズ。szがゼロの場合は を指定する。pがnullの場合、szは0でなければならない。
TypeInfo ti	メモリを記述するTypeInfo。GCはこの情報を使って ポインタのスキャンを改善したり、ファイナライザを呼び出したりする。

例:

// Cのヒープにメモリーを割り当てる。
enum size = 1_000;
auto rawMemory = core.stdc.stdlib.malloc(size);

// GCの範囲として追加する。
GC.addRange(rawMemory, size);

// これで、rawMemoryに格納されたGC管理メモリーへのポインタは、
// コレクション時に認識される。

static pure nothrow @nogc void removeRange(const void* p);

コレクション中にスキャンされる範囲の内部リストから、pで始まるメモリ範囲を削除する。 を削除する。p が NULL または以前に でない場合、操作は実行されない。 は実行されない。

Parameters:

void* p

有効なメモリ・アドレスへのポインタ、またはNULLへのポインタ。

static void runFinalizers(scope const void[] segment);

指定されたコード・セグメントのアドレス範囲にあるファイナライザを実行する。 実行する。 これは ライブラリをアンロードする前に使用される。 このコード・セグメントにファイナライザを持つすべてのマッチするオブジェクトは、死んだものとみなされる。 このメソッドを呼び出している間または呼び出した後にそれらを使用すると、未定義の動作になる。 このメソッドを呼び出している間または呼び出した後にそれらを使用すると、未定義の動作:" になる。

Parameters:

void[] segment

コードセグメントのアドレス範囲。

static nothrow @nogc @safe bool inFinalizer();

現在のスレッドがオブジェクトの最終化を実行しているかどうかを GC に問い合わせる。 を実行しているかどうかを照会する。

いくつかのGC実装(現在の保守的なものなど)は、オブジェクトのファイナライズ中のGCメモリ割り当てをサポートしていない。 オブジェクトのファイナライズ中にGCメモリ割り当てをサポートしないので、この関数を使用することで、そのようなプログラミングを防ぐことができる。 を使用すると、そのようなプログラミング・エラーを防ぐことができる。

Returns:

現在のスレッドがファイナライザ(GCによって呼び出されるデストラクタ)の中にある場合、trueを返す。 デストラクタである。

Examples:

// デストラクタから呼び出されたコードのみが、ファイナライズ中に実行される。
assert(!GC.inFinalizer);

Examples:

enum Outcome
{
    notCalled,
    calledManually,
    calledFromDruntime
}

static class Resource
{
    static Outcome outcome;

    this()
    {
        outcome = Outcome.notCalled;
    }

    ~this()
    {
        if (GC.inFinalizer)
        {
            outcome = Outcome.calledFromDruntime;

            import core.exception : InvalidMemoryOperationError;
            try
            {
                /*
                 * 現在、ファイナライズ中にGCメモリーを
                 * 割り当てることは禁止されており、
                 * `InvalidMemoryOperationError`がスローされる原因となる。
                 *
                 * `GC.inFinalizer`は、このようなプログラミングエラーを防ぐために
                 * 使用することができ、また、デストラクタが
                 * GCによって呼び出されたかどうかを確認するより
                 * 効率的な方法でもある。
                 */
                cast(void) GC.malloc(1);
                assert(false);
            }
            catch (InvalidMemoryOperationError e)
            {
                return;
            }
            assert(false);
        }
        else
            outcome = Outcome.calledManually;
    }
}

static void createGarbage()
{
    auto r = new Resource;
    r = null;
}

assert(Resource.outcome == Outcome.notCalled);
createGarbage();
GC.collect;
assert(
    Resource.outcome == Outcome.notCalled ||
    Resource.outcome == Outcome.calledFromDruntime);

auto r = new Resource;
GC.runFinalizers((cast(const void*)typeid(Resource).destructor)[0..1]);
assert(Resource.outcome == Outcome.calledFromDruntime);
Resource.outcome = Outcome.notCalled;

debug(MEMSTOMP) {} else
{
    // リソースデータはまだ利用可能であると仮定する
    r.destroy;
    assert(Resource.outcome == Outcome.notCalled);
}

r = new Resource;
assert(Resource.outcome == Outcome.notCalled);
r.destroy;
assert(Resource.outcome == Outcome.calledManually);

static nothrow ulong allocatedInCurrentThread();

現在のスレッドに割り当てられたバイト数を返す。 に割り当てられたバイト数を返す。これは GC.stats().allocatedInCurrentThreadと同じだが、より高速である。

Examples:

allocatedInCurrentThreadを使う

ulong currentlyAllocated = GC.allocatedInCurrentThread();
struct DataStruct
{
    long l1;
    long l2;
    long l3;
    long l4;
}
DataStruct* unused = new DataStruct;
assert(GC.allocatedInCurrentThread() == currentlyAllocated + 32);
assert(GC.stats().allocatedInCurrentThread == currentlyAllocated + 32);

pure nothrow @nogc @trusted void* pureMalloc()(size_t size);

pure nothrow @nogc @trusted void* pureCalloc()(size_t nmemb, size_t size);

pure nothrow @nogc @system void* pureRealloc()(void* ptr, size_t size);

pure nothrow @nogc @system void pureFree()(void* ptr);

C言語のメモリ割り当て関数malloc 、calloc 、およびメモリ解放関数 の純粋な亜種である。 realloc およびデアロケーション関数free 。

UNIX 98は、失敗時にerrnoをENOMEMに設定することを要求している。 純度は、errno の値を保存し、復元することで達成される。 の値を保存および復元することで、あたかも変更されなかったかのように動作する。

See Also:

Dの純度のルール、 これは、特定の状況下でメモリ割り当てを許可するものである。

Examples:

ubyte[] fun(size_t n) pure
{
    void* p = pureMalloc(n);
    p !is null || n == 0 || assert(0);
    scope(failure) p = pureRealloc(p, 0);
    p = pureRealloc(p, n *= 2);
    p !is null || n == 0 || assert(0);
    return cast(ubyte[]) p[0 .. n];
}

auto buf = fun(100);
assert(buf.length == 200);
pureFree(buf.ptr);

@system void __delete(T)(ref T x);

オブジェクトを破棄し、デアロケートする。

詳しくは __delete(x)の場合、何もせずに戻る。 xがnull の場合は、何もせずに戻る。そうでなければ は以下のアクションを順番に実行する:

• で参照されているオブジェクトのデストラクタ~this() を呼び出す。 x (で参照されるオブジェクトのデストラクタを呼び出す(もし xが参照するオブジェクトのデストラクタを呼び出す。 が指すオブジェクトのデストラクタを呼び出す。 x(を呼び出す。 xstructへのポインタの場合)。 構造体の配列は、もし定義されていれば、配列の各要素に対してデストラクタを呼び出す。 デストラクタが定義されていない場合、このステップは何の効果もない。
• のために割り当てられたメモリを解放する。 x.もし xがクラス またはインターフェイスへの参照である場合、そのインスタンスに割り当てられたメモリが解放される。もし xが がポインタの場合、指定されたオブジェクトに割り当てられたメモリが解放される。もし xが であれば、その配列のために確保されたメモリが解放される。 もし xがnew (またはGC APIにおけるより低レベルの同等のもの)で以前に割り当てられたメモリを参照していない場合、動作は未定義である。 またはGC APIにおけるより低レベルの同等物)で以前に割り当てられたメモリを参照しない場合、動作は未定義のままである。
• 最後に xはnull に設定される。に設定されている。 他の参照を通じて解放されたメモリを読み書きしようとすると、未定義の動作になる。

注釈 ユーザーは destroyオブジェクトを明示的にファイナライズする、 そして _deleteに頼るのみである。 destroy に頼るしかない。

Parameters:

T x	破棄されるべきオブジェクトを集約する

See Also:

destroy, GC.free

History:

delete キーワードはGCで割り当てられたメモリを解放することができた。 これは本質的に@safe ではないため、非推奨となった。 この関数は、delete からの移行を容易にするために追加された。 この関数は、以前のdelete キーワードと同じ機能を実行する。

Examples:

クラスの削除

bool dtorCalled;
class B
{
    int test;
    ~this()
    {
        dtorCalled = true;
    }
}
B b = new B();
B a = b;
b.test = 10;

assert(GC.addrOf(cast(void*) b) != null);
__delete(b);
assert(b is null);
assert(dtorCalled);
assert(GC.addrOf(cast(void*) b) == null);
// しかし、注意が必要だ。aはまだそれを指している
assert(a !is null);
assert(GC.addrOf(cast(void*) a) == null); // しかし、有効なGCポインタではない

Examples:

インターフェースを削除する

bool dtorCalled;
interface A
{
    int quack();
}
class B : A
{
    int a;
    int quack()
    {
        a++;
        return a;
    }
    ~this()
    {
        dtorCalled = true;
    }
}
A a = new B();
a.quack();

assert(GC.addrOf(cast(void*) a) != null);
__delete(a);
assert(a is null);
assert(dtorCalled);
assert(GC.addrOf(cast(void*) a) == null);

Examples:

構造体を削除する

bool dtorCalled;
struct A
{
    string test;
    ~this()
    {
        dtorCalled = true;
    }
}
auto a = new A("foo");

assert(GC.addrOf(cast(void*) a) != null);
__delete(a);
assert(a is null);
assert(dtorCalled);
assert(GC.addrOf(cast(void*) a) == null);

// https://issues.dlang.org/show_bug.cgi?id=22779
A *aptr;
__delete(aptr);

Examples:

配列を削除する

int[] a = [1, 2, 3];
auto b = a;

assert(GC.addrOf(b.ptr) != null);
__delete(b);
assert(b is null);
assert(GC.addrOf(b.ptr) == null);
// しかし、注意が必要だ。aはまだそれを指している
assert(a !is null);
assert(GC.addrOf(a.ptr) == null); // しかし、有効なGCポインタではない

Examples:

構造体の配列を削除する

int dtorCalled;
struct A
{
    int a;
    ~this()
    {
        assert(dtorCalled == a);
        dtorCalled++;
    }
}
auto arr = [A(1), A(2), A(3)];
arr[0].a = 2;
arr[1].a = 1;
arr[2].a = 0;

assert(GC.addrOf(arr.ptr) != null);
__delete(arr);
assert(dtorCalled == 3);
assert(GC.addrOf(arr.ptr) == null);

T* moveToGC(T)(auto ref T value);

値を新しいGC割り当てに移動する。

Parameters:

T value

移動する値。引数がl値であり、デストラクタまたはポストブリットを持つ構造体である。 デストラクタまたはポストブリットを持つ構造体の場合は、.init の値にリセットされる。

Returns:

GCで割り当てられた新しい値へのポインタ。

Examples:

struct S
{
    int x;
    this(this) @disable;
    ~this() @safe pure nothrow @nogc {}
}

S* p;

// r値
p = moveToGC(S(123));
assert(p.x == 123);

// l値
auto lval = S(456);
p = moveToGC(lval);
assert(p.x == 456);
assert(lval.x == 0);