operation.hpp 22.6 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
/*
 * The MIT License (MIT)
 *
 * Copyright (c) 2015-2022 Advanced Micro Devices, Inc. All rights reserved.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */
Paul's avatar
Paul committed
24
25
#ifndef MIGRAPHX_GUARD_MIGRAPHLIB_OPERAND_HPP
#define MIGRAPHX_GUARD_MIGRAPHLIB_OPERAND_HPP
Paul's avatar
Paul committed
26

Paul's avatar
Paul committed
27
#include <cassert>
Paul's avatar
Paul committed
28
29
30
31
32
#include <string>
#include <functional>
#include <memory>
#include <type_traits>
#include <utility>
Shucai Xiao's avatar
Shucai Xiao committed
33
#include <unordered_map>
Paul's avatar
Paul committed
34
#include <migraphx/reflect.hpp>
35
36
#include <migraphx/dyn_output.hpp>
#include <migraphx/functional.hpp>
Paul's avatar
Paul committed
37
#include <migraphx/streamutils.hpp>
Shucai Xiao's avatar
Shucai Xiao committed
38
#include <migraphx/normalize_attributes.hpp>
Paul's avatar
Paul committed
39
#include <migraphx/argument.hpp>
Shucai Xiao's avatar
Shucai Xiao committed
40
#include <migraphx/module_ref.hpp>
41
#include <migraphx/serialize.hpp>
Paul's avatar
Paul committed
42
#include <migraphx/auto_any_cast.hpp>
43
#include <migraphx/lifetime.hpp>
Paul's avatar
Paul committed
44
#include <migraphx/config.hpp>
Paul's avatar
Paul committed
45

