Halide 22.0.0 Halide compiler and libraries

Featurization.h
Go to the documentation of this file.
1#ifndef FEATURIZATION_H
2#define FEATURIZATION_H
3
4#include <cstdint>
5#include <cstring>
6#include <iostream>
7
8 namespace Halide {
9 namespace Internal {
10
11// The algorithm-specific features. For legacy reasons these are
12// called PipelineFeatures in the code.
13 struct PipelineFeatures {
14 static constexpr size_t num_features() {
15 return sizeof(PipelineFeatures) / sizeof(int);
16 }
17
18 static constexpr uint32_t version() {
19 return 3;
20 }
21
22 // Access them by index.
23 int &operator[](int idx) {
24 return ((int *)(this))[idx];
25 }
26
27 int operator[](int idx) const {
28 return ((const int *)(this))[idx];
29 }
30
31 enum class OpType {
32 Const,
33 Cast,
34 Variable,
35 Param,
36 Add,
37 Sub,
38 Mod,
39 Mul,
40 Div,
41 Min,
42 Max,
43 EQ,
44 NE,
45 LT,
46 LE,
47 And,
48 Or,
49 Not,
50 Select,
51 ImageCall, // Loads to an input buffer
52 FuncCall, // Calls to another pipeline stage
53 SelfCall, // Recursive calls from a Func to itself
54 ExternCall, // Math intrinsics, typically
55 Let,
56 NumOpTypes
57 };
58
59 enum class ScalarType {
60 Bool,
61 UInt8, // or Int8
62 UInt16, // or Int16
63 UInt32, // or Int32
64 UInt64, // or Int64
65 Float,
66 Double,
67 NumScalarTypes
68 };
69
70 // Not fed into the network, but helps avoid printing huge numbers of zeros while debugging things
71 int types_in_use[(int)ScalarType::NumScalarTypes] = {};
72
73 int op_histogram[(int)OpType::NumOpTypes][(int)ScalarType::NumScalarTypes] = {};
74
75 enum class AccessType {
76 LoadFunc,
77 LoadSelf,
78 LoadImage,
79 Store,
80 NumAccessTypes
81 };
82
83 // Finer granularity call/store node properties. These are a
84 // function of the matrix of derivatives of each arg to a
85 // call w.r.t the loop variables of the Stage. Each row of
86 // the matrix corresponds to one of the call arguments. In
87 // each case we illustrate such a call, assuming that the
88 // variables of this Func are x, y, z, and that the
89 // dimension vectorized over is the first (x).
90
91 // Square identity matrix. f(x - 2, y + 8, z + param)
92 int pointwise_accesses[(int)AccessType::NumAccessTypes][(int)ScalarType::NumScalarTypes] = {};
93 // Square permutation matrix. f(y + 1, z - 3, x)
94 int transpose_accesses[(int)AccessType::NumAccessTypes][(int)ScalarType::NumScalarTypes] = {};
95 // Each row sums to 1. Each column sums to 1 or 0. f(y, x)
96 int broadcast_accesses[(int)AccessType::NumAccessTypes][(int)ScalarType::NumScalarTypes] = {};
97 // Each row sums to 1 or 0. Each column sums to 1. f(z, y, x, 4)
98 int slice_accesses[(int)AccessType::NumAccessTypes][(int)ScalarType::NumScalarTypes] = {};
99
100 void dump(std::ostream &os) const {
101 for (int i = 0; i < (int)ScalarType::NumScalarTypes; i++) {
102 const char *type_names[] = {"Bool", "UInt8", "UInt16", "UInt32", "UInt64", "Float", "Double"};
103 // Skip printing for types not used
104 if (!types_in_use[i]) {
105 continue;
106 }
107
108 os << " Featurization for type " << type_names[i] << "\n"
109 << " Op histogram:\n"
110 << " Constant: " << op_histogram[(int)OpType::Const][i] << "\n"
111 << " Cast: " << op_histogram[(int)OpType::Cast][i] << "\n"
112 << " Variable: " << op_histogram[(int)OpType::Variable][i] << "\n"
113 << " Param: " << op_histogram[(int)OpType::Param][i] << "\n"
114 << " Add: " << op_histogram[(int)OpType::Add][i] << "\n"
115 << " Sub: " << op_histogram[(int)OpType::Sub][i] << "\n"
116 << " Mod: " << op_histogram[(int)OpType::Mod][i] << "\n"
117 << " Mul: " << op_histogram[(int)OpType::Mul][i] << "\n"
118 << " Div: " << op_histogram[(int)OpType::Div][i] << "\n"
119 << " Min: " << op_histogram[(int)OpType::Min][i] << "\n"
120 << " Max: " << op_histogram[(int)OpType::Max][i] << "\n"
121 << " EQ: " << op_histogram[(int)OpType::EQ][i] << "\n"
122 << " NE: " << op_histogram[(int)OpType::NE][i] << "\n"
123 << " LT: " << op_histogram[(int)OpType::LT][i] << "\n"
124 << " LE: " << op_histogram[(int)OpType::LE][i] << "\n"
125 << " And: " << op_histogram[(int)OpType::And][i] << "\n"
126 << " Or: " << op_histogram[(int)OpType::Or][i] << "\n"
127 << " Not: " << op_histogram[(int)OpType::Not][i] << "\n"
128 << " Select: " << op_histogram[(int)OpType::Select][i] << "\n"
129 << " ImageCall: " << op_histogram[(int)OpType::ImageCall][i] << "\n"
130 << " FuncCall: " << op_histogram[(int)OpType::FuncCall][i] << "\n"
131 << " SelfCall: " << op_histogram[(int)OpType::SelfCall][i] << "\n"
132 << " ExternCall: " << op_histogram[(int)OpType::ExternCall][i] << "\n"
133 << " Let: " << op_histogram[(int)OpType::Let][i] << "\n"
134 << " Memory access patterns. Columns are calls to other Funcs, self-calls, input image access, and stores\n"
135 << " Pointwise: "
136 << pointwise_accesses[0][i] << " "
137 << pointwise_accesses[1][i] << " "
138 << pointwise_accesses[2][i] << " "
139 << pointwise_accesses[3][i] << "\n"
140 << " Transpose: "
141 << transpose_accesses[0][i] << " "
142 << transpose_accesses[1][i] << " "
143 << transpose_accesses[2][i] << " "
144 << transpose_accesses[3][i] << "\n"
145 << " Broadcast: "
146 << broadcast_accesses[0][i] << " "
147 << broadcast_accesses[1][i] << " "
148 << broadcast_accesses[2][i] << " "
149 << broadcast_accesses[3][i] << "\n"
150 << " Slice: "
151 << slice_accesses[0][i] << " "
152 << slice_accesses[1][i] << " "
153 << slice_accesses[2][i] << " "
154 << slice_accesses[3][i] << "\n";
155 }
156 }
157};
158
159// The schedule-dependent portion of the featurization of a stage
160 struct ScheduleFeatures {
161 static constexpr size_t num_features() {
162 return sizeof(ScheduleFeatures) / sizeof(double);
163 }
164
165 static constexpr uint32_t version() {
166 return 3;
167 }
168
169 double &operator[](int idx) {
170 return ((double *)(this))[idx];
171 }
172
173 double operator[](int idx) const {
174 return ((const double *)(this))[idx];
175 }
176
177 // The number of times storage for this stage is allocated. The
178 // product of outer loops at store_at site
179 double num_realizations = 0;
180
181 // The number of times a tile of the stage is computed. The
182 // product of outer loops at compute_at site. Always at least as
183 // large as num_realizations.
184 double num_productions = 0;
185
186 // Number of times the innermost loop happens per allocation.
187 double points_computed_per_realization = 0;
188
189 // Number of times the innermost stmt happens per tile computed.
190 double points_computed_per_production = 0;
191
192 // The total trip count of the innermost loop over the entire program.
193 // == num_realizations * points_computed_per_realization
194 // ~= num_productions * points_computed_per_production
195 // Only approximately equal because of the simplifications made
196 // regarding the modeling of sliding window
197 double points_computed_total = 0;
198
199 // The minimum number of points that are actually required to be
200 // computed to produce a correct output. Not actually a function
201 // of the schedule, but a useful reference point to see if a
202 // schedule has gone off the rails.
203 double points_computed_minimum = 0;
204
205 // Trip count of innermost loop nest.
206 double innermost_loop_extent = 0;
207
208 // Trip count of just the pure loops in the innermost loop
209 // (i.e. excludes loops representing reductions).
210 double innermost_pure_loop_extent = 0;
211
212 // If this is to be unrolled, what is the product of the unrolling
213 // factors.
214 double unrolled_loop_extent = 0;
215
216 // The number of parallel jobs launched in the production of this
217 // stage. Always 1 unless the Func is compute_root, because we
218 // place all parallelism at the outermost level.
219 double inner_parallelism = 0;
220
221 // The number of times this Func could be realized in parallel. 1
222 // when the Func is compute_root. Product of the containing
223 // parallel loops for other stages.
224 double outer_parallelism = 0;
225
226 // Size of the region computed at the store_at site, measured in
227 // bytes. Does not take storage-folding optimizations into account.
228 double bytes_at_realization = 0;
229
230 // Size of the region computed per tile (at the compute_at site),
231 // measured in bytes. This includes the effect of storage-folding,
232 // so it's a better number to look at to estimate memory usage.
233 double bytes_at_production = 0;
234
235 // If the stage were hypothetically scheduled at root, how much
236 // memory would it consumed. Doesn't vary w.r.t. the schedule, but
237 // a useful reference.
238 double bytes_at_root = 0;
239
240 // Same as the above, but only measuring the extent along the
241 // innermost dimension, so that we can reason about spatial
242 // locality, cache lines, prefetchers, etc.
243 double innermost_bytes_at_realization = 0;
244 double innermost_bytes_at_production = 0;
245 double innermost_bytes_at_root = 0;
246
247 // For inlined Funcs, how many calls are made to this Func total.
248 double inlined_calls = 0;
249
250 // Number of unique bytes and unique continguous segments of
251 // memory loaded from all inputs over a single trip of the loop
252 // containing the allocation site.
253 double unique_bytes_read_per_realization = 0;
254 double unique_lines_read_per_realization = 0;
255
256 // The sum of the sizes of the allocations accessed at this
257 // site. Gives a hint as to the likely locality of it.
258 double allocation_bytes_read_per_realization = 0;
259
260 // The sum of the sizes of the temporary allocations while
261 // computing one tile of this Func. Probably a good thing if it
262 // fits in cache.
263 double working_set = 0;
264
265 // The vectorization factor (#simd lanes) to be used to compute
266 // this stage. Wasted work if it's smaller than the stage's native
267 // vector size.
268 double vector_size = 0;
269
270 // The native vector size for the narrowest type used. Does not
271 // vary with the schedule, but a useful reference point.
272 double native_vector_size = 0;
273
274 // Number of SIMD vectors computed
275 double num_vectors = 0;
276
277 // Number of scalars computed (e.g. from tails of loops)
278 double num_scalars = 0;
279
280 // The number of loads done per vector or scalar computed. Vector
281 // gathers count as a batch of scalar loads. These get amortized
282 // across unrolled blocks if some loads can be reused across the
283 // unrolled dimension.
284 double scalar_loads_per_vector = 0;
285 double vector_loads_per_vector = 0;
286 double scalar_loads_per_scalar = 0;
287
288 // The memory footprint written over one per parallel task. The
289 // union of the regions if the stage is computed at finer
290 // granularity that one parallel task of some consumer.
291 double bytes_at_task = 0;
292 double innermost_bytes_at_task = 0;
293
294 // The memory footprint accessed while computing a single vector.
295 double unique_bytes_read_per_vector = 0;
296 double unique_lines_read_per_vector = 0;
297
298 // The memory footprint accessed per parallel task. Only counts
299 // loads from things computed outside of that parallel task (to
300 // measure the amount of traffic coming from another core).
301 double unique_bytes_read_per_task = 0;
302 double unique_lines_read_per_task = 0;
303
304 // The sum of the sizes of all live allocations at various sites.
305 double working_set_at_task = 0;
306 double working_set_at_production = 0;
307 double working_set_at_realization = 0;
308 double working_set_at_root = 0;
309
310 void dump(std::ostream &os) const {
311 os << " num_realizations: " << num_realizations << "\n"
312 << " num_productions: " << num_productions << "\n"
313 << " points_computed_per_realization: " << points_computed_per_realization << "\n"
314 << " points_computed_per_production: " << points_computed_per_production << "\n"
315 << " points_computed_total: " << points_computed_total << "\n"
316 << " points_computed_minimum: " << points_computed_minimum << "\n"
317 << " innermost_loop_extent: " << innermost_loop_extent << "\n"
318 << " innermost_pure_loop_extent: " << innermost_pure_loop_extent << "\n"
319 << " unrolled_loop_extent: " << unrolled_loop_extent << "\n"
320 << " inner_parallelism: " << inner_parallelism << "\n"
321 << " outer_parallelism: " << outer_parallelism << "\n"
322 << " bytes_at_realization: " << bytes_at_realization << "\n"
323 << " bytes_at_production: " << bytes_at_production << "\n"
324 << " bytes_at_root: " << bytes_at_root << "\n"
325 << " innermost_bytes_at_realization: " << innermost_bytes_at_realization << "\n"
326 << " innermost_bytes_at_production: " << innermost_bytes_at_production << "\n"
327 << " innermost_bytes_at_root: " << innermost_bytes_at_root << "\n"
328 << " inlined_calls: " << inlined_calls << "\n"
329 << " unique_bytes_read_per_realization: " << unique_bytes_read_per_realization << "\n"
330 << " unique_lines_read_per_realization: " << unique_lines_read_per_realization << "\n"
331 << " allocation_bytes_read_per_realization: " << allocation_bytes_read_per_realization << "\n"
332 << " working_set: " << working_set << "\n"
333 << " vector_size: " << vector_size << "\n"
334 << " native_vector_size: " << native_vector_size << "\n"
335 << " num_vectors: " << num_vectors << "\n"
336 << " num_scalars: " << num_scalars << "\n"
337 << " scalar_loads_per_vector: " << scalar_loads_per_vector << "\n"
338 << " vector_loads_per_vector: " << vector_loads_per_vector << "\n"
339 << " scalar_loads_per_scalar: " << scalar_loads_per_scalar << "\n"
340 << " bytes_at_task: " << bytes_at_task << "\n"
341 << " innermost_bytes_at_task: " << innermost_bytes_at_task << "\n"
342 << " unique_bytes_read_per_vector: " << unique_bytes_read_per_vector << "\n"
343 << " unique_lines_read_per_vector: " << unique_lines_read_per_vector << "\n"
344 << " unique_bytes_read_per_task: " << unique_bytes_read_per_task << "\n"
345 << " unique_lines_read_per_task: " << unique_lines_read_per_task << "\n"
346 << " working_set_at_task: " << working_set_at_task << "\n"
347 << " working_set_at_production: " << working_set_at_production << "\n"
348 << " working_set_at_realization: " << working_set_at_realization << "\n"
349 << " working_set_at_root: " << working_set_at_root << "\n";
350 }
351
352 bool equal(const ScheduleFeatures &other) const {
353 const size_t n_features = ScheduleFeatures::num_features();
354 for (size_t i = 0; i < n_features; i++) {
355 if ((*this)[i] != other[i]) {
356 return false;
357 }
358 }
359 return true;
360 }
361};
362
363/*
364 Some feature values cannot be cached, and need to be recomputed.
365 These intermediates allow for faster recomputation of such features.
366*/
367 struct FeatureIntermediates {
368 double inlined_calls;
369 double num_scalars;
370 double innermost_pure_loop_extent;
371 double outer_parallelism;
372};
373
374} // namespace Internal
375} // namespace Halide
376
377#endif
Halide::Param
A scalar parameter to a halide pipeline.
Definition: Param.h:22
Halide
This file defines the class FunctionDAG, which is our representation of a Halide pipeline,...
Definition: AbstractGenerator.h:19
Halide::Float
Type Float(int bits, int lanes=1)
Construct a floating-point type.
Definition: Type.h:549
Halide::LinkageType::Internal
@ Internal
Not visible externally, similar to 'static' linkage in C.
Halide::Bool
Type Bool(int lanes=1)
Construct a boolean type.
Definition: Type.h:559
uint32_t
unsigned __INT32_TYPE__ uint32_t
Definition: runtime_internal.h:25
Halide::Internal::Add
The sum of two expressions.
Definition: IR.h:66
Halide::Internal::And
Logical and - are both expressions true.
Definition: IR.h:185
Halide::Internal::Cast
The actual IR nodes begin here.
Definition: IR.h:40
Halide::Internal::Div
The ratio of two expressions.
Definition: IR.h:93
Halide::Internal::EQ
Is the first expression equal to the second.
Definition: IR.h:131
Halide::Internal::FeatureIntermediates
Definition: Featurization.h:367
Halide::Internal::FeatureIntermediates::num_scalars
double num_scalars
Definition: Featurization.h:369
Halide::Internal::FeatureIntermediates::outer_parallelism
double outer_parallelism
Definition: Featurization.h:371
Halide::Internal::FeatureIntermediates::inlined_calls
double inlined_calls
Definition: Featurization.h:368
Halide::Internal::FeatureIntermediates::innermost_pure_loop_extent
double innermost_pure_loop_extent
Definition: Featurization.h:370
Halide::Internal::LE
Is the first expression less than or equal to the second.
Definition: IR.h:158
Halide::Internal::LT
Is the first expression less than the second.
Definition: IR.h:149
Halide::Internal::Let
A let expression, like you might find in a functional language.
Definition: IR.h:281
Halide::Internal::Max
The greater of two values.
Definition: IR.h:122
Halide::Internal::Min
The lesser of two values.
Definition: IR.h:113
Halide::Internal::Mod
The remainder of a / b.
Definition: IR.h:104
Halide::Internal::Mul
The product of two expressions.
Definition: IR.h:84
Halide::Internal::NE
Is the first expression not equal to the second.
Definition: IR.h:140
Halide::Internal::Not
Logical not - true if the expression false.
Definition: IR.h:203
Halide::Internal::Or
Logical or - is at least one of the expression true.
Definition: IR.h:194
Halide::Internal::PipelineFeatures
Definition: Featurization.h:13
Halide::Internal::PipelineFeatures::dump
void dump(std::ostream &os) const
Definition: Featurization.h:100
Halide::Internal::PipelineFeatures::OpType
OpType
Definition: Featurization.h:31
Halide::Internal::PipelineFeatures::OpType::NumOpTypes
@ NumOpTypes
Halide::Internal::PipelineFeatures::OpType::ExternCall
@ ExternCall
Halide::Internal::PipelineFeatures::OpType::EQ
@ EQ
Halide::Internal::PipelineFeatures::OpType::ImageCall
@ ImageCall
Halide::Internal::PipelineFeatures::OpType::Or
@ Or
Halide::Internal::PipelineFeatures::OpType::Div
@ Div
Halide::Internal::PipelineFeatures::OpType::Variable
@ Variable
Halide::Internal::PipelineFeatures::OpType::Cast
@ Cast
Halide::Internal::PipelineFeatures::OpType::Mul
@ Mul
Halide::Internal::PipelineFeatures::OpType::Max
@ Max
Halide::Internal::PipelineFeatures::OpType::Min
@ Min
Halide::Internal::PipelineFeatures::OpType::Const
@ Const
Halide::Internal::PipelineFeatures::OpType::Mod
@ Mod
Halide::Internal::PipelineFeatures::OpType::SelfCall
@ SelfCall
Halide::Internal::PipelineFeatures::OpType::Not
@ Not
Halide::Internal::PipelineFeatures::OpType::Param
@ Param
Halide::Internal::PipelineFeatures::OpType::And
@ And
Halide::Internal::PipelineFeatures::OpType::LT
@ LT
Halide::Internal::PipelineFeatures::OpType::Let
@ Let
Halide::Internal::PipelineFeatures::OpType::LE
@ LE
Halide::Internal::PipelineFeatures::OpType::FuncCall
@ FuncCall
Halide::Internal::PipelineFeatures::OpType::NE
@ NE
Halide::Internal::PipelineFeatures::OpType::Select
@ Select
Halide::Internal::PipelineFeatures::OpType::Sub
@ Sub
Halide::Internal::PipelineFeatures::OpType::Add
@ Add
Halide::Internal::PipelineFeatures::version
static constexpr uint32_t version()
Definition: Featurization.h:18
Halide::Internal::PipelineFeatures::pointwise_accesses
int pointwise_accesses[(int) AccessType::NumAccessTypes][(int) ScalarType::NumScalarTypes]
Definition: Featurization.h:92
Halide::Internal::PipelineFeatures::operator[]
int & operator[](int idx)
Definition: Featurization.h:23
Halide::Internal::PipelineFeatures::broadcast_accesses
int broadcast_accesses[(int) AccessType::NumAccessTypes][(int) ScalarType::NumScalarTypes]
Definition: Featurization.h:96
Halide::Internal::PipelineFeatures::num_features
static constexpr size_t num_features()
Definition: Featurization.h:14
Halide::Internal::PipelineFeatures::op_histogram
int op_histogram[(int) OpType::NumOpTypes][(int) ScalarType::NumScalarTypes]
Definition: Featurization.h:73
Halide::Internal::PipelineFeatures::transpose_accesses
int transpose_accesses[(int) AccessType::NumAccessTypes][(int) ScalarType::NumScalarTypes]
Definition: Featurization.h:94
Halide::Internal::PipelineFeatures::types_in_use
int types_in_use[(int) ScalarType::NumScalarTypes]
Definition: Featurization.h:71
Halide::Internal::PipelineFeatures::operator[]
int operator[](int idx) const
Definition: Featurization.h:27
Halide::Internal::PipelineFeatures::AccessType
AccessType
Definition: Featurization.h:75
Halide::Internal::PipelineFeatures::AccessType::NumAccessTypes
@ NumAccessTypes
Halide::Internal::PipelineFeatures::slice_accesses
int slice_accesses[(int) AccessType::NumAccessTypes][(int) ScalarType::NumScalarTypes]
Definition: Featurization.h:98
Halide::Internal::PipelineFeatures::ScalarType
ScalarType
Definition: Featurization.h:59
Halide::Internal::PipelineFeatures::ScalarType::NumScalarTypes
@ NumScalarTypes
Halide::Internal::ScheduleFeatures
Definition: Featurization.h:160
Halide::Internal::ScheduleFeatures::working_set_at_production
double working_set_at_production
Definition: Featurization.h:306
Halide::Internal::ScheduleFeatures::equal
bool equal(const ScheduleFeatures &other) const
Definition: Featurization.h:352
Halide::Internal::ScheduleFeatures::innermost_loop_extent
double innermost_loop_extent
Definition: Featurization.h:206
Halide::Internal::ScheduleFeatures::unique_bytes_read_per_vector
double unique_bytes_read_per_vector
Definition: Featurization.h:295
Halide::Internal::ScheduleFeatures::points_computed_total
double points_computed_total
Definition: Featurization.h:197
Halide::Internal::ScheduleFeatures::points_computed_per_realization
double points_computed_per_realization
Definition: Featurization.h:187
Halide::Internal::ScheduleFeatures::bytes_at_task
double bytes_at_task
Definition: Featurization.h:291
Halide::Internal::ScheduleFeatures::working_set
double working_set
Definition: Featurization.h:263
Halide::Internal::ScheduleFeatures::innermost_bytes_at_root
double innermost_bytes_at_root
Definition: Featurization.h:245
Halide::Internal::ScheduleFeatures::innermost_bytes_at_realization
double innermost_bytes_at_realization
Definition: Featurization.h:243
Halide::Internal::ScheduleFeatures::operator[]
double operator[](int idx) const
Definition: Featurization.h:173
Halide::Internal::ScheduleFeatures::inner_parallelism
double inner_parallelism
Definition: Featurization.h:219
Halide::Internal::ScheduleFeatures::working_set_at_realization
double working_set_at_realization
Definition: Featurization.h:307
Halide::Internal::ScheduleFeatures::outer_parallelism
double outer_parallelism
Definition: Featurization.h:224
Halide::Internal::ScheduleFeatures::bytes_at_production
double bytes_at_production
Definition: Featurization.h:233
Halide::Internal::ScheduleFeatures::native_vector_size
double native_vector_size
Definition: Featurization.h:272
Halide::Internal::ScheduleFeatures::dump
void dump(std::ostream &os) const
Definition: Featurization.h:310
Halide::Internal::ScheduleFeatures::working_set_at_task
double working_set_at_task
Definition: Featurization.h:305
Halide::Internal::ScheduleFeatures::version
static constexpr uint32_t version()
Definition: Featurization.h:165
Halide::Internal::ScheduleFeatures::scalar_loads_per_vector
double scalar_loads_per_vector
Definition: Featurization.h:284
Halide::Internal::ScheduleFeatures::innermost_pure_loop_extent
double innermost_pure_loop_extent
Definition: Featurization.h:210
Halide::Internal::ScheduleFeatures::vector_loads_per_vector
double vector_loads_per_vector
Definition: Featurization.h:285
Halide::Internal::ScheduleFeatures::unique_bytes_read_per_task
double unique_bytes_read_per_task
Definition: Featurization.h:301
Halide::Internal::ScheduleFeatures::num_scalars
double num_scalars
Definition: Featurization.h:278
Halide::Internal::ScheduleFeatures::num_features
static constexpr size_t num_features()
Definition: Featurization.h:161
Halide::Internal::ScheduleFeatures::num_vectors
double num_vectors
Definition: Featurization.h:275
Halide::Internal::ScheduleFeatures::unique_bytes_read_per_realization
double unique_bytes_read_per_realization
Definition: Featurization.h:253
Halide::Internal::ScheduleFeatures::innermost_bytes_at_task
double innermost_bytes_at_task
Definition: Featurization.h:292
Halide::Internal::ScheduleFeatures::num_realizations
double num_realizations
Definition: Featurization.h:179
Halide::Internal::ScheduleFeatures::innermost_bytes_at_production
double innermost_bytes_at_production
Definition: Featurization.h:244
Halide::Internal::ScheduleFeatures::allocation_bytes_read_per_realization
double allocation_bytes_read_per_realization
Definition: Featurization.h:258
Halide::Internal::ScheduleFeatures::num_productions
double num_productions
Definition: Featurization.h:184
Halide::Internal::ScheduleFeatures::bytes_at_root
double bytes_at_root
Definition: Featurization.h:238
Halide::Internal::ScheduleFeatures::operator[]
double & operator[](int idx)
Definition: Featurization.h:169
Halide::Internal::ScheduleFeatures::points_computed_minimum
double points_computed_minimum
Definition: Featurization.h:203
Halide::Internal::ScheduleFeatures::unique_lines_read_per_realization
double unique_lines_read_per_realization
Definition: Featurization.h:254
Halide::Internal::ScheduleFeatures::working_set_at_root
double working_set_at_root
Definition: Featurization.h:308
Halide::Internal::ScheduleFeatures::inlined_calls
double inlined_calls
Definition: Featurization.h:248
Halide::Internal::ScheduleFeatures::unique_lines_read_per_vector
double unique_lines_read_per_vector
Definition: Featurization.h:296
Halide::Internal::ScheduleFeatures::points_computed_per_production
double points_computed_per_production
Definition: Featurization.h:190
Halide::Internal::ScheduleFeatures::unique_lines_read_per_task
double unique_lines_read_per_task
Definition: Featurization.h:302
Halide::Internal::ScheduleFeatures::unrolled_loop_extent
double unrolled_loop_extent
Definition: Featurization.h:214
Halide::Internal::ScheduleFeatures::bytes_at_realization
double bytes_at_realization
Definition: Featurization.h:228
Halide::Internal::ScheduleFeatures::scalar_loads_per_scalar
double scalar_loads_per_scalar
Definition: Featurization.h:286
Halide::Internal::ScheduleFeatures::vector_size
double vector_size
Definition: Featurization.h:268
Halide::Internal::Select
A ternary operator.
Definition: IR.h:214
Halide::Internal::Store
Store a 'value' to the buffer called 'name' at a given 'index' if 'predicate' is true.
Definition: IR.h:343
Halide::Internal::Sub
The difference of two expressions.
Definition: IR.h:75
Halide::Internal::Variable
A named variable.
Definition: IR.h:813