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
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
|
/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
/*
*
* (C) COPYRIGHT 2017-2018, 2020-2022 ARM Limited. All rights reserved.
*
* This program is free software and is provided to you under the terms of the
* GNU General Public License version 2 as published by the Free Software
* Foundation, and any use by you of this program is subject to the terms
* of such GNU license.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, you can access it online at
* http://www.gnu.org/licenses/gpl-2.0.html.
*
*/
#ifndef _KBASE_IPA_COUNTER_COMMON_JM_H_
#define _KBASE_IPA_COUNTER_COMMON_JM_H_
#include "mali_kbase.h"
#include "hwcnt/mali_kbase_hwcnt_virtualizer.h"
#include "hwcnt/mali_kbase_hwcnt_types.h"
/* Maximum number of IPA groups for an IPA model. */
#define KBASE_IPA_MAX_GROUP_DEF_NUM 16
/* Number of bytes per hardware counter in a vinstr_buffer. */
#define KBASE_IPA_NR_BYTES_PER_CNT (sizeof(u64))
/* Number of hardware counters per block in a vinstr_buffer. */
#define KBASE_IPA_NR_CNT_PER_BLOCK 64
/* Number of bytes per block in a vinstr_buffer. */
#define KBASE_IPA_NR_BYTES_PER_BLOCK \
(KBASE_IPA_NR_CNT_PER_BLOCK * KBASE_IPA_NR_BYTES_PER_CNT)
struct kbase_ipa_model_vinstr_data;
typedef u32
kbase_ipa_get_active_cycles_callback(struct kbase_ipa_model_vinstr_data *);
/**
* struct kbase_ipa_model_vinstr_data - IPA context per device
* @kbdev: pointer to kbase device
* @group_values: values of coefficients for IPA groups
* @groups_def: Array of IPA groups.
* @groups_def_num: Number of elements in the array of IPA groups.
* @get_active_cycles: Callback to return number of active cycles during
* counter sample period
* @hvirt_cli: hardware counter virtualizer client handle
* @dump_buf: buffer to dump hardware counters onto
* @reference_voltage: voltage, in mV, of the operating point used when
* deriving the power model coefficients. Range approx
* 0.1V - 5V (~= 8V): 2^7 <= reference_voltage <= 2^13
* @scaling_factor: User-specified power scaling factor. This is an
* integer, which is multiplied by the power coefficient
* just before OPP scaling.
* Range approx 0-32: 0 < scaling_factor < 2^5
* @min_sample_cycles: If the value of the GPU_ACTIVE counter (the number of
* cycles the GPU was working) is less than
* min_sample_cycles, the counter model will return an
* error, causing the IPA framework to approximate using
* the cached simple model results instead. This may be
* more accurate than extrapolating using a very small
* counter dump.
*/
struct kbase_ipa_model_vinstr_data {
struct kbase_device *kbdev;
s32 group_values[KBASE_IPA_MAX_GROUP_DEF_NUM];
const struct kbase_ipa_group *groups_def;
size_t groups_def_num;
kbase_ipa_get_active_cycles_callback *get_active_cycles;
struct kbase_hwcnt_virtualizer_client *hvirt_cli;
struct kbase_hwcnt_dump_buffer dump_buf;
s32 reference_voltage;
s32 scaling_factor;
s32 min_sample_cycles;
};
/**
* struct kbase_ipa_group - represents a single IPA group
* @name: name of the IPA group
* @default_value: default value of coefficient for IPA group.
* Coefficients are interpreted as fractions where the
* denominator is 1000000.
* @op: which operation to be performed on the counter values
* @counter_block_offset: block offset in bytes of the counter used to calculate energy for IPA group
*/
struct kbase_ipa_group {
const char *name;
s32 default_value;
s64 (*op)(
struct kbase_ipa_model_vinstr_data *model_data,
s32 coeff,
u32 counter_block_offset);
u32 counter_block_offset;
};
/**
* kbase_ipa_sum_all_shader_cores() - sum a counter over all cores
* @model_data: pointer to model data
* @coeff: model coefficient. Unity is ~2^20, so range approx
* +/- 4.0: -2^22 < coeff < 2^22
* @counter: offset in bytes of the counter used to calculate energy
* for IPA group
*
* Calculate energy estimation based on hardware counter `counter'
* across all shader cores.
*
* Return: Sum of counter values. Range: -2^54 < ret < 2^54
*/
s64 kbase_ipa_sum_all_shader_cores(
struct kbase_ipa_model_vinstr_data *model_data,
s32 coeff, u32 counter);
/**
* kbase_ipa_sum_all_memsys_blocks() - sum a counter over all mem system blocks
* @model_data: pointer to model data
* @coeff: model coefficient. Unity is ~2^20, so range approx
* +/- 4.0: -2^22 < coeff < 2^22
* @counter: offset in bytes of the counter used to calculate energy
* for IPA group
*
* Calculate energy estimation based on hardware counter `counter' across all
* memory system blocks.
*
* Return: Sum of counter values. Range: -2^51 < ret < 2^51
*/
s64 kbase_ipa_sum_all_memsys_blocks(
struct kbase_ipa_model_vinstr_data *model_data,
s32 coeff, u32 counter);
/**
* kbase_ipa_single_counter() - sum a single counter
* @model_data: pointer to model data
* @coeff: model coefficient. Unity is ~2^20, so range approx
* +/- 4.0: -2^22 < coeff < 2^22
* @counter: offset in bytes of the counter used to calculate energy
* for IPA group
*
* Calculate energy estimation based on hardware counter `counter'.
*
* Return: Counter value. Range: -2^49 < ret < 2^49
*/
s64 kbase_ipa_single_counter(
struct kbase_ipa_model_vinstr_data *model_data,
s32 coeff, u32 counter);
/**
* kbase_ipa_attach_vinstr() - attach a vinstr_buffer to an IPA model.
* @model_data: pointer to model data
*
* Attach a vinstr_buffer to an IPA model. The vinstr_buffer
* allows access to the hardware counters used to calculate
* energy consumption.
*
* Return: 0 on success, or an error code.
*/
int kbase_ipa_attach_vinstr(struct kbase_ipa_model_vinstr_data *model_data);
/**
* kbase_ipa_detach_vinstr() - detach a vinstr_buffer from an IPA model.
* @model_data: pointer to model data
*
* Detach a vinstr_buffer from an IPA model.
*/
void kbase_ipa_detach_vinstr(struct kbase_ipa_model_vinstr_data *model_data);
/**
* kbase_ipa_vinstr_dynamic_coeff() - calculate dynamic power based on HW counters
* @model: pointer to instantiated model
* @coeffp: pointer to location where calculated power, in
* pW/(Hz V^2), is stored.
*
* This is a GPU-agnostic implementation of the get_dynamic_coeff()
* function of an IPA model. It relies on the model being populated
* with GPU-specific attributes at initialization time.
*
* Return: 0 on success, or an error code.
*/
int kbase_ipa_vinstr_dynamic_coeff(struct kbase_ipa_model *model, u32 *coeffp);
/**
* kbase_ipa_vinstr_reset_data() - Reset the counters data used for dynamic
* power estimation
* @model: pointer to instantiated model
*
* Currently it is not implemented for JM GPUs.
* When implemented it is expected to retrieve the accumulated value of HW
* counters from the Vinstr component, without doing any processing, which is
* effectively a reset as the next call to kbase_ipa_counter_dynamic_coeff()
* will see the increment in counter values from this point onwards.
*/
void kbase_ipa_vinstr_reset_data(struct kbase_ipa_model *model);
/**
* kbase_ipa_vinstr_common_model_init() - initialize ipa power model
* @model: ipa power model to initialize
* @ipa_groups_def: array of ipa groups which sets coefficients for
* the corresponding counters used in the ipa model
* @ipa_group_size: number of elements in the array @ipa_groups_def
* @get_active_cycles: callback to return the number of cycles the GPU was
* active during the counter sample period.
* @reference_voltage: voltage, in mV, of the operating point used when
* deriving the power model coefficients.
*
* This initialization function performs initialization steps common
* for ipa models based on counter values. In each call, the model
* passes its specific coefficient values per ipa counter group via
* @ipa_groups_def array.
*
* Return: 0 on success, error code otherwise
*/
int kbase_ipa_vinstr_common_model_init(struct kbase_ipa_model *model,
const struct kbase_ipa_group *ipa_groups_def,
size_t ipa_group_size,
kbase_ipa_get_active_cycles_callback *get_active_cycles,
s32 reference_voltage);
/**
* kbase_ipa_vinstr_common_model_term() - terminate ipa power model
* @model: ipa power model to terminate
*
* This function performs all necessary steps to terminate ipa power model
* including clean up of resources allocated to hold model data.
*/
void kbase_ipa_vinstr_common_model_term(struct kbase_ipa_model *model);
#endif /* _KBASE_IPA_COUNTER_COMMON_JM_H_ */
|
