Vinicius Quinafelex Alves

Prefetching (ou pré-carregamento) é uma técnica que inicia o carregamento de dados antes deles serem necessários, diminuindo o tempo total de execução, mas com o risco de carregar dados desnecessariamente.

Na programação, através do código, o desenvolvedor pode identificar quais dados serão necessários em quais situações, reduzindo ou eliminando o risco de carregamentos desnecessários.

No C#, usar async e tasks permite iniciar o carregamento de dados sem interromper o fluxo do código. Isso ajuda a diluir o tempo que o algoritmo ficará esperando pelo resultado de operações de I/O, pois ele estará trabalhando em outros comandos enquanto espera o resultado.

Exemplos de pré-carregamento com assincronia abaixo:

Pré-carregando um resultado

Executar um método assíncrono imediatamente inicia a execução do método sem interromper o fluxo de código. Ao guardar referência à task retornada, é possível utilizar await para aguardar o carregamento apenas quando ele será necessário.

public static async Task<string> GetHtmlAsync(string uri)
{
    using (var client = new HttpClient())
        return await client.GetStringAsync(uri);
}

// Start prefetching
var taskHtml = GetHtmlAsync("https://domain.com");
CodeWithoutHtml();

// Await and consume the result
var html = await taskHtml
CodeWithHtml(html);

Executando múltiplos pré-carregamentos

Invocar métodos assíncronos sem await em sequência é o suficiente para buscar os dados múltiplos dados em paralelo, sem gerar interrupções de código. O fluxo só será interrompido na presença de um await.

// Start pre-fetching
var taskHtml1 = GetHtmlAsync("https://domain1.com");
var taskHtml2 = GetHtmlAsync("https://domain2.com");
var taskHtml3 = GetHtmlAsync("https://domain3.com");

// Await results
var html1 = await taskHtml1;
var html2 = await taskHtml2;
var html3 = await taskHtml3;

Encadeamento de pré-carregamentos

Existem situações em que um método assíncrono precisa de um dado carregado por outro método assíncrono, criando uma corrente de carregamentos.

Tasks podem ser encadeadas usando ContinueWith(), que invocará um método qualquer assim que a task for concluída, e Unwrap(), que expõe a task interna sendo executada no ContinueWith. Considerando que o ContinueWith só é executado depois que a task foi concluída, não há bloqueio de thread quando é chamado diretamente o .Result da task.

// Start pre-fetching
var taskUrl = RetrieveUrlAsync();

var taskStatusCode = taskUrl.ContinueWith(async (task) => 
{
    return await GetStatusCodeAsync(task.Result);
}).Unwrap();

var taskFavicon = taskUrl.ContinueWith(async (task) => 
{
    return await HasFaviconAsync(task.Result);
}).Unwrap();

// Await results
var statusCode = await taskStatusCode;
var hasFavicon = await taskFavicon;

Pré-carregamento com IAsyncEnumerable

Quando utilizar IAsyncEnumerable, também é possível pré-carregar o próximo resultado ao controlar o IEnumerator, como demonstrado pelo extension method abaixo. Os benchmarks foram gerados pelo BenchmarkDotNet.

public static async IAsyncEnumerable<T> WithPrefetch<T>(this IAsyncEnumerable<T> enumerable)
{
    await using(var enumerator = enumerable.GetAsyncEnumerator())
    {
        ValueTask<bool> hasNextTask = enumerator.MoveNextAsync();

        while(await hasNextTask)
        {
            T data = enumerator.Current;
            hasNextTask = enumerator.MoveNextAsync();
            yield return data;
        }
    }
}

// Prefetching 1 item
await foreach(var item in EnumerateAsync().WithPrefetch())
    Process(item);

Há um ganho de performance significante em utilizar pré-carregamento quando o tempo de carregamento e o tempo de processamento são próximos. Pré-carregamento apresenta uma sobrecarga desnecessária para dados que já estão em memória.

Não há benefícios em pré-carregar mais que um item por vez, se for realizar o processamento de um item por vez. Código para pré-carregar mais de um item:

public static IAsyncEnumerable<T> WithPrefetch<T>(this IAsyncEnumerable<T> enumerable, int prefetchDepth)
{
    while(prefetchDepth > 0)
    { 
        enumerable = enumerable.WithPrefetch();
        prefetchDepth--;
    }

    return enumerable;
}

// Prefetching 10 items
await foreach(var item in EnumerateAsync().WithPrefetch(10))
    Process(item);

Benchmarks constatam que pré-carregar múltiplos registros causa um aumento linear de tempo baseado na profundidade de pré-carregamento.

O método utilizado como referência soma 100 números de uma enumeração nos cenários em que ela é carregada de forma síncrona, assíncrona ou assíncrona com pré-carregamento. 1 ms = 1.000.000 ns

Alterações exclusivamente no tempo de processamento ou tempo de carregamento não afeta o tempo geral da execução da função, independente da profundidade de pré-carregamentos.

Aumentar a profundidade de pré-carregamentos não apresenta melhoria na performance mesmo em situações aonde carregamento e processamento favorecem o paralelismo.