Compartilhar via

Heaps compartilhados

  • Artigo

O compartilhamento é útil para arquiteturas de vários processos e vários adaptadores.

Visão geral de compartilhamento

Heaps compartilhados permitem duas coisas: compartilhar dados em um heap entre um ou mais processos e impedir uma escolha não determinística de layout de textura indefinido para recursos colocados dentro do heap. O compartilhamento de heaps entre adaptadores também elimina a necessidade de empacotamento de CPU dos dados.

Tanto os heaps quanto os recursos comprometidos podem ser compartilhados. Compartilhar um recurso comprometido na verdade compartilha o heap implícito junto com a descrição do recurso comprometido, de modo que uma descrição de recurso compatível pode ser mapeada para o heap de outro dispositivo.

Todos os métodos são de thread livre e herdam a semântica D3D11 existente da criação de compartilhamento de identificador NT.

Compartilhamento de heaps entre processos

Os heaps compartilhados são especificados com o membro D3D12_HEAP_FLAG_SHARED da enumeração D3D12_HEAP_FLAGS.

Não há suporte para heaps compartilhados em heaps acessíveis pela CPU: D3D12_HEAP_TYPE_UPLOAD, D3D12_HEAP_TYPE_READBACK e D3D12_HEAP_TYPE_CUSTOM sem D3D12_CPU_PAGE_PROPERTY_NOT_AVAILABLE.

Impedir uma escolha não determinística de layout de textura indefinido pode prejudicar significativamente cenários de renderização adiada em algumas GPUs. Portanto, não é o comportamento padrão para recursos colocados e comprometidos. A renderização adiada é prejudicada em algumas arquiteturas de GPU, pois os layouts de textura determinísticos diminuem a largura de banda de memória efetiva obtida ao renderizar simultaneamente várias texturas de destino de renderização do mesmo formato e tamanho. As arquiteturas de GPU estão deixando de aproveitar layouts de textura não determinísticos para oferecer suporte a padrões swizzle padronizados e layouts padronizados de forma eficiente para renderização adiada.

Os heaps compartilhados também vêm com outros custos menores:

  • Os dados de heap compartilhados não podem ser reciclados com a mesma flexibilidade que heaps em processamento devido a preocupações com divulgação de informações. Portanto, a memória física é zerada com mais frequência.
  • Há uma pequena sobrecarga adicional da CPU e maior uso de memória do sistema durante a criação e destruição de heaps compartilhados.

Compartilhar heaps entre adaptadores

Os heaps compartilhados entre adaptadores são especificados com o membro D3D12_HEAP_FLAG_SHARED_CROSS_ADAPTER da enumeração D3D12_HEAP_FLAGS.

Os heaps compartilhados entre adaptadores permitem que vários adaptadores compartilhem dados sem que a CPU tenha que organizar os dados entre eles. Embora a variação das funcionalidades do adaptador determine a eficiência com que os adaptadores podem transmitir dados entre eles, a simples ativação de cópias da GPU aumenta a largura de banda efetiva alcançada. Alguns layouts de textura são permitidos em heaps de adaptadores cruzados para oferecer suporte a uma troca de dados de textura, mesmo que esses layouts de textura não sejam suportados de outra forma. Certas restrições podem ser aplicadas a essas texturas, como suporte apenas para cópia.

O compartilhamento entre adaptadores funciona com heaps criados chamando ID3D12Device::CreateHeap. Seu aplicativo pode criar recursos por meio de CreatePlacedResource. Também é permitido por recursos/pilhas criados por CreateCommittedResource, mas apenas para recursos D3D12_RESOURCE_DIMENSION_TEXTURE2D de linha principal (consulte D3D12_RESOURCE_DIMENSION). O compartilhamento entre adaptadores não funciona com CreateReservedResource.

Para compartilhamento entre adaptadores, todas as regras usuais de compartilhamento de recursos entre filas ainda se aplicam. Seu aplicativo deve emitir as barreiras apropriadas para garantir a sincronização e a coerência adequadas entre os dois adaptadores. Seu aplicativo deve usar limites entre adaptadores para coordenar o agendamento de listas de comandos enviadas a vários adaptadores. Não há nenhum mecanismo para compartilhar recursos entre adaptadores entre versões da API D3D. Os recursos compartilhados entre adaptadores têm suporte apenas na memória do sistema. Há suporte para heaps/recursos compartilhados entre adaptadores em heaps D3D12_HEAP_TYPE_DEFAULT e heaps D3D12_HEAP_TYPE_CUSTOM (com o pool de memória L0 e as propriedades de página de CPU de combinação de gravação). Os drivers devem garantir que as operações de leitura/gravação de GPU para heaps compartilhados entre adaptadores sejam coerentes com outras GPUs no sistema. Por exemplo, o driver pode precisar excluir os dados do heap de caches de GPU que normalmente não precisam ser liberados quando a CPU não pode acessar diretamente os dados do heap.

Seu aplicativo deve limitar o uso de heaps de adaptador cruzado apenas aos cenários que exigem a funcionalidade que eles fornecem. Os heaps entre adaptadores estão localizados em D3D12_MEMORY_POOL_L0, o que nem sempre é o que sugere GetCustomHeapProperties. Esse pool de memória não é eficiente para arquiteturas de adaptadores discretos/NUMA. E os layouts de textura mais eficientes nem sempre estão disponíveis.

As seguintes limitações também se aplicam:

  • Os sinalizadores de heap relacionados às camadas de heap devem ser D3D12_HEAP_FLAG_ALLOW_ALL_BUFFERS_AND_TEXTURES.
  • D3D12_HEAP_FLAG_SHARED também deve ser definido.
  • É necessário definir D3D12_HEAP_TYPE_DEFAULT ou D3D12_HEAP_TYPE_CUSTOM com D3D12_MEMORY_POOL_L0 e D3D12_CPU_PAGE_PROPERTY_NOT_AVAILABLE.
  • Apenas recursos com D3D12_RESOURCE_FLAG_ALLOW_CROSS_ADAPTER podem ser colocados em heaps entre adaptadores.
  • Uma sessão protegida não pode ser passada para a criação do heap quando D3D12_HEAP_FLAG_SHARED_CROSS_ADAPTER é especificado

Para obter mais informações sobre o uso de vários adaptadores, consulte a seção Sistemas de vários adaptadores.