Vazba v DirectML

In DirectML, vazba se týká připojení prostředků k pipeline, které GPU používala během inicializace a provádění operátorů strojového učení. Tyto prostředky můžou být vstupní a výstupní tensory, například všechny dočasné nebo trvalé prostředky, které operátor potřebuje.

Toto téma se zabývá koncepčními a procedurálními podrobnostmi vazby. Doporučujeme také plně přečíst dokumentaci k rozhraním API, která voláte, včetně parametrů a poznámek.

Důležité nápady o vazbě

Následující seznam kroků obsahuje základní popis úloh souvisejících s vazbami. Tyto kroky je potřeba provést při každém spuštění dispatchable—to může být buď inicializátor operátoru nebo kompilovaný operátor. Tyto kroky představují důležité myšlenky, struktury a metody, které jsou součástí vazby DirectML.

Další části v tomto tématu podrobněji popisují tyto úlohy vazby s ilustrativními fragmenty kódu převzatými z minimálního příkladu kódu aplikace DirectML .

Volání IDMLDispatchable::GetBindingProperties na zpracovatelném objektu k určení počtu popisovačů, které potřebuje, a také jeho potřeb dočasných/trvalých prostředků.
Vytvořte dostatečně velkou haldu deskriptorů Direct3D 12 pro popisovače a připojte ji k potrubí.
Volání IDMLDevice::CreateBindingTable pro vytvoření tabulky vazeb DirectML, která představuje prostředky vázané na datový proud. Pomocí struktury DML_BINDING_TABLE_DESC popište tabulku vazeb, včetně podmnožiny popisovačů, na které odkazuje v haldě popisovače.
Vytvořte dočasné nebo trvalé prostředky jako bufferové prostředky Direct3D 12, popište je pomocí struktur DML_BUFFER_BINDING a DML_BINDING_DESC a přidejte je do tabulky vazeb.
Pokud je dispečovatelným operátorem kompilovaný operátor, vytvořte vyrovnávací paměť prvků tensoru jako prostředek vyrovnávací paměti Direct3D 12. Vyplňte/nahrajte to, popište to strukturami DML_BUFFER_BINDING a DML_BINDING_DESC a přidejte to do tabulky vazeb.
Tabulku vazeb předejte jako parametr při volání IDMLCommandRecorder::RecordDispatch.

Načtení vlastností vazby dispečerovatelného

Struktura DML_BINDING_PROPERTIES popisuje potřeby vazby dispečovatelného operátoru (inicializátor operátoru nebo kompilovaný operátor). Tyto vlastnosti související s vazbou zahrnují počet popisovačů, které byste měli svázat s dispečovatelným objektem, a také velikost v bajtech jakéhokoli dočasného a/nebo trvalého prostředku, který potřebuje.

Poznámka:

I pro více operátorů stejného typu nevytvádejte předpoklady o tom, že mají stejné požadavky na vazby. Zadejte dotaz na vlastnosti vazby pro každý inicializátor a operátor, který vytvoříte.

Zavolejte IDMLDispatchable::GetBindingProperties pro načtení DML_BINDING_PROPERTIES.

winrt::com_ptr<::IDMLCompiledOperator> dmlCompiledOperator;
// Code to create and compile a DirectML operator goes here.

DML_BINDING_PROPERTIES executeDmlBindingProperties{
    dmlCompiledOperator->GetBindingProperties()
};

winrt::com_ptr<::IDMLOperatorInitializer> dmlOperatorInitializer;
// Code to create a DirectML operator initializer goes here.

DML_BINDING_PROPERTIES initializeDmlBindingProperties{
    dmlOperatorInitializer->GetBindingProperties()
};

UINT descriptorCount = ...

Hodnota descriptorCount , kterou zde načtete, určuje (minimální) velikost haldy deskriptoru a tabulky vazeb, kterou vytvoříte v následujících dvou krocích.

DML_BINDING_PROPERTIES obsahuje také TemporaryResourceSize člena, což je minimální velikost v bajtech dočasného prostředku, který musí být vázán na tabulku vazeb pro tento dispečovatelný objekt. Hodnota nuly znamená, že dočasný prostředek není povinný.

