Compartilhar via

Heaps compartilhados

  • Artigo

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

Visão geral do compartilhamento

Os heaps compartilhados permitem duas coisas: compartilhar dados em um heap em um ou mais processos e impedir uma opção 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 marshaling de CPU dos dados.

Os heaps e os recursos confirmados podem ser compartilhados. O compartilhamento de um recurso confirmado realmente compartilha o heap implícito junto com a descrição do recurso confirmado, de modo que uma descrição de recurso compatível possa ser mapeada para o heap 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.

Compartilhando 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 à 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 adiados em algumas GPUs, portanto, não é o comportamento padrão para recursos colocados e confirmados. A renderização adiada é prejudicada em algumas arquiteturas de GPU porque os 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 de aproveitar layouts de textura não determinísticos para dar suporte a padrões de swizzle padronizados e layouts padronizados com eficiência para renderização adiada.

Os heaps compartilhados também vêm com outros custos secundários:

  • 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 é zero 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 heaps compartilhados.

Compartilhando heaps entre adaptadores

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 marshaling dos dados entre eles. Embora as funcionalidades variadas do adaptador determinem como os adaptadores eficientes podem passar dados entre eles, apenas habilitar cópias de GPU aumenta a largura de banda efetiva obtida. Alguns layouts de textura são permitidos em heaps de adaptador cruzado para dar suporte a um intercâmbio de dados de textura, mesmo que esses layouts de textura não sejam suportados de outra forma. Determinadas restrições podem se aplicar a essas texturas, como dar suporte apenas à cópia.

O compartilhamento entre adaptadores funciona com heaps criados chamando ID3D12Device::CreateHeap. Em seguida, seu aplicativo pode criar recursos por meio de CreatePlacedResource. Ele também é permitido por recursos/heaps criados por CreateCommittedResource , mas apenas para recursos de D3D12_RESOURCE_DIMENSION_TEXTURE2D principais linhas (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 e a coerência adequadas entre os dois adaptadores. Seu aplicativo deve usar cercas entre adaptadores para coordenar o agendamento de listas de comandos enviadas a vários adaptadores. Não há mecanismo para compartilhar recursos de adaptador cruzado entre versões da API D3D. Os recursos compartilhados entre adaptadores só têm suporte na memória do sistema. Há suporte para heaps/recursos compartilhados entre adaptadores em heaps D3D12_HEAP_TYPE_DEFAULT e heaps de 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 de GPU para heaps compartilhados entre adaptadores 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 heaps de adaptador cruzado apenas aos cenários que exigem a funcionalidade que eles fornecem. Os heaps de adaptadores cruzados estão localizados em D3D12_MEMORY_POOL_L0, o que nem sempre é o que GetCustomHeapProperties sugere. Esse pool de memória não é eficiente para arquiteturas discretas/de adaptador 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.
  • Os D3D12_HEAP_TYPE_DEFAULT devem ser definidos ou D3D12_HEAP_TYPE_CUSTOM com D3D12_MEMORY_POOL_L0 e D3D12_CPU_PAGE_PROPERTY_NOT_AVAILABLE devem ser definidos.
  • Somente recursos com D3D12_RESOURCE_FLAG_ALLOW_CROSS_ADAPTER podem ser colocados em heaps de adaptadores cruzados.
  • 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 como usar vários adaptadores, consulte a seção Sistemas de vários adaptadores .