Performance Hint Manager

Return the APerformanceHintSession wrapped by a Java PerformanceHintManager.Session object.

The Java session maintains ownership over the wrapped native session, so it cannot be closed using APerformanceHint_closeSession. The return value is valid until the Java object containing this value dies.

The returned pointer is intended to be used by JNI calls to access native performance APIs using a Java hint session wrapper, and then immediately discarded. Using the pointer after the death of the Java container results in undefined behavior.

Release the performance hint manager pointer acquired via APerformanceHint_createSession.

This cannot be used to close a Java PerformanceHintManager.Session, as its lifecycle is tied to the object in the SDK.

Creates a session for the given set of threads and sets their initial target work duration.

Creates a session using arguments from a corresponding ASessionCreationConfig.

Note: when using graphics pipeline mode, using too many cumulative graphics pipeline threads is not a failure and will still create a session, but it will cause all graphics pipeline sessions to have undefined behavior and the method will return EBUSY.

Acquire an instance of the performance hint manager.

Get maximum number of graphics pipieline threads per-app for this device.

Get preferred update rate information for this device.

Deprecated. Client side rate limiting is not necessary, rate limiting is handled in the framework. If you were using this to check for hint session support, please use APerformanceHint_isFeatureSupported instead.

Checks whether the device exposes support for a specific feature.

Informs the framework of an upcoming increase in the workload of this session.

The user can specify whether the increase is expected to be on the CPU, GPU, or both.

These hints should be sent shortly before the start of the cycle where the workload is going to change, or as early as possible during that cycle for maximum effect. Hints sent towards the end of the cycle may be interpreted as applying to the next cycle. Any unsupported hints will be silently dropped, to avoid the need for excessive support checking each time they are sent, and sending a hint for both CPU and GPU will count as two separate hints for the rate limiter. These hints should not be sent repeatedly for an ongoing expensive workload, as workload time reporting is intended to handle this.

Informs the framework that the workload associated with this session is about to start, or that it is about to completely change, and that the system should discard any assumptions about its characteristics inferred from previous activity.

The user can specify whether the reset is expected to affect the CPU, GPU, or both.

These hints should be sent shortly before the start of the cycle where the workload is going to change, or as early as possible during that cycle for maximum effect. Hints sent towards the end of the cycle may be interpreted as applying to the next cycle. Any unsupported hints will be silently dropped, to avoid the need for excessive support checking each time they are sent, and sending a hint for both CPU and GPU will count as two separate hints for the rate limiter. These hints should not be sent repeatedly for an ongoing expensive workload, as workload time reporting is intended to handle this.

Informs the framework of an upcoming one-off expensive workload cycle for a given session.

This cycle will be treated as not representative of the workload as a whole, and it will be discarded the purposes of load tracking. The user can specify whether the workload spike is expected to be on the CPU, GPU, or both.

These hints should be sent shortly before the start of the cycle where the workload is going to change, or as early as possible during that cycle for maximum effect. Hints sent towards the end of the cycle may be interpreted as applying to the next cycle. Any unsupported hints will be silently dropped, to avoid the need for excessive support checking each time they are sent, and sending a hint for both CPU and GPU will count as two separate hints for the rate limiter. These hints should not be sent repeatedly for an ongoing expensive workload, as workload time reporting is intended to handle this.

Reports the actual duration for the last cycle of work.

The system will attempt to adjust the scheduling and performance of the threads within the thread group to bring the actual duration close to the target duration.

Reports the durations for the last cycle of work.

The system will attempt to adjust the scheduling and performance of the threads within the thread group to bring the actual duration close to the target duration.

The work period start timestamp and actual total duration must be greater than zero.

The actual CPU and GPU durations must be greater than or equal to zero, and at least one of them must be greater than zero. When one of them is equal to zero, it means that type of work was not measured for this workload.

Associates a session with any ASurfaceControl or ANativeWindow instances managed by this session.

Any previously associated objects that are not passed in again lose their association. Invalid or dead instances are ignored, and passing both lists as null drops all current associations.

This method is primarily intended for sessions that manage the timing of an entire graphics pipeline end-to-end for frame pacing, such as those using the ASessionCreationConfig_setGraphicsPipeline API. However, any session directly or indirectly managing a graphics pipeline should still associate themselves with directly relevant ASurfaceControl or ANativeWindow instances for better optimization. Additionally, if the surface associated with a session changes, this method should be called again to re-create the association.

To see any benefit from this method, the client must make sure they are updating the frame rate of attached surfaces using methods such as ANativeWindow_setFrameRate, or by updating any associated ASurfaceControls with transactions that have {ASurfaceTransaction_setFrameRate}.

This tells the session that these threads can be safely scheduled to prefer power efficiency over performance.

Set a list of threads to the performance hint session.

This operation will replace the current list of threads with the given list of threads.

Note: when using a session with the graphics pipeline mode enabled, using too many cumulative graphics pipeline threads is not a failure, but it will cause all graphics pipeline sessions to have undefined behavior and the method will return EBUSY.

Updates this session's target duration for each cycle of work.

ASessionCreationConfig_release

void ASessionCreationConfig_release(
  ASessionCreationConfig *_Nonnull config
)

ASessionCreationConfig_setGraphicsPipeline

void ASessionCreationConfig_setGraphicsPipeline(
  ASessionCreationConfig *_Nonnull config,
  bool enabled
)

ASessionCreationConfig_setNativeSurfaces

void ASessionCreationConfig_setNativeSurfaces(
  ASessionCreationConfig *_Nonnull config,
  ANativeWindow *_Nonnull *_Nullable nativeWindows,
  size_t nativeWindowsSize,
  ASurfaceControl *_Nonnull *_Nullable surfaceControls,
  size_t surfaceControlsSize
)

ASessionCreationConfig_setPreferPowerEfficiency

void ASessionCreationConfig_setPreferPowerEfficiency(
  ASessionCreationConfig *_Nonnull config,
  bool enabled
)

ASessionCreationConfig_setTargetWorkDurationNanos

void ASessionCreationConfig_setTargetWorkDurationNanos(
  ASessionCreationConfig *_Nonnull config,
  int64_t targetWorkDurationNanos
)

ASessionCreationConfig_setTids

void ASessionCreationConfig_setTids(
  ASessionCreationConfig *_Nonnull config,
  const pid_t *_Nonnull tids,
  size_t size
)

ASessionCreationConfig_setUseAutoTiming

void ASessionCreationConfig_setUseAutoTiming(
  ASessionCreationConfig *_Nonnull config,
  bool cpu,
  bool gpu
)

AWorkDuration_create

AWorkDuration *_Nonnull AWorkDuration_create()

AWorkDuration_release

void AWorkDuration_release(
  AWorkDuration *_Nonnull aWorkDuration
)

AWorkDuration_setActualCpuDurationNanos

void AWorkDuration_setActualCpuDurationNanos(
  AWorkDuration *_Nonnull aWorkDuration,
  int64_t actualCpuDurationNanos
)

AWorkDuration_setActualGpuDurationNanos

void AWorkDuration_setActualGpuDurationNanos(
  AWorkDuration *_Nonnull aWorkDuration,
  int64_t actualGpuDurationNanos
)

AWorkDuration_setActualTotalDurationNanos

void AWorkDuration_setActualTotalDurationNanos(
  AWorkDuration *_Nonnull aWorkDuration,
  int64_t actualTotalDurationNanos
)

AWorkDuration_setWorkPeriodStartTimestampNanos

void AWorkDuration_setWorkPeriodStartTimestampNanos(
  AWorkDuration *_Nonnull aWorkDuration,
  int64_t workPeriodStartTimestampNanos
)