PersistentResourceSize A člen, což je minimální velikost v bajtech trvalého prostředku, který musí být vázán na tabulku vazeb pro tento dispečovatelný objekt. Hodnota nuly znamená, že trvalý prostředek není povinný. Pokud je potřeba, při inicializaci zkompilovaného operátoru (kde je vázán jako výstup inicializátoru operátoru) i během jeho provádění musí být poskytnut přetrvávající prostředek. O tom se dozvíte později v tomto tématu. Pouze kompilované operátory mají trvalé prostředky – inicializátory operátorů vždy vrátí hodnotu 0 pro tohoto člena.

Pokud voláte IDMLDispatchable::GetBindingProperties u inicializátoru operátoru před i po volání IDMLOperatorInitializer::Reset, pak se nesmí předpokládat, že dvě sady načtených vlastností vazby budou stejné.

Popis, vytvoření a svázání haldy popisovače

Pokud jde o popisovače, vaše odpovědnost začíná a končí samotnou haldou deskriptoru. DirectML se postará o vytváření a správu popisovačů uvnitř haldy, kterou zadáte.

Proto použijte strukturu D3D12_DESCRIPTOR_HEAP_DESC k popisu haldy dostatečně velké pro počet popisovačů, které jsou potřebné k provedení úkolů. Pak ho vytvořte pomocí ID3D12Device::CreateDescriptorHeap. A nakonec zavolejte ID3D12GraphicsCommandList::SetDescriptorHeaps pro navázání vaší haldy popisovače na pipelinu.

winrt::com_ptr<::ID3D12DescriptorHeap> d3D12DescriptorHeap;

D3D12_DESCRIPTOR_HEAP_DESC descriptorHeapDescription{};
descriptorHeapDescription.Type = D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV;
descriptorHeapDescription.NumDescriptors = descriptorCount;
descriptorHeapDescription.Flags = D3D12_DESCRIPTOR_HEAP_FLAG_SHADER_VISIBLE;

winrt::check_hresult(
    d3D12Device->CreateDescriptorHeap(
        &descriptorHeapDescription,
        _uuidof(d3D12DescriptorHeap),
        d3D12DescriptorHeap.put_void()
    )
);

std::array<ID3D12DescriptorHeap*, 1> d3D12DescriptorHeaps{ d3D12DescriptorHeap.get() };
d3D12GraphicsCommandList->SetDescriptorHeaps(
    static_cast<UINT>(d3D12DescriptorHeaps.size()),
    d3D12DescriptorHeaps.data()
);

Popis a vytvoření tabulky vazeb

Tabulka vazeb DirectML představuje prostředky, které navážete na pipeline pro použití dispatchable. Tyto prostředky mohou být vstupními a výstupními tensory (nebo jinými parametry) pro operátor, nebo mohou být různé trvalé a dočasné zdroje, se kterými pracuje zpracování.

Pomocí struktury DML_BINDING_TABLE_DESC popíšete tabulku vazeb, včetně dispečovatelné tabulky, pro kterou bude tabulka vazeb představovat vazby, a rozsah popisovačů (z haldy popisovače, kterou jste právě vytvořili), na kterou má tabulka vazby odkazovat (a na které může DirectML zapisovat popisovače). Hodnota descriptorCount (jedna z vlastností vazby, kterou jsme načetli v prvním kroku) nám říká, jaká je minimální velikost v popisovačích tabulky vazeb vyžadované pro dispečovatelný objekt. Tuto hodnotu zde použijeme k označení maximálního počtu popisovačů, které má DirectML povoleno zapisovat do haldy od začátku zadaných popisovačů procesoru i GPU.

Potom zavolejte IDMLDevice::CreateBindingTable a vytvořte tabulku vazeb DirectML. V pozdějších krocích po vytvoření dalších prostředků pro odeslání přidáme tyto prostředky do tabulky vazeb.

Místo předání DML_BINDING_TABLE_DESC tomuto volání můžete předat nullptr, což označuje prázdnou vazbu tabulku.

DML_BINDING_TABLE_DESC dmlBindingTableDesc{};
dmlBindingTableDesc.Dispatchable = dmlOperatorInitializer.get();
dmlBindingTableDesc.CPUDescriptorHandle = d3D12DescriptorHeap->GetCPUDescriptorHandleForHeapStart();
dmlBindingTableDesc.GPUDescriptorHandle = d3D12DescriptorHeap->GetGPUDescriptorHandleForHeapStart();
dmlBindingTableDesc.SizeInDescriptors = descriptorCount;

