1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
|
/*
* Copyright (C) 2021 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ANDROID_PRIVATE_NATIVE_PERFORMANCE_HINT_PRIVATE_H
#define ANDROID_PRIVATE_NATIVE_PERFORMANCE_HINT_PRIVATE_H
#include <stdint.h>
__BEGIN_DECLS
struct APerformanceHintManager;
struct APerformanceHintSession;
/**
* An opaque type representing a handle to a performance hint manager.
* It must be released after use.
*
* <p>To use:<ul>
* <li>Obtain the performance hint manager instance by calling
* {@link APerformanceHint_getManager} function.</li>
* <li>Create an {@link APerformanceHintSession} with
* {@link APerformanceHint_createSession}.</li>
* <li>Get the preferred update rate in nanoseconds with
* {@link APerformanceHint_getPreferredUpdateRateNanos}.</li>
*/
typedef struct APerformanceHintManager APerformanceHintManager;
/**
* An opaque type representing a handle to a performance hint session.
* A session can only be acquired from a {@link APerformanceHintManager}
* with {@link APerformanceHint_getPreferredUpdateRateNanos}. It must be
* freed with {@link APerformanceHint_closeSession} after use.
*
* A Session represents a group of threads with an inter-related workload such that hints for
* their performance should be considered as a unit. The threads in a given session should be
* long-life and not created or destroyed dynamically.
*
* <p>Each session is expected to have a periodic workload with a target duration for each
* cycle. The cycle duration is likely greater than the target work duration to allow other
* parts of the pipeline to run within the available budget. For example, a renderer thread may
* work at 60hz in order to produce frames at the display's frame but have a target work
* duration of only 6ms.</p>
*
* <p>After each cycle of work, the client is expected to use
* {@link APerformanceHint_reportActualWorkDuration} to report the actual time taken to
* complete.</p>
*
* <p>To use:<ul>
* <li>Update a sessions target duration for each cycle of work
* with {@link APerformanceHint_updateTargetWorkDuration}.</li>
* <li>Report the actual duration for the last cycle of work with
* {@link APerformanceHint_reportActualWorkDuration}.</li>
* <li>Release the session instance with
* {@link APerformanceHint_closeSession}.</li></ul></p>
*/
typedef struct APerformanceHintSession APerformanceHintSession;
/**
* Acquire an instance of the performance hint manager.
*
* @return manager instance on success, nullptr on failure.
*/
APerformanceHintManager* APerformanceHint_getManager();
/**
* Creates a session for the given set of threads and sets their initial target work
* duration.
* @param manager The performance hint manager instance.
* @param threadIds The list of threads to be associated with this session. They must be part of
* this app's thread group.
* @param size the size of threadIds.
* @param initialTargetWorkDurationNanos The desired duration in nanoseconds for the new session.
* This must be positive.
* @return manager instance on success, nullptr on failure.
*/
APerformanceHintSession* APerformanceHint_createSession(APerformanceHintManager* manager,
const int32_t* threadIds, size_t size,
int64_t initialTargetWorkDurationNanos);
/**
* Get preferred update rate information for this device.
*
* @param manager The performance hint manager instance.
* @return the preferred update rate supported by device software.
*/
int64_t APerformanceHint_getPreferredUpdateRateNanos(APerformanceHintManager* manager);
/**
* Updates this session's target duration for each cycle of work.
*
* @param session The performance hint session instance to update.
* @param targetDurationNanos the new desired duration in nanoseconds. This must be positive.
* @return 0 on success
* EINVAL if targetDurationNanos is not positive.
* EPIPE if communication with the system service has failed.
*/
int APerformanceHint_updateTargetWorkDuration(APerformanceHintSession* session,
int64_t targetDurationNanos);
/**
* Reports the actual duration for the last cycle of work.
*
* <p>The system will attempt to adjust the core placement of the threads within the thread
* group and/or the frequency of the core on which they are run to bring the actual duration
* close to the target duration.</p>
*
* @param session The performance hint session instance to update.
* @param actualDurationNanos how long the thread group took to complete its last task in
* nanoseconds. This must be positive.
* @return 0 on success
* EINVAL if actualDurationNanos is not positive.
* EPIPE if communication with the system service has failed.
*/
int APerformanceHint_reportActualWorkDuration(APerformanceHintSession* session,
int64_t actualDurationNanos);
/**
* Release the performance hint manager pointer acquired via
* {@link APerformanceHint_createSession}.
*
* @param session The performance hint session instance to release.
*/
void APerformanceHint_closeSession(APerformanceHintSession* session);
/**
* For testing only.
*/
void APerformanceHint_setIHintManagerForTesting(void* iManager);
__END_DECLS
#endif // ANDROID_PRIVATE_NATIVE_PERFORMANCE_HINT_PRIVATE_H
|