Paul's avatar
Paul committed
46
namespace migraphx {
Paul's avatar
Paul committed
47
inline namespace MIGRAPHX_INLINE_NS {
Paul's avatar
Paul committed
48

Paul's avatar
Paul committed
49
50
struct context;

Paul's avatar
Paul committed
51
52
53
54
55
56
57
58
#ifdef DOXYGEN

/// The operation interface represents an action an instruction will perform. All
/// operation classes must be CopyConstructible.
struct operation
{
    /// A unique name identifying the operation
    std::string name() const;
Paul's avatar
Paul committed
59
60
    /// An optional method that can be used to finalize the operator before running
    void finalize(context& ctx);
Paul's avatar
Paul committed
61
62
63
    /// This is used to compute the resulting shape from an operation. If an
    /// operation cannot be run with input shapes, then it should throw an
    /// exception.
Paul's avatar
Paul committed
64
    shape compute_shape(const std::vector<shape>& input) const;
Paul's avatar
Paul committed
65
    /**
Paul's avatar
Paul committed
66
67
     * @brief This performs the operation's computation.
     *
Paul's avatar
Paul committed
68
69
     * This method can be optional when the operation is only used as a placeholder to be lowered
     * later on.
Paul's avatar
Paul committed
70
71
72
     *
     * @param ctx This is the context created by the `target` during compilation. Implementations
     * can use the target's `context` class rather than the `context` interface class.
73
74
75
76
     * @param output Equivalent to running `compute_shape` with each `shape` of the `argument`.
     * For a fixed shape, the returned argument will have the same shape as `output`.
     * For a dynamic shape, the returned `argument` will be a fixed shape within the bounds
     * set in the dynamic shape `output`.
Paul's avatar
Paul committed
77
     * @param input This is the `argument` result from the previous instruction's computation.
Paul's avatar
Paul committed
78
79
     * @return Return an `argument` of the result computation. The `shape` of `argument` should be
     * the same the `output` shape.
Paul's avatar
Paul committed
80
     */
Paul's avatar
Paul committed
81
    argument compute(context& ctx, const shape& output, const std::vector<argument>& input) const;
Paul's avatar
Paul committed
82
83
    /// An optional method to return which argument the output will alias. If
    /// there is no aliased output then -1 can be returned.
Paul's avatar
Paul committed
84
    std::ptrdiff_t output_alias(const std::vector<shape>& input) const;
Paul's avatar
Paul committed
85
86
    /// An optional stream operator to print the operation. When this is not
    /// implemented, it will just print the operation's name.
Paul's avatar
Paul committed
87
    friend std::ostream& operator<<(std::ostream& os, const operation& op);
Paul's avatar
Paul committed
88
89
};

Paul's avatar
Paul committed
90
91
/// Returns true if operation does not require a context to run compute
bool is_context_free(const operation& x);
Shucai Xiao's avatar
Shucai Xiao committed
92
93
/// Returns true if operation needs normalization before running compute
bool need_normalization(const operation& x);
Paul's avatar
Paul committed
94
95
/// Returns true if the operation has a finalize method
bool has_finalize(const operation& x);
Paul's avatar
Paul committed
96

Paul's avatar
Paul committed
97
98
#else

99
100
101
namespace detail {

namespace operation_operators {
Paul's avatar
Paul committed
102

Paul's avatar
Paul committed
103
104
template <class T>
auto operator<<(std::ostream& os, const T& x) -> decltype(os << x.name())
Paul's avatar
Paul committed
105
{
Paul's avatar
Paul committed
106
107
    os << x.name();
    char delim = '[';
Paul's avatar
Paul committed
108
    reflect_each(x, [&](auto&& y, auto name) {
Paul's avatar
Paul committed
109
        os << delim;
Paul's avatar
Paul committed
110
111
        os << name << "=";
        stream_write_value(os, y);
Paul's avatar
Paul committed
112
113
        delim = ',';
    });
Paul's avatar
Paul committed
114
115
    if(delim == ',')
        os << "]";
Paul's avatar
Paul committed
116
    return os;
Paul's avatar
Paul committed
117
118
}

Paul's avatar
Paul committed
119
120
121
template <class T, class U>
auto operator==(const T& x, const U& y) -> decltype(x.name() == y.name())
{
Paul's avatar
Paul committed
122
123
    static_assert(is_reflectable<T>{} or sizeof(T) <= 1,
                  "Missing equality operator or reflect method.");
Paul's avatar
Paul committed
124
125
126
127
128
129
    if(x.name() != y.name())
        return false;
    const auto& yy = any_cast<T>(y);
    return reflect_tie(x) == reflect_tie(yy);
}

130
} // namespace operation_operators
Paul's avatar
Paul committed
131

Shucai Xiao's avatar
Shucai Xiao committed
132
template <class T>
133
134
135
136
137
138
139
140
auto compute_shape_op(rank<3>, const T& x, const std::vector<shape>& inputs)
    -> decltype(x.compute_shape(inputs))
{
    return x.compute_shape(inputs);
}

template <class T>
auto compute_shape_op(rank<2>, const T& x, const std::vector<shape>& inputs)
Shucai Xiao's avatar
Shucai Xiao committed
141
    -> decltype(x.normalize_compute_shape(inputs))
Shucai Xiao's avatar
Shucai Xiao committed
142
{
143
144
    if(inputs.empty())
        MIGRAPHX_THROW("At least one input is required for " + x.name());
Shucai Xiao's avatar
Shucai Xiao committed
145
    dependent_type<operation, T> y = x;
146
    normalize_attributes(y, inputs[0]);
Shucai Xiao's avatar
Shucai Xiao committed
147
148
149
    return any_cast<T>(y).normalize_compute_shape(inputs);
}

150
template <class T>
151
auto compute_shape_op(rank<1>, const T& x, const std::vector<shape>& inputs)
152
153
154
155
156
    -> decltype(x.compute_shape(inputs, {}))
{
    return x.compute_shape(inputs, {});
}

Shucai Xiao's avatar
Shucai Xiao committed
157
template <class T>
158
shape compute_shape_op(rank<0>, const T& x, const std::vector<shape>&)
Shucai Xiao's avatar
Shucai Xiao committed
159
160
161
162
163
164
{
    std::string name = x.name();
    MIGRAPHX_THROW("Shape not computable: " + name);
}

template <class T>
165
shape compute_shape_op(const T& x, const std::vector<shape>& inputs)
Shucai Xiao's avatar
Shucai Xiao committed
166
{
167
    return compute_shape_op(rank<3>{}, x, inputs);
Shucai Xiao's avatar
Shucai Xiao committed
168
169
170
}

template <class T>
171
172
173
174
auto mod_compute_shape_op(rank<1>,
                          const T& x,
                          const std::vector<shape>& inputs,
                          const std::vector<module_ref>& mod_args)
Shucai Xiao's avatar
Shucai Xiao committed
175
176
177
178
179
180
    -> decltype(x.compute_shape(inputs, mod_args))
{
    return x.compute_shape(inputs, mod_args);
}

template <class T>
181
182
183
184
shape mod_compute_shape_op(rank<0>,
                           const T& x,
                           const std::vector<shape>& inputs,
                           const std::vector<module_ref>& mod_args)
Shucai Xiao's avatar
Shucai Xiao committed
185
{
186
187
    if(mod_args.empty())
        return compute_shape_op(x, inputs);
Shucai Xiao's avatar
Shucai Xiao committed
188
189
190
191
192
    std::string name = x.name();
    MIGRAPHX_THROW("Shape not computable: " + name);
}

template <class T>
193
194
195
shape mod_compute_shape_op(const T& x,
                           const std::vector<shape>& inputs,
                           const std::vector<module_ref>& mod_args)
Shucai Xiao's avatar
Shucai Xiao committed
196
{
197
    return mod_compute_shape_op(rank<1>{}, x, inputs, mod_args);
Shucai Xiao's avatar
Shucai Xiao committed
198
199
}

Paul's avatar
Paul committed
200
template <class T>
Shucai Xiao's avatar
Shucai Xiao committed
201
auto compute_op(rank<1>,
Paul's avatar
Paul committed
202
203
204
205
                const T& x,
                context& ctx,
                const shape& output_shape,
                const std::vector<argument>& input)
206
207
208
    -> decltype(x.compute(auto_any_cast(ctx),
                          make_compute_output_shape(pack(x, output_shape, input)),
                          input))
Paul's avatar
Paul committed
209
{
210
211
    return x.compute(
        auto_any_cast(ctx), make_compute_output_shape(pack(x, output_shape, input)), input);
Paul's avatar
Paul committed
212
213
214
}

template <class T>
Paul's avatar
Paul committed
215
argument compute_op(rank<0>, const T& x, context&, const shape&, const std::vector<argument>&)
Paul's avatar
Paul committed
216
{
Paul's avatar
Paul committed
217
    std::string name = x.name();
Paul's avatar
Paul committed
218
    MIGRAPHX_THROW("Not computable: " + name);
Paul's avatar
Paul committed
219
220
}

Paul's avatar
Paul committed
221
template <class T>
Paul's avatar
Paul committed
222
223
argument
compute_op(const T& x, context& ctx, const shape& output_shape, const std::vector<argument>& input)
Paul's avatar
Paul committed
224
{
Shucai Xiao's avatar
Shucai Xiao committed
225
    return compute_op(rank<1>{}, x, ctx, output_shape, input);
Paul's avatar
Paul committed
226
227
228
}

template <class T>
Shucai Xiao's avatar
Shucai Xiao committed
229
auto compute_op(rank<1>, const T& x, const shape& output_shape, const std::vector<argument>& input)
230
    -> decltype(x.compute(make_compute_output_shape(pack(x, output_shape, input)), input))
Paul's avatar
Paul committed
231
{
232
    return x.compute(make_compute_output_shape(pack(x, output_shape, input)), input);
Paul's avatar
Paul committed
233
234
235
}

template <class T>
Shucai Xiao's avatar
Shucai Xiao committed
236
argument compute_op(rank<0>, const T& x, const shape&, const std::vector<argument>&)
Paul's avatar
Paul committed
237
238
{
    std::string name = x.name();
Shucai Xiao's avatar
Shucai Xiao committed
239
    MIGRAPHX_THROW("Not computable: " + name);
Paul's avatar
Paul committed
240
241
242
}

template <class T>
Shucai Xiao's avatar
Shucai Xiao committed
243
244
245
246
247
248
249
250
251
252
253
argument compute_op(const T& x, const shape& output_shape, const std::vector<argument>& input)
{
    return compute_op(rank<1>{}, x, output_shape, input);
}

template <class T, class F>
auto compute_op(rank<1>,
                const T& x,
                const shape& output,
                const std::vector<argument>& inputs,
                const std::vector<module_ref>& module_args,
254
255
256
                F f)
    -> decltype(
        x.compute(make_compute_output_shape(pack(x, output, inputs)), inputs, module_args, f))
Shucai Xiao's avatar
Shucai Xiao committed
257
{
258
    return x.compute(make_compute_output_shape(pack(x, output, inputs)), inputs, module_args, f);
Shucai Xiao's avatar
Shucai Xiao committed
259
260
261
262
263
}

template <class T, class F>
argument compute_op(rank<0>,
                    const T& x,
264
265
266
                    const shape& output,
                    const std::vector<argument>& inputs,
                    const std::vector<module_ref>& module_args,
Shucai Xiao's avatar
Shucai Xiao committed
267
                    F)
Paul's avatar
Paul committed
268
{
269
270
    if(module_args.empty())
        return compute_op(x, output, inputs);
Paul's avatar
Paul committed
271
272
273
274
    std::string name = x.name();
    MIGRAPHX_THROW("Not computable: " + name);
}

Shucai Xiao's avatar
Shucai Xiao committed
275
276
277
278
279
280
template <class T, class F>
argument compute_op(const T& x,
                    const shape& output,
                    const std::vector<argument>& inputs,
                    const std::vector<module_ref>& module_args,
                    F f)
Paul's avatar
Paul committed
281
{
Shucai Xiao's avatar
Shucai Xiao committed
282
    return compute_op(rank<1>{}, x, output, inputs, module_args, f);
Paul's avatar
Paul committed
283
284
}

Shucai Xiao's avatar
Shucai Xiao committed
285
286
287
288
289
290
291
template <class T, class F>
auto compute_op(rank<4>,
                const T& x,
                context& ctx,
                const shape& output,
                const std::vector<argument>& inputs,
                const std::vector<module_ref>& module_args,
292
293
294
295
296
                F f) -> decltype(x.compute(auto_any_cast(ctx),
                                           make_compute_output_shape(pack(x, output, inputs)),
                                           inputs,
                                           module_args,
                                           f))
Shucai Xiao's avatar
Shucai Xiao committed
297
{
298
299
300
301
302
    return x.compute(auto_any_cast(ctx),
                     make_compute_output_shape(pack(x, output, inputs)),
                     inputs,
                     module_args,
                     f);
Shucai Xiao's avatar
Shucai Xiao committed
303
304
}

Shucai Xiao's avatar
Shucai Xiao committed
305
template <class T, class F>
Shucai Xiao's avatar
Shucai Xiao committed
306
auto compute_op(rank<3>,
Shucai Xiao's avatar
Shucai Xiao committed
307
                const T& x,
Shucai Xiao's avatar
Shucai Xiao committed
308
309
                context&,
                const shape& output,
Shucai Xiao's avatar
Shucai Xiao committed
310
311
                const std::vector<argument>& inputs,
                const std::vector<module_ref>& module_args,
312
313
314
                F f)
    -> decltype(
        x.compute(make_compute_output_shape(pack(x, output, inputs)), inputs, module_args, f))
Shucai Xiao's avatar
Shucai Xiao committed
315
{
316
    return x.compute(make_compute_output_shape(pack(x, output, inputs)), inputs, module_args, f);
Shucai Xiao's avatar
Shucai Xiao committed
317
318
319
}

template <class T, class F>
Shucai Xiao's avatar
Shucai Xiao committed
320
321
322
323
324
325
auto compute_op(rank<2>,
                const T& x,
                context&,
                const shape& output,
                const std::vector<argument>& inputs,
                const std::vector<module_ref>&,
326
327
                F)
    -> decltype(x.compute(make_compute_output_shape(pack(x, output, inputs)), inputs))
Shucai Xiao's avatar
Shucai Xiao committed
328
{
329
    return x.compute(make_compute_output_shape(pack(x, output, inputs)), inputs);
Shucai Xiao's avatar
Shucai Xiao committed
330
331
332
333
334
335
336
337
338
}

template <class T, class F>
auto compute_op(rank<1>,
                const T& x,
                context& ctx,
                const shape& output,
                const std::vector<argument>& inputs,
                const std::vector<module_ref>&,
339
340
341
                F) -> decltype(x.compute(auto_any_cast(ctx),
                                         make_compute_output_shape(pack(x, output, inputs)),
                                         inputs))
Shucai Xiao's avatar
Shucai Xiao committed
342
{
343
344
    return x.compute(
        auto_any_cast(ctx), make_compute_output_shape(pack(x, output, inputs)), inputs);
Shucai Xiao's avatar
Shucai Xiao committed
345
346
347
348
349
350
351
352
353
354
}

template <class T, class F>
argument compute_op(rank<0>,
                    const T& x,
                    context&,
                    const shape&,
                    const std::vector<argument>&,
                    const std::vector<module_ref>&,
                    F)
Shucai Xiao's avatar
Shucai Xiao committed
355
356
357
358
359
360
361
{
    std::string name = x.name();
    MIGRAPHX_THROW("Not computable: " + name);
}

template <class T, class F>
argument compute_op(const T& x,
Shucai Xiao's avatar
Shucai Xiao committed
362
363
                    context& ctx,
                    const shape& output,
Shucai Xiao's avatar
Shucai Xiao committed
364
365
366
367
                    const std::vector<argument>& inputs,
                    const std::vector<module_ref>& module_args,
                    F f)
{
Shucai Xiao's avatar
Shucai Xiao committed
368
    return compute_op(rank<4>{}, x, ctx, output, inputs, module_args, f);
Shucai Xiao's avatar
Shucai Xiao committed
369
370
}

Paul's avatar
Paul committed
371
template <class T>
Paul's avatar
Paul committed
372
373
374
375
auto is_context_free_op(rank<1>,
                        const T& x,
                        const shape& output_shape,
                        const std::vector<argument>& input)
376
377
    -> decltype(x.compute(make_compute_output_shape(pack(x, output_shape, input)), input),
                std::true_type{});
Paul's avatar
Paul committed
378
379

template <class T>
Paul's avatar
Paul committed
380
381
auto is_context_free_op(rank<0>, const T&, const shape&, const std::vector<argument>&)
    -> std::false_type;
Paul's avatar
Paul committed
382
383

template <class T>
Paul's avatar
Paul committed
384
385
auto is_context_free_op(const T& x) -> decltype(is_context_free_op(
    rank<1>{}, x, std::declval<const shape&>(), std::declval<std::vector<argument>>()))
Paul's avatar
Paul committed
386
387
{
    return {};
Paul's avatar
Paul committed
388
389
}

Shucai Xiao's avatar
Shucai Xiao committed
390
391
392
393
394
395
396
397
398
399
400
401
402
403
template <class T>
auto need_normalization_op(rank<1>, const T& x, const std::vector<shape>& inputs)
    -> decltype(x.normalize_compute_shape(inputs), std::true_type{});

template <class T>
auto need_normalization_op(rank<0>, const T&, const std::vector<shape>&) -> std::false_type;

template <class T>
auto need_normalization_op(const T& x)
    -> decltype(need_normalization_op(rank<1>{}, x, std::declval<std::vector<shape>>()))
{
    return {};
}

Paul's avatar
Paul committed
404
template <class T>
405
std::ptrdiff_t output_alias_op(const T&, const std::vector<shape>&)
Paul's avatar
Paul committed
406
407
408
409
{
    return -1;
}

Paul's avatar
Paul committed
410
template <class T>
Paul's avatar
Paul committed
411
412
auto finalize_op(
    rank<1>, T& x, context& ctx, const shape& output_shape, const std::vector<shape>& input)
Paul's avatar
Paul committed
413
414
415
416
417
418
419
    -> decltype(x.finalize(auto_any_cast(ctx), output_shape, input), void())
{
    x.finalize(auto_any_cast(ctx), output_shape, input);
}

template <class T>
void finalize_op(rank<0>, T&, context&, const shape&, const std::vector<shape>&)
Paul's avatar
Paul committed
420
421
{
}
Paul's avatar
Paul committed
422
423
424
425
426
427
428
429

template <class T>
void finalize_op(T& x, context& ctx, const shape& output_shape, const std::vector<shape>& input)
{
    finalize_op(rank<1>{}, x, ctx, output_shape, input);
}

template <class T>
Paul's avatar
Paul committed
430
431
auto has_finalize_op(
    rank<1>, T& x, context& ctx, const shape& output_shape, const std::vector<shape>& input)
Paul's avatar
Paul committed
432
433
434
435
436
437
438
    -> decltype(x.finalize(auto_any_cast(ctx), output_shape, input), std::true_type{});

template <class T>
auto has_finalize_op(rank<0>, T&, context&, const shape&, const std::vector<shape>&)
    -> std::false_type;

template <class T>
Paul's avatar
Paul committed
439
440
441
442
443
auto has_finalize_op(const T&) -> decltype(has_finalize_op(rank<1>{},
                                                           std::declval<T&>(),
                                                           std::declval<context&>(),
                                                           std::declval<const shape&>(),
                                                           std::declval<std::vector<shape>>()))
Paul's avatar
Paul committed
444
445
446
447
{
    return {};
}

448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
template <class T>
auto compile_op(
    rank<1>, T& x, context& ctx, const shape& output_shape, const std::vector<shape>& input)
    -> decltype(x.compile(auto_any_cast(ctx), output_shape, input))
{
    return x.compile(auto_any_cast(ctx), output_shape, input);
}

template <class T>
value compile_op(rank<0>, T&, context&, const shape&, const std::vector<shape>&)
{
    return value::object{};
}

template <class T>
value compile_op(const T& x,
                 context& ctx,
                 const shape& output_shape,
                 const std::vector<shape>& input)
{
    return compile_op(rank<1>{}, x, ctx, output_shape, input);
}

471
472
473
474
475
476
template <class T>
value attributes_op(const T&)
{
    return value::object{};
}

477
478
479
480
481
482
483
484
485
template <class T>
value to_value_op(const T& x)
{
    return migraphx::to_value(x);
}

template <class T>
void from_value_op(T& x, const value& v)
{
486
487
    if(not(v.is_object() or (v.empty() and v.is_array())))
        MIGRAPHX_THROW("Value is not an object");
488
489
490
    return migraphx::from_value(v, x);
}

491
template <class T>
492
lifetime get_lifetime_op(const T&)
493
{
494
    return lifetime::local;
495
496
}

497
498
} // namespace detail

499
<%
Paul's avatar
Paul committed
500
501
502
 interface(
     'operation',
     virtual('name', returns = 'std::string', const = True),
Paul's avatar
Paul committed
503
504
     virtual(
         'is_context_free', returns = 'bool', const = True, default = 'detail::is_context_free_op'),
Shucai Xiao's avatar
Shucai Xiao committed
505
506
507
508
     virtual('need_normalization',
             returns = 'bool',
             const   = True,
             default = 'detail::need_normalization_op'),
509
     virtual('has_finalize', returns = 'bool', const = True, default = 'detail::has_finalize_op'),
510
511
     virtual(
         'get_lifetime', returns = 'lifetime', const = True, default = 'detail::get_lifetime_op'),
Paul's avatar
Paul committed
512
     virtual('output_alias',
Paul's avatar
Paul committed
513
             returns = 'std::ptrdiff_t',
Paul's avatar
Paul committed
514
515
             input   = 'const std::vector<shape>&',
             const   = True,
516
             default = 'detail::output_alias_op'),
517
518
519
520
521
522
     virtual('compile',
             returns = 'value',
             ctx     = 'context&',
             output  = 'const shape&',
             input   = 'const std::vector<shape>&',
             default = 'detail::compile_op'),
Paul's avatar
Paul committed
523
524
525
526
     virtual('finalize',
             ctx     = 'context&',
             output  = 'const shape&',
             input   = 'const std::vector<shape>&',
527
             default = 'detail::finalize_op'),
Shucai Xiao's avatar
Shucai Xiao committed
528
529
530
531
     virtual('compute_shape',
             returns = 'shape',
             input   = 'const std::vector<shape>&',
             const   = True,
532
             default = 'detail::compute_shape_op'),
Shucai Xiao's avatar
Shucai Xiao committed
533
534
535
536
537
     virtual('compute_shape',
             returns  = 'shape',
             inputs   = 'const std::vector<shape>&',
             mod_args = 'const std::vector<module_ref>&',
             const    = True,
538
             default  = 'detail::mod_compute_shape_op'),
Paul's avatar
Paul committed
539
540
541
542
543
544
     virtual('compute',
             returns = 'argument',
             ctx     = 'context&',
             output  = 'const shape&',
             input   = 'const std::vector<argument>&',
             const   = True,
545
             default = 'detail::compute_op'),
Paul's avatar
Paul committed
546
547
548
549
550
     virtual('compute',
             returns = 'argument',
             output  = 'const shape&',
             input   = 'const std::vector<argument>&',
             const   = True,
551
             default = 'detail::compute_op'),
Shucai Xiao's avatar
Shucai Xiao committed
552
553
554
     virtual(
         'compute',
         returns     = 'argument',
Shucai Xiao's avatar
Shucai Xiao committed
555
556
557
558
559
560
561
562
563
564
565
566
         output      = 'const shape&',
         input       = 'const std::vector<argument>&',
         module_args = 'const std::vector<module_ref>&',
         run =
             'std::function<std::vector<argument>(module_ref&, const std::unordered_map<std::string, argument>&)>',
         const   = True,
         default = 'detail::compute_op'),
     virtual(
         'compute',
         returns     = 'argument',
         ctx         = 'context&',
         output      = 'const shape&',
Shucai Xiao's avatar
Shucai Xiao committed
567
568
569
         input       = 'const std::vector<argument>&',
         module_args = 'const std::vector<module_ref>&',
         run =
Shucai Xiao's avatar
Shucai Xiao committed
570
             'std::function<std::vector<argument>(module_ref&, const std::unordered_map<std::string, argument>&)>',
Shucai Xiao's avatar
Shucai Xiao committed
571
572
         const   = True,
         default = 'detail::compute_op'),
573
574
     virtual('to_value', returns = 'value', const = True, default = 'detail::to_value_op'),
     virtual('from_value', v = 'const value&', default = 'detail::from_value_op'),
575
     virtual('attributes', returns = 'value', const = True, default = 'detail::attributes_op'),
Paul's avatar
Paul committed
576
577
578
579
     friend('operator<<',
            returns = 'std::ostream &',
            os      = 'std::ostream &',
            op      = 'const operation &',
580
            using   = 'migraphx::detail::operation_operators::operator<<'),
Paul's avatar
Paul committed
581
582
583
584
     friend('operator==',
            returns = 'bool',
            x       = 'const operation &',
            y       = 'const operation &',
585
            using   = 'migraphx::detail::operation_operators::operator==')) %>
Paul's avatar
Paul committed
586
587

    inline bool operator!=(const operation& x, const operation& y)
Paul's avatar
Paul committed
588
{
589
    return not(x == y);
Paul's avatar
Paul committed
590
591
}

592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
inline value
compile(operation& op, context& ctx, const shape& output_shape, const std::vector<shape>& input)
{
    return op.compile(ctx, output_shape, input);
}
template <class Context>
inline value
compile(operation& op, Context& ctx, const shape& output_shape, const std::vector<shape>& input)
{
    dependent_type<context, Context> ctx2 = std::ref(ctx);
    return compile(op, ctx2, output_shape, input);
}
template <class T, class Context>
inline auto compile(T& op, Context& ctx, const shape& output_shape, const std::vector<shape>& input)
    -> decltype(op.compile(ctx, ctx, output_shape, input))
{
    return op.compile(ctx, ctx, output_shape, input);
}
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
inline shape compute_shape(const operation& op, const std::vector<shape>& inputs)
{
    return op.compute_shape(inputs);
}

template <class T>
inline auto compute_shape(const T& op, const std::vector<shape>& inputs)
    -> decltype(op.compute_shape(inputs))
{
    return op.compute_shape(inputs);
}

template <class T>
inline auto compute_shape(const T& op, const std::vector<shape>& inputs)
    -> decltype(op.normalize_compute_shape(inputs))
{
626
    return detail::compute_shape_op(op, inputs);
627
628
}

Shucai Xiao's avatar
Shucai Xiao committed
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
inline shape compute_shape(const operation& op,
                           const std::vector<shape>& inputs,
                           const std::vector<module_ref>& mod_args)
{
    return op.compute_shape(inputs, mod_args);
}

template <class T>
inline auto compute_shape(const T& op,
                          const std::vector<shape>& inputs,
                          const std::vector<module_ref>& mod_args)
    -> decltype(op.compute_shape(inputs, mod_args))
{
    return op.compute_shape(inputs, mod_args);
}

template <class T>
inline auto compute_shape(const T& op,
                          const std::vector<shape>& inputs,
                          const std::vector<module_ref>& mod_args)
    -> decltype(op.normalize_compute_shape(inputs, mod_args))
{
651
    return detail::compute_shape_op(op, inputs, mod_args);
Shucai Xiao's avatar
Shucai Xiao committed
652
653
}

Paul's avatar
Paul committed
654
inline bool is_context_free(const operation& op) { return op.is_context_free(); }
Paul's avatar
Paul committed
655

Paul's avatar
Paul committed
656
template <class T>
Paul's avatar
Paul committed
657
658
bool is_context_free(const T& x)
{
659
    return detail::is_context_free_op(x);
Paul's avatar
Paul committed
660
661
}

Shucai Xiao's avatar
Shucai Xiao committed
662
663
664
665
666
667
668
669
inline bool need_normalization(const operation& op) { return op.need_normalization(); }

template <class T>
bool need_normalization(const T& x)
{
    return detail::need_normalization_op(x);
}

Paul's avatar
Paul committed
670
671
672
673
674
inline bool has_finalize(const operation& op) { return op.has_finalize(); }

template <class T>
bool has_finalize(const T& x)
{
675
    return detail::has_finalize_op(x);
Paul's avatar
Paul committed
676
677
}

678
679
MIGRAPHX_EXPORT void migraphx_to_value(value& v, const operation& op);
MIGRAPHX_EXPORT void migraphx_from_value(const value& v, operation& op);
680

Paul's avatar
Paul committed
681
682
#endif

Paul's avatar
Paul committed
683
} // namespace MIGRAPHX_INLINE_NS
Paul's avatar
Paul committed
684
} // namespace migraphx
Paul's avatar
Paul committed
685
686

#endif