winrt::com_ptr<::IDMLBindingTable> dmlBindingTable;
winrt::check_hresult(
    dmlDevice->CreateBindingTable(
        &dmlBindingTableDesc,
        __uuidof(dmlBindingTable),
        dmlBindingTable.put_void()
    )
);

Pořadí, ve kterém DirectML zapisuje popisovače do haldy, není specifikováno, takže aplikace musí dbát na to, aby nepřepsala popisovače zabalené vazební tabulkou. Zadané popisovače CPU a GPU mohou pocházet z různých hald. Je však zodpovědností vaší aplikace zajistit, aby celá oblast popisovače odkazovaná popisovačem CPU byla zkopírována do oblasti, na kterou odkazuje popisovač GPU, před spuštěním aplikace pomocí této tabulky vazeb. Halda popisovače, ze které jsou popisovače dodány, musí mít typ D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV. Navíc, halda, na kterou GPUDescriptorHandle odkazuje, musí být haldou deskriptorů viditelnou pro stínovač.

Tabulku vazeb můžete resetovat tak, aby se odebraly všechny prostředky, které jste do ní přidali, a zároveň změnit libovolnou vlastnost, kterou jste nastavili na počátečním DML_BINDING_TABLE_DESC (aby se zabalila nová oblast popisovačů, nebo aby se znovu používala pro jinou dispečovatelnou). Stačí provést změny struktury popisu a volat IDMLBindingTable::Reset.

dmlBindingTableDesc.Dispatchable = pIDMLCompiledOperator.get();

winrt::check_hresult(
    pIDMLBindingTable->Reset(
        &dmlBindingTableDesc
    )
);

Popis a vytvoření vazby všech dočasných/trvalých prostředků

Struktura DML_BINDING_PROPERTIES, kterou jsme vyplnili při získání vlastností vazby našeho dispečovatelného objektu, obsahuje velikost v bajtech všech dočasných a/nebo trvalých prostředků, které dispečovatelný objekt potřebuje. Pokud některé z těchto velikostí není nula, vytvořte prostředek vyrovnávací paměti Direct3D 12 a přidejte ho do tabulky vazeb.

V následujícím příkladu kódu vytvoříme dočasný prostředek o velikosti temporaryResourceSize bajtů pro dispečovatelný objekt. Popisujeme, jak chceme prostředek svázat, a pak přidáme danou vazbu do tabulky vazeb.

Vzhledem k tomu, že vážeme jeden prostředek vyrovnávací paměti, popisujeme vazbu s DML_BUFFER_BINDING strukturou. V této struktuře určíme prostředek vyrovnávací paměti Direct3D 12 (prostředek musí mít dimenzi D3D12_RESOURCE_DIMENSION_BUFFER), stejně jako posun a velikost do vyrovnávací paměti. Je také možné popsat vazbu pro pole vyrovnávacích pamětí (nikoli pro jednu vyrovnávací paměť) a DML_BUFFER_ARRAY_BINDING struktura existuje pro tento účel.

K abstrahování rozlišování mezi vazbou vyrovnávací paměti a vazbou pole vyrovnávací paměti používáme strukturu DML_BINDING_DESC . Člena Type můžete nastavit na DML_BINDING_TYPE_BUFFER nebo DML_BINDING_TYPE_BUFFER_ARRAY. Pak můžete nastavit Desc člena tak, aby odkazoval buď na DML_BUFFER_BINDING, nebo na DML_BUFFER_ARRAY_BINDING v závislosti na Type.

Pracujeme s dočasným prostředkem v tomto příkladu, takže ho přidáme do tabulky vazeb s voláním IDMLBindingTable::BindTemporaryResource.

D3D12_HEAP_PROPERTIES defaultHeapProperties{ CD3DX12_HEAP_PROPERTIES(D3D12_HEAP_TYPE_DEFAULT) };
winrt::com_ptr<::ID3D12Resource> temporaryBuffer;

D3D12_RESOURCE_DESC temporaryBufferDesc{ CD3DX12_RESOURCE_DESC::Buffer(temporaryResourceSize) };
winrt::check_hresult(
    d3D12Device->CreateCommittedResource(
        &defaultHeapProperties,
        D3D12_HEAP_FLAG_NONE,
        &temporaryBufferDesc,
        D3D12_RESOURCE_STATE_COMMON,
        nullptr,
        __uuidof(temporaryBuffer),
        temporaryBuffer.put_void()
    )
);

