Partilhar via

Pilhas compartilhadas

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

Visão geral de compartilhamento

Pilhas compartilhadas permitem duas coisas: compartilhar dados em uma pilha em um ou mais processos e impedir uma escolha não determinística de layout de textura indefinido para recursos colocados dentro da pilha. O compartilhamento de pilhas entre adaptadores também elimina a necessidade de empacotamento de dados da CPU.

Tanto as pilhas como os recursos comprometidos podem ser partilhados. O compartilhamento de um recurso comprometido realmente compartilha o heap implícito junto com a descrição do recurso comprometido, de modo que uma descrição de recurso compatível possa ser mapeada para o heap a partir de outro dispositivo.

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

Compartilhamento de pilhas entre processos

Pilhas compartilhadas são especificadas com o membro D3D12_HEAP_FLAG_SHARED do D3D12_HEAP_FLAGS enum.

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 indefinida pode prejudicar significativamente os 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 porque layouts de textura determinística diminuem a largura de banda de memória efetiva obtida ao renderizar simultaneamente para várias texturas de destino de renderização do mesmo formato e tamanho. As arquiteturas de GPU estão evoluindo para longe do aproveitamento de layouts de textura não determinísticos para oferecer suporte a padrões de swizzle padronizados e layouts padronizados de forma eficiente para renderização adiada.

Pilhas compartilhadas vêm com outros custos menores também:

  • Os dados de heap compartilhados não podem ser reciclados de forma tão flexível quanto os heaps em processo devido a preocupações com a divulgação de informações, portanto, a memória física é zerada com mais frequência.
  • Há uma pequena sobrecarga adicional de CPU e aumento do uso de memória do sistema durante a criação e destruição de pilhas compartilhadas.

Compartilhando pilhas entre adaptadores

Pilhas compartilhadas entre adaptadores são especificadas com o membro D3D12_HEAP_FLAG_SHARED_CROSS_ADAPTER do D3D12_HEAP_FLAGS enum.

Pilhas compartilhadas de adaptador cruzado permitem que vários adaptadores compartilhem dados sem que a CPU marshaling os dados entre eles. Embora os diferentes recursos do adaptador determinem o quão eficientes os adaptadores podem passar dados entre eles, apenas habilitar cópias de GPU aumenta a largura de banda efetiva alcançada. Alguns layouts de textura são permitidos em pilhas de adaptador cruzado para suportar um intercâmbio de dados de textura, mesmo que esses layouts de textura não sejam suportados de outra forma. Podem aplicar-se determinadas restrições a essas texturas, tais como apenas a cópia de suporte.

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

Para o 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 adequada e a coerência entre os dois adaptadores. Seu aplicativo deve usar cercas de adaptador cruzado para coordenar o agendamento de listas de comandos enviadas para vários adaptadores. Não há nenhum mecanismo para compartilhar recursos de adaptador cruzado entre versões de API D3D. Os recursos compartilhados entre adaptadores são suportados apenas na memória do sistema. Os heaps/recursos compartilhados entre adaptadores são suportados em heaps de D3D12_HEAP_TYPE_DEFAULT e heaps D3D12_HEAP_TYPE_CUSTOM (com o pool de memória L0 e propriedades de página de CPU de combinação de gravação). Os drivers devem ter certeza de que as operações de leitura/gravação da GPU para heaps compartilhados de adaptador cruzado são coerentes com outras GPUs no sistema. Por exemplo, o driver pode precisar excluir os dados de heap de residir em caches de GPU que normalmente não precisam ser liberados quando a CPU não pode acessar diretamente os dados de heap.

Seu aplicativo deve limitar o uso de pilhas de adaptador cruzado apenas aos cenários que exigem a funcionalidade que eles fornecem. As pilhas de adaptador cruzado estão localizadas em D3D12_MEMORY_POOL_L0, o que nem sempre é o que GetCustomHeapProperties sugere. Esse pool de memória não é eficiente para arquiteturas de adaptador NUMA/discreto. 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 a camadas de heap devem ser D3D12_HEAP_FLAG_ALLOW_ALL_BUFFERS_AND_TEXTURES.
  • D3D12_HEAP_FLAG_SHARED também deve ser definido.
  • Qualquer D3D12_HEAP_TYPE_DEFAULT deve ser definido ou D3D12_HEAP_TYPE_CUSTOM com D3D12_MEMORY_POOL_L0 e D3D12_CPU_PAGE_PROPERTY_NOT_AVAILABLE deve ser definido.
  • Somente recursos com D3D12_RESOURCE_FLAG_ALLOW_CROSS_ADAPTER podem ser colocados em pilhas de adaptador cruzado.
  • Uma sessão protegida não pode ser passada para a criação da pilha quando D3D12_HEAP_FLAG_SHARED_CROSS_ADAPTER é especificado

Para obter mais informações sobre como usar vários adaptadores, consulte a seção sistemas multiadaptadores.

  • Last updated on