API Performance Hint

Lançamento:

Android 12 (nível 31 da API): API Performance Hint

Android 13 (nível 33 da API): Gerenciador de dicas de desempenho na API NDK

(Prévia) Android 15 (DP1): reportActualWorkDuration()

Com as dicas de desempenho da CPU, um jogo pode influenciar o desempenho dinâmico da CPU e comportamento adequado para atender melhor às necessidades dele. Na maioria dos dispositivos, o Android se ajusta dinamicamente a velocidade do clock e o tipo de núcleo da CPU para uma carga de trabalho com base nas demandas anteriores. Se uma carga de trabalho usar mais recursos da CPU, a velocidade do clock é aumentada e a a carga de trabalho é movida para um núcleo maior. Se a carga de trabalho usar menos recursos, o Android vai diminuir a alocação deles. Com o ADPF, o aplicativo ou jogo podem enviar um indicador adicional sobre seu desempenho e prazos. Isso ajuda o sistema a aumentar de forma mais agressiva (melhorando o desempenho) e reduzir o aos relógios rapidamente quando a carga de trabalho é concluída, economizando energia.

Velocidade do relógio

Quando os dispositivos Android ajustam dinamicamente a velocidade do clock da CPU, a frequência pode mudar o desempenho do seu código. Design de código que aborda o relógio dinâmico é importante para maximizar o desempenho, mantendo um ambiente térmico seguro estado e usando energia de forma eficiente. Não é possível atribuir frequências de CPU diretamente no código do app. Por isso, uma forma comum de execução dos apps tentarem As velocidades do relógio da CPU são executadas em um loop ocupado em uma linha de execução em segundo plano para que a carga de trabalho parece mais exigente. Essa é uma prática não recomendada, pois desperdiça energia e aumenta a carga térmica no dispositivo quando o app não estiver usando o do Google Cloud. A API PerformanceHint da CPU foi projetada para resolver esse problema. De informando ao sistema a duração real e a meta, O Android terá uma visão geral das necessidades de CPU do app e da alocação recursos com eficiência. Isso leva a um desempenho ideal com energia eficiente e nível de consumo.

Tipos de núcleo

Os tipos de núcleo da CPU em que seu jogo é executado são outro fator de performance importante. Os dispositivos Android geralmente mudam o núcleo da CPU atribuído a uma linha de execução de forma dinâmica com base no comportamento recente da carga de trabalho. A atribuição de núcleo da CPU é ainda mais complexa em SoCs com vários tipos de núcleo. Em alguns desses dispositivos, os núcleos maiores só podem ser usados de forma breve, porque atingem rapidamente um estado térmico insustentável.

Seu jogo não deve tentar definir a afinidade de núcleo da CPU pelos seguintes motivos:

• O melhor tipo de núcleo para a carga de trabalho varia de acordo com o modelo do dispositivo.
• A sustentabilidade da execução de núcleos maiores varia de acordo com o SoC e as diversas soluções térmicas fornecidas por cada modelo de dispositivo.
• O impacto ambiental no estado térmico pode complicar ainda mais a escolha do núcleo. Por exemplo, o clima ou uma capa de smartphone pode mudar o estado térmico de um dispositivo.
• A seleção do núcleo não acomoda novos dispositivos com recursos térmicos e de performance extras. Como resultado, os dispositivos geralmente ignoram a afinidade entre o processador e um jogo.

Exemplo de comportamento padrão do programador do Linux

A API PerformanceHint abstrai mais do que as latências do DVFS

• Se as tarefas precisarem ser executadas em uma CPU específica, a API PerformanceHint sabe como tomar essa decisão em seu nome.
• Portanto, não é necessário usar a afinidade.
• Os dispositivos vêm com várias topologias. Características de potência e térmica são muito variados para serem expostos a um desenvolvedor de aplicativos.
• Você não pode fazer nenhuma suposição sobre o sistema subjacente em que está sendo executado.

Solução

O ADPF oferece o PerformanceHintManager. para que os jogos possam enviar dicas de desempenho ao Android sobre a velocidade do clock da CPU e tipo de núcleo. Então, o SO pode decidir a melhor forma de usar as dicas com base no SoC e na solução térmica do dispositivo. Se o app usa essa API com o monitoramento de estado térmico, ele pode fornecer dicas mais fundamentadas para o SO, em vez de usar loops ocupados e outras técnicas de programação que podem causar limitações.

Veja como um jogo usa as dicas de performance:

1. Crie sessões de dicas para linhas de execução principais que se comportam de forma semelhante. Por exemplo:
   • A linha de execução de renderização e as dependências dela recebem uma sessão
     1. No Cocos, as linhas de execução do mecanismo principal e de renderização recebem um sessão
     2. No Unity, integre o plug-in Adaptive Performance Android Provider.
     3. No Unreal, integre o plug-in Unreal Adaptive Performance e use Opções de escalonabilidade para atender a vários níveis de qualidade
   • As linhas de execução de E/S recebem outra sessão
   • As linhas de execução de áudio recebem uma terceira sessão
2. O jogo precisa fazer isso pelo menos 2ms ou, de preferência, mais de 4ms antes de uma sessão exigir mais recursos do sistema.
3. Estima a duração necessária para cada sessão de dica. A duração típica é equivalente a um intervalo de frames, mas o app pode usar uma intervalo mais curto se a carga de trabalho não variar significativamente entre os frames.

Veja como colocar a teoria em prática:

Inicializar PerformanceHintManager e createHintSession

Fazer o gerenciador usar o serviço do sistema e criar uma sessão de dicas para a linha de execução ou um grupo de conversas na mesma carga de trabalho.

int32_t tids[1];
tids[0] = gettid();
int64_t target_fps_nanos = getFpsNanos();
APerformanceHintManager* hint_manager = APerformanceHint_getManager();
APerformanceHintSession* hint_session =
  APerformanceHint_createSession(hint_manager, tids, 1, target_fps_nanos);

int[] tids = {
  android.os.Process.myTid()
};
long targetFpsNanos = getFpsNanos();
PerformanceHintManager performanceHintManager =
  (PerformanceHintManager) this.getSystemService(Context.PERFORMANCE_HINT_SERVICE);
PerformanceHintManager.Session hintSession =
  performanceHintManager.createHintSession(tids, targetFpsNanos);

Definir linhas de execução, se necessário

Lançamento:

Android 11 (nível 34 da API)

Usar o setThreads uma função de PerformanceHintManager.Session quando há outras linhas de execução que precisam ser adicionados mais tarde. Por exemplo, se você criar uma linha de execução de física mais tarde e precisar adicioná-lo à sessão, use esta API setThreads.

auto tids = thread_ids.data();
std::size_t size = thread_ids_.size();
APerformanceHint_setThreads(hint_session, tids, size);

int[] tids = new int[3];

// add all your thread IDs. Remember to use android.os.Process.myTid() as that
// is the linux native thread-id.
// Thread.currentThread().getId() will not work because it is jvm's thread-id.
hintSession.setThreads(tids);

Se você estiver segmentando níveis de API mais baixos, precisará destruir a sessão e recriar uma nova sessão sempre que precisar alterar os IDs de linhas de execução.

Informar a duração real do trabalho

Monitore a duração real necessária para concluir o trabalho em nanossegundos e informe ao sistema após a conclusão do trabalho em cada ciclo. Por exemplo, se para as linhas de execução de renderização, chame-a em todos os frames.

Para ter um tempo real confiável, use:

clock_gettime(CLOCK_MONOTONIC, &clock); // if you prefer "C" way from <time.h>
// or
std::chrono::high_resolution_clock::now(); // if you prefer "C++" way from <chrono>

System.nanoTime();

Exemplo:

// All timings should be from `std::chrono::steady_clock` or `clock_gettime(CLOCK_MONOTONIC, ...)`
auto start_time = std::chrono::high_resolution_clock::now();

// do work

auto end_time = std::chrono::high_resolution_clock::now();
auto duration = std::chrono::duration_cast<std::chrono::nanoseconds>(end_time - start_time).count();
int64_t actual_duration = static_cast<int64_t>(duration);

APerformanceHint_reportActualWorkDuration(hint_session, actual_duration);

long startTime = System.nanoTime();

// do work

long endTime = System.nanoTime();
long duration = endTime - startTime;

hintSession.reportActualWorkDuration(duration);

Atualize a duração desejada do trabalho quando necessário

Sempre que a duração desejada mudar, por exemplo, se o jogador escolher QPS diferentes, chame o método updateTargetWorkDuration para informar ao sistema para que o SO possa ajustar os recursos de acordo para o novo destino. Você não precisa chamá-la em todos os frames, chamá-lo quando a duração desejada mudar.

APerformanceHint_updateTargetWorkDuration(hint_session, target_duration);

hintSession.updateTargetWorkDuration(targetDuration);