DML_BUFFER_BINDING bufferBinding{ temporaryBuffer.get(), 0, temporaryResourceSize };
DML_BINDING_DESC bindingDesc{ DML_BINDING_TYPE_BUFFER, &bufferBinding };
dmlBindingTable->BindTemporaryResource(&bindingDesc);

Dočasný prostředek (pokud je potřeba) je pomocné paměti, která se používá interně během provádění operátoru, takže se nemusíte zabývat jeho obsahem. Ani nemusíte ho držet po dokončení volání IDMLCommandRecorder::RecordDispatch na GPU. To znamená, že vaše aplikace může uvolnit nebo přepsat dočasný prostředek mezi jednotlivými voláními zkompilovaného operátoru. Zadaný rozsah vyrovnávací paměti, který má být vázán, protože dočasný prostředek musí mít počáteční posun zarovnaný na DML_TEMPORARY_BUFFER_ALIGNMENT. Typ haldy podkladové vyrovnávací paměti musí být D3D12_HEAP_TYPE_DEFAULT.

Pokud dispečovatelný prostředek uvádí nenulovou velikost svého persistentního prostředku, pak je postup trochu odlišný. Vytvořte vyrovnávací paměť a popište vazbu podle stejného vzoru, jak je uvedeno výše. Ale přidejte ji do tabulky vazeb inicializátoru operátoru pomocí volání IDMLBindingTable::BindOutputs, protože úloha inicializace trvalého prostředku spadá na inicializátor operátoru. Pak ji přidejte do tabulky vazeb kompilovaného operátora s voláním IDMLBindingTable::BindPersistentResource. Pokud chcete zobrazit tento pracovní postup v akci, podívejte se na minimální příklad kódu aplikace DirectML . Obsah a životnost trvalého prostředku musí být zachovány, dokud existuje kompilovaný operátor. To znamená, že pokud operátor vyžaduje trvalý prostředek, aplikace ho musí poskytnout během inicializace a následně také při všech budoucích spuštěních operátoru, aniž by se změnil jeho obsah. Trvalý prostředek obvykle directML používá k ukládání vyhledávacích tabulek nebo jiných dlouhotrvajících dat vypočítaných během inicializace operátoru a opětovného použití při budoucích spuštěních tohoto operátoru. Zadaný rozsah vyrovnávací paměti, který má být vázán jako trvalá vyrovnávací paměť, musí mít počáteční posun zarovnaný na DML_PERSISTENT_BUFFER_ALIGNMENT. Typ haldy podkladové vyrovnávací paměti musí být D3D12_HEAP_TYPE_DEFAULT.

Popis a vytvoření vazby libovolných tenzorů

Pokud pracujete s kompilovaným operátorem (ne s inicializátorem operátoru), musíte svázat vstupní a výstupní prostředky (pro tensory a další parametry) s tabulkou vazeb operátoru. Počet vazeb musí přesně odpovídat počtu vstupů operátoru, včetně volitelných tenzorů. Konkrétní vstupní a výstupní tensory a další parametry, které operátor vezme, jsou zdokumentované v tématu tohoto operátoru (například DML_ELEMENT_WISE_IDENTITY_OPERATOR_DESC).

Tensorový prostředek je vyrovnávací paměť, která obsahuje hodnoty jednotlivých prvků tenzoru. Pomocí běžných technik Direct3D 12 (nahrání prostředků a čtení dat zpět pomocí vyrovnávací paměti) nahráváte a čtete zpět vyrovnávací paměť z/do GPU. Podívejte se na minimální příklad kódu aplikace DirectML a prohlédněte si tyto techniky v akci.

Nakonec popište vstupní a výstupní vazby prostředků pomocí DML_BUFFER_BINDING a DML_BINDING_DESC struktur a pak je přidejte do zkompilované tabulky vazeb operátora s voláními IDMLBindingTable::BindInputs a IDMLBindingTable::BindOutputs. Při volání IDMLBindingTable::Bind* Metoda DirectML zapíše jeden nebo více popisovačů do rozsahu popisovačů procesoru.

DML_BUFFER_BINDING inputBufferBinding{ inputBuffer.get(), 0, tensorBufferSize };
DML_BINDING_DESC inputBindingDesc{ DML_BINDING_TYPE_BUFFER, &inputBufferBinding };
dmlBindingTable->BindInputs(1, &inputBindingDesc);

