Descompactação de hardware fácil

Os consoles XBOX Series dão suporte à descompactação de hardware para conteúdo compactado com zlib usando o DirectStorage. Aqui é fornecido um substituto direto (drop-in) para a função de software inflate padrão do zlib. Usar este código pode permitir que um desenvolvedor adicione suporte à descompactação acelerada por hardware com o mínimo de alterações em seu código. Ele proporcionará uma melhoria imediata nos tempos de descompactação, além de liberar recursos de CPU que podem ser usados para outros trabalhos. É necessária uma inicialização única para criar os objetos do DirectStorage usados para a descompactação de hardware.

Microsoft::WRL::ComPtr<IDStorageFactoryX> inflateDropInFactory;
Microsoft::WRL::ComPtr<IDStorageQueueX> inflateDropInQueue;
Microsoft::WRL::ComPtr<IDStorageStatusArrayX> inflateDropInStatus;

void CreateDSObjects()
{
    DX::ThrowIfFailed(DStorageGetFactory(__uuidof(IDStorageFactoryX), (void**)(inflateDropInFactory.ReleaseAndGetAddressOf())));
    DSTORAGE_QUEUE_DESC queueDesc = {};
    queueDesc.SourceType = DSTORAGE_REQUEST_SOURCE_MEMORY;
    queueDesc.Priority = DSTORAGE_PRIORITY_REALTIME;
    queueDesc.Capacity = DSTORAGE_MIN_QUEUE_CAPACITY;
    inflateDropInFactory->CreateQueue(&queueDesc, __uuidof(IDStorageQueueX), (void**)(inflateDropInQueue.ReleaseAndGetAddressOf()));
    inflateDropInFactory->CreateStatusArray(1, nullptr, __uuidof(IDStorageStatusArrayX), (void**)(inflateDropInStatus.ReleaseAndGetAddressOf()));
}

A descompactação de hardware tem um custo mínimo de configuração; por isso, pode ser mais rápido usar a descompactação de software para tamanhos de bloco menores. Uma tabela de tempos é fornecida abaixo usando texto ASCII como buffer de origem. Você deve criar perfis para encontrar o melhor tamanho de transição em relação ao seu descompactador de software e ao seu conteúdo. Este código pressupõe que o conteúdo compactado esteja em conformidade com o padrão zlib IETF RFC 1950 com suporte. Confira Otimização de conteúdo compactado usando DirectStorage e XBTC (microsoft.com) para obter mais detalhes.

int inflateDropIn(z_streamp strm, int flush)
{
    bool fallback(false);
    if (strm->avail_out <= strm->total_in)
        fallback = true;
    if (flush != Z_FINISH)
        fallback = true;
    if (strm->avail_out < c_hardwareSizeCrossOverSize)
        fallback = true;
    if (fallback)
        return inflate(strm, flush);

    DSTORAGE_REQUEST request = {};
    request.Options.ZlibDecompress = true;
    request.Options.SourceType = DSTORAGE_REQUEST_SOURCE_MEMORY;
    request.Source = strm->next_in;
    request.SourceSize = strm->total_in;
    request.Destination = strm->next_out;
    request.DestinationSize = strm->avail_out;
    inflateDropInQueue->EnqueueRequest(&request);
    inflateDropInQueue->EnqueueStatus(inflateDropInStatus.Get(), 0);
    inflateDropInQueue->Submit();
    while (!inflateDropInStatus->IsComplete(0))
    {
        _mm_pause();
    }
    return Z_STREAM_END;
}

Esta tabela fornece uma medição dos tempos do descompactador de software zlib padrão em comparação com o descompactador de hardware em um XBOX Series X|S operando a 3,8 GHz, usando texto ASCII como buffer de origem. Diferentes taxas de compactação criarão diferentes pontos de transição quanto a qual é mais rápido entre software e hardware. Você deve criar perfis para encontrar o melhor tamanho de transição em relação ao seu descompactador de software e ao seu conteúdo. O tamanho do bloco está em bytes e os tempos estão em microssegundos.

Tamanho do bloco	Tempo de CPU	Tempo de hardware
128	2.91	75.39
256	3.67	65.29
512	4.14	65.54
1,024	5.59	66.63
2,048	7.65	66.29
4,096	10.96	83.93
8,192	13.69	69.04
10,240	15.08	67.09
12,288	16.16	67.66
14,336	17.37	70.58
16,384	18.40	72.56
20,480	20.58	70.34
24,576	22.88	71.52
28,672	25.34	71.34
32,768	27.71	73.03
36,864	29.73	72.35
40,960	31.56	77.67
45,056	34.34	73.22
65,536	46.76	76.69
131,072	83.96	89.13
262,144	158.32	111.58
524,288	308.01	177.95

Porting

Build Paths