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
![Comportamento do programador do Linux](https://developer.android.google.cn/static/games/optimize/adpf/images/adpf_linux_sched_behavior.png?authuser=19&hl=pt-br)
A API PerformanceHint abstrai mais do que as latências do DVFS
![ADPF abstrai mais do que latências de DVFS](https://developer.android.google.cn/static/games/optimize/adpf/images/adpf_dvfs_latency.png?authuser=19&hl=pt-br)
- 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:
- 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
- No Cocos, as linhas de execução do mecanismo principal e de renderização recebem um sessão
- No Unity, integre o plug-in Adaptive Performance Android Provider.
- 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
- A linha de execução de renderização e as dependências dela recebem uma sessão
- 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.
- 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.
C++
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);
Java
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
.
C++
auto tids = thread_ids.data();
std::size_t size = thread_ids_.size();
APerformanceHint_setThreads(hint_session, tids, size);
Java
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:
C++
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>
Java
System.nanoTime();
Exemplo:
C++
// 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);
Java
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.
C++
APerformanceHint_updateTargetWorkDuration(hint_session, target_duration);
Java
hintSession.updateTargetWorkDuration(targetDuration);