DML_BUFFER_BINDING outputBufferBinding{ outputBuffer.get(), 0, tensorBufferSize };
DML_BINDING_DESC outputBindingDesc{ DML_BINDING_TYPE_BUFFER, &outputBufferBinding };
dmlBindingTable->BindOutputs(1, &outputBindingDesc);

Jedním z kroků při vytváření operátoru DirectML (viz IDMLDevice::CreateOperator) je deklarovat jednu nebo více DML_BUFFER_TENSOR_DESC struktur, které popisují vyrovnávací paměti dat tensoru, které operátor přebírá a vrací. Kromě typu a velikosti vyrovnávací paměti tensoru můžete volitelně zadat příznak DML_TENSOR_FLAG_OWNED_BY_DML.

DML_TENSOR_FLAG_OWNED_BY_DML označuje, že data tensoru by měla vlastnit a spravovat DirectML. DirectML vytvoří kopii dat tensoru během inicializace operátoru a uloží je do trvalého prostředku. DirectML tak umožňuje provádět přeformátování dat tensoru do jiných, efektivnějších formulářů. Nastavení tohoto příznaku může zvýšit výkon, ale obvykle je užitečné pouze pro tensory, jejichž data se v průběhu životnosti operátoru nemění (například váhové tensory). Příznak lze použít pouze u vstupních tenzorů. Pokud je příznak nastaven na konkrétní popis tensoru, musí být odpovídající tensor vázán na tabulku vazby během inicializace operátoru, a ne během provádění (což bude mít za následek chybu). To je opak výchozího chování (chování bez příznaku DML_TENSOR_FLAG_OWNED_BY_DML), kde se očekává, že tensor bude vázán během provádění, a ne během inicializace. Všechny prostředky vázané na DirectML musí být prostředky haldy typu DEFAULT nebo CUSTOM.

Další informace najdete v tématu IDMLBindingTable::BindInputs a IDMLBindingTable::BindOutputs.

Provést dispečovatelný proces

Tabulku vazeb předejte jako parametr při volání IDMLCommandRecorder::RecordDispatch.

Při použití tabulky vazeb během volání IDMLCommandRecorder::RecordDispatch DirectML připojí odpovídající deskriptory GPU k potrubí. Popisovače procesoru a GPU se nevyžadují, aby odkazovaly na stejné položky v haldě deskriptoru, ale je zodpovědností vaší aplikace zajistit, aby se celý rozsah popisovače, na který odkazuje popisovač procesoru, zkopíroval do rozsahu, na který odkazuje popisovač GPU před spuštěním pomocí této tabulky vazeb.

winrt::com_ptr<::ID3D12GraphicsCommandList> d3D12GraphicsCommandList;
// Code to create a Direct3D 12 command list goes here.

winrt::com_ptr<::IDMLCommandRecorder> dmlCommandRecorder;
// Code to create a DirectML command recorder goes here.

dmlCommandRecorder->RecordDispatch(
    d3D12GraphicsCommandList.get(),
    dmlOperatorInitializer.get(),
    dmlBindingTable.get()
);

Nakonec zavřete seznam příkazů Direct3D 12 a odešlete ho ke spuštění stejně jako jakýkoli jiný seznam příkazů.

Před spuštěním recordDispatch na GPU je nutné převést všechny vázané prostředky do D3D12_RESOURCE_STATE_UNORDERED_ACCESS stavu nebo do stavu implicitně propagačního na D3D12_RESOURCE_STATE_UNORDERED_ACCESS, například D3D12_RESOURCE_STATE_COMMON. Po dokončení tohoto volání zůstanou prostředky ve stavu D3D12_RESOURCE_STATE_UNORDERED_ACCESS . Jedinou výjimkou je pro nahrávání hald, které jsou navázány při provádění inicializátoru operátoru, a dokud je jeden nebo více tensorů označen příznakem DML_TENSOR_FLAG_OWNED_BY_DML. V takovém případě musí být všechny haldy nahrávání vázané na vstup ve stavu D3D12_RESOURCE_STATE_GENERIC_READ a zůstanou v tomto stavu, jak to vyžaduje všechny haldy nahrávání. Pokud DML_EXECUTION_FLAG_DESCRIPTORS_VOLATILE nebyl při kompilaci operátoru nastaven, musí být všechny vazby nastaveny na tabulku vazeb před zavoláním RecordDispatch , jinak chování není definováno. Pokud operátor podporuje pozdní vazbu, může být vazba prostředků odložena, dokud není seznam příkazů Direct3D 12 odeslán do fronty příkazů ke spuštění.

RecordDispatch funguje logicky jako volání ID3D12GraphicsCommandList::Dispatch. V takovém případě jsou bariéry pro neuspořádané zobrazení přístupu (UAV) nezbytné ke zajištění správného pořadí, pokud mezi operacemi existují datové závislosti. Tato metoda nevkládává bariéry UAV do vstupních ani výstupních prostředků. Vaše aplikace musí zajistit, aby na všech vstupech byly prováděny správné bariéry UAV, pokud jejich obsah závisí na nadřazeném dispečinku, a na všech výstupech, pokud existují podřízené dispečinky, které závisí na těchto výstupech.

Životnost a synchronizace deskriptorů a tabulky vazeb

Dobrým mentálním modelem vazby v DirectML je, že na pozadí samotná tabulka vazeb DirectML vytváří a spravuje neuspořádané popisovače zobrazení přístupu (UAV) uvnitř haldy popisovače, kterou zadáte. Všechna obvyklá pravidla Direct3D 12 se tedy vztahují na synchronizaci přístupu k této haldě a k popisovačům. Za správnou synchronizaci mezi procesorem a GPU, která používá tabulku vazeb, zodpovídá vaše aplikace.

Tabulka vazeb nemůže přepsat popisovač, zatímco se popisovač používá (například v předchozím snímku). Pokud tedy chcete znovu použít již vázanou haldu popisovače (například opětovným voláním Bind* na tabulce vazby, která na ni ukazuje, nebo manuálním přepsáním haldy popisovače), měli byste počkat, až úloha, která haldu popisovače aktuálně používá, dokončí své provádění na GPU. Tabulka vazeb neudržuje silný odkaz na haldu deskriptoru, do které se zapisuje, proto nesmíte uvolnit pomocnou haldu deskriptorů viditelnou shaderem, dokud nebude všechna práce využívající tuto tabulku vazeb zcela dokončena na GPU.

Na druhou stranu zatímco tabulka vazeb určuje a spravuje haldu deskriptoru, tabulka sama neobsahuje žádnou z této paměti. Proto můžete kdykoli uvolnit nebo resetovat vazbu tabulky po zavolání IDMLCommandRecorder::RecordDispatch s ní (nemusíte čekat na dokončení volání na GPU, pokud základní popisovače zůstanou platné).

Tabulka vazeb neuchovává silné odkazy na žádné prostředky vázané pomocí této vazby – vaše aplikace musí zajistit, aby se prostředky neodstranily, i když je gpu stále používá. Také tabulka vazeb není bezpečná pro vlákno – aplikace nesmí volat metody v tabulce vazeb současně z různých vláken bez synchronizace.

Pamatujte, že v každém případě je restrukturace vazeb nutná pouze tehdy, když změníte, které zdroje jsou vázány. Pokud nepotřebujete měnit vázané prostředky, můžete vytvořit vazbu jednou při spuštění a předat stejnou tabulku vazeb pokaždé, když voláte RecordDispatch.

Pro prokládání úloh strojového učení a vykreslování je třeba zajistit, aby tabulky vazeb jednotlivých snímků ukazovaly na rozsahy haldy deskriptoru, které se na GPU ještě nepoužívají.

Volitelně můžete zadat pozdní vazby operátoru.

Pokud pracujete s kompilovaným operátorem (ne s inicializátorem operátoru), máte možnost zadat pro operátor pozdní vazbu. Bez pozdní vazby musíte před záznamem operátoru do seznamu příkazů nastavit všechny vazby v tabulce vazeb. Při pozdním navázání můžete nastavit (nebo změnit) vazby u operátorů, které jste už nahráli do seznamu příkazů, předtím než je odešlete do fronty příkazů.

Chcete-li specifikovat pozdní vazbu, volejte IDMLDevice::CompileOperator s argumentem flagsDML_EXECUTION_FLAG_DESCRIPTORS_VOLATILE.

Viz také

Windows AI

Váš názor

Byla tato stránka užitečná?

Last updated on 2025-05-03