operation.hpp 23.4 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>
charlie's avatar
charlie committed
35
#include <migraphx/functional.hpp>
Paul's avatar
Paul committed
36
#include <migraphx/streamutils.hpp>
Shucai Xiao's avatar
Shucai Xiao committed
37
#include <migraphx/normalize_attributes.hpp>
Paul's avatar
Paul committed
38
#include <migraphx/argument.hpp>
Shucai Xiao's avatar
Shucai Xiao committed
39
#include <migraphx/module_ref.hpp>
40
#include <migraphx/serialize.hpp>
Paul's avatar
Paul committed
41
#include <migraphx/auto_any_cast.hpp>
42
#include <migraphx/lifetime.hpp>
Paul's avatar
Paul committed
43
#include <migraphx/config.hpp>
Paul's avatar
Paul committed
44

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

Paul's avatar
Paul committed
48
49
struct context;

Paul's avatar
Paul committed
50
51
52
53
54
55
56
57
#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
58
59
    /// An optional method that can be used to finalize the operator before running
    void finalize(context& ctx);
Paul's avatar
Paul committed
60
61
62
    /// 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
63
    shape compute_shape(const std::vector<shape>& input) const;
Paul's avatar
Paul committed
64
    /**
Paul's avatar
Paul committed
65
66
     * @brief This performs the operation's computation.
     *
Paul's avatar
Paul committed
67
68
     * This method can be optional when the operation is only used as a placeholder to be lowered
     * later on.
Paul's avatar
Paul committed
69
70
71
     *
     * @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.
72
73
74
75
     * @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
76
     * @param input This is the `argument` result from the previous instruction's computation.
Paul's avatar
Paul committed
77
78
     * @return Return an `argument` of the result computation. The `shape` of `argument` should be
     * the same the `output` shape.
Paul's avatar
Paul committed
79
     */
Paul's avatar
Paul committed
80
    argument compute(context& ctx, const shape& output, const std::vector<argument>& input) const;
Paul's avatar
Paul committed
81
82
    /// 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
83
    std::ptrdiff_t output_alias(const std::vector<shape>& input) const;
Paul's avatar
Paul committed
84
85
    /// 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
86
    friend std::ostream& operator<<(std::ostream& os, const operation& op);
Paul's avatar
Paul committed
87
88
};

Paul's avatar
Paul committed
89
90
/// 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
91
92
/// Returns true if operation needs normalization before running compute
bool need_normalization(const operation& x);
Paul's avatar
Paul committed
93
94
/// Returns true if the operation has a finalize method
bool has_finalize(const operation& x);
Paul's avatar
Paul committed
95

Paul's avatar
Paul committed
96
97
#else

charlie's avatar
charlie committed
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
struct dyn_output
{
    // original shape from the instruction
    shape ins_shape;
    // shape computed at eval time using input arguments
    shape computed_shape;
};

/**
 * Handle dynamic and static shape at evaluation time.
 * If converted to shape type, returns original ins_shape.
 * If converted to dyn_output type, will compute an output shape using the input arguments.
 */
template <class F>
struct compute_output_shape
{
    F ins_inputs;

    operator dyn_output() const
    {
        return ins_inputs([](const auto& x, shape ins_shape, const std::vector<argument>& inputs) {
119
120
121
            if(ins_shape.dynamic())
                return dyn_output{ins_shape, compute_shape(x, to_shapes(inputs))};
            return dyn_output{ins_shape, ins_shape};
charlie's avatar
charlie committed
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
        });
    }

    operator shape() const
    {
        return ins_inputs(
            [](const auto&, shape ins_shape, const std::vector<argument>&) { return ins_shape; });
    }
};

template <class F>
compute_output_shape<F> make_compute_output_shape(F f)
{
    return {f};
}

138
139
140
namespace detail {

namespace operation_operators {
Paul's avatar
Paul committed
141

Paul's avatar
Paul committed
142
143
template <class T>
auto operator<<(std::ostream& os, const T& x) -> decltype(os << x.name())
Paul's avatar
Paul committed
144
{
Paul's avatar
Paul committed
145
146
    os << x.name();
    char delim = '[';
Paul's avatar
Paul committed
147
    reflect_each(x, [&](auto&& y, auto name) {
Paul's avatar
Paul committed
148
        os << delim;
Paul's avatar
Paul committed
149
150
        os << name << "=";
        stream_write_value(os, y);
Paul's avatar
Paul committed
151
152
        delim = ',';
    });
Paul's avatar
Paul committed
153
154
    if(delim == ',')
        os << "]";
Paul's avatar
Paul committed
155
    return os;
Paul's avatar
Paul committed
156
157
}

Paul's avatar
Paul committed
158
159
160
template <class T, class U>
auto operator==(const T& x, const U& y) -> decltype(x.name() == y.name())
{
Paul's avatar
Paul committed
161
162
    static_assert(is_reflectable<T>{} or sizeof(T) <= 1,
                  "Missing equality operator or reflect method.");
Paul's avatar
Paul committed
163
164
165
166
167
168
    if(x.name() != y.name())
        return false;
    const auto& yy = any_cast<T>(y);
    return reflect_tie(x) == reflect_tie(yy);
}

169
} // namespace operation_operators
Paul's avatar
Paul committed
170

Shucai Xiao's avatar
Shucai Xiao committed
171
template <class T>
172
173
174
175
176
177
178
179
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
180
    -> decltype(x.normalize_compute_shape(inputs))
Shucai Xiao's avatar
Shucai Xiao committed
181
182
{
    dependent_type<operation, T> y = x;
183
    normalize_attributes(y, inputs[0].max_lens());
Shucai Xiao's avatar
Shucai Xiao committed
184
185
186
    return any_cast<T>(y).normalize_compute_shape(inputs);
}

187
template <class T>
188
auto compute_shape_op(rank<1>, const T& x, const std::vector<shape>& inputs)
189
190
191
192
193
    -> decltype(x.compute_shape(inputs, {}))
{
    return x.compute_shape(inputs, {});
}

Shucai Xiao's avatar
Shucai Xiao committed
194
template <class T>
195
shape compute_shape_op(rank<0>, const T& x, const std::vector<shape>&)
Shucai Xiao's avatar
Shucai Xiao committed
196
197
198
199
200
201
{
    std::string name = x.name();
    MIGRAPHX_THROW("Shape not computable: " + name);
}

template <class T>
202
shape compute_shape_op(const T& x, const std::vector<shape>& inputs)
Shucai Xiao's avatar
Shucai Xiao committed
203
{
204
    return compute_shape_op(rank<3>{}, x, inputs);
Shucai Xiao's avatar
Shucai Xiao committed
205
206
207
}

template <class T>
208
209
210
211
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
212
213
214
215
216
217
    -> decltype(x.compute_shape(inputs, mod_args))
{
    return x.compute_shape(inputs, mod_args);
}

template <class T>
218
219
220
221
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
222
{
223
224
    if(mod_args.empty())
        return compute_shape_op(x, inputs);
Shucai Xiao's avatar
Shucai Xiao committed
225
226
227
228
229
    std::string name = x.name();
    MIGRAPHX_THROW("Shape not computable: " + name);
}

template <class T>
230
231
232
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
233
{
234
    return mod_compute_shape_op(rank<1>{}, x, inputs, mod_args);
Shucai Xiao's avatar
Shucai Xiao committed
235
236
}

Paul's avatar
Paul committed
237
template <class T>
Shucai Xiao's avatar
Shucai Xiao committed
238
auto compute_op(rank<1>,
Paul's avatar
Paul committed
239
240
241
242
                const T& x,
                context& ctx,
                const shape& output_shape,
                const std::vector<argument>& input)
charlie's avatar
charlie committed
243
    -> decltype(x.compute(auto_any_cast(ctx),
charlie's avatar
charlie committed
244
                          make_compute_output_shape(pack(x, output_shape, input)),
charlie's avatar
charlie committed
245
                          input))
Paul's avatar
Paul committed
246
{
charlie's avatar
charlie committed
247
248
    return x.compute(
        auto_any_cast(ctx), make_compute_output_shape(pack(x, output_shape, input)), input);
Paul's avatar
Paul committed
249
250
251
}

template <class T>
Paul's avatar
Paul committed
252
argument compute_op(rank<0>, const T& x, context&, const shape&, const std::vector<argument>&)
Paul's avatar
Paul committed
253
{
Paul's avatar
Paul committed
254
    std::string name = x.name();
Paul's avatar
Paul committed
255
    MIGRAPHX_THROW("Not computable: " + name);
Paul's avatar
Paul committed
256
257
}

Paul's avatar
Paul committed
258
template <class T>
Paul's avatar
Paul committed
259
260
argument
compute_op(const T& x, context& ctx, const shape& output_shape, const std::vector<argument>& input)
Paul's avatar
Paul committed
261
{
Shucai Xiao's avatar
Shucai Xiao committed
262
    return compute_op(rank<1>{}, x, ctx, output_shape, input);
Paul's avatar
Paul committed
263
264
265
}

template <class T>
Shucai Xiao's avatar
Shucai Xiao committed
266
auto compute_op(rank<1>, const T& x, const shape& output_shape, const std::vector<argument>& input)
charlie's avatar
charlie committed
267
    -> decltype(x.compute(make_compute_output_shape(pack(x, output_shape, input)), input))
Paul's avatar
Paul committed
268
{
charlie's avatar
charlie committed
269
    return x.compute(make_compute_output_shape(pack(x, output_shape, input)), input);
Paul's avatar
Paul committed
270
271
272
}

template <class T>
Shucai Xiao's avatar
Shucai Xiao committed
273
argument compute_op(rank<0>, const T& x, const shape&, const std::vector<argument>&)
Paul's avatar
Paul committed
274
275
{
    std::string name = x.name();
Shucai Xiao's avatar
Shucai Xiao committed
276
    MIGRAPHX_THROW("Not computable: " + name);
Paul's avatar
Paul committed
277
278
279
}

template <class T>
Shucai Xiao's avatar
Shucai Xiao committed
280
281
282
283
284
285
286
287
288
289
290
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,
charlie's avatar
charlie committed
291
                F f)
charlie's avatar
charlie committed
292
293
    -> decltype(
        x.compute(make_compute_output_shape(pack(x, output, inputs)), inputs, module_args, f))
Shucai Xiao's avatar
Shucai Xiao committed
294
{
charlie's avatar
charlie committed
295
    return x.compute(make_compute_output_shape(pack(x, output, inputs)), inputs, module_args, f);
Shucai Xiao's avatar
Shucai Xiao committed
296
297
298
299
300
301
302
303
304
}

template <class T, class F>
argument compute_op(rank<0>,
                    const T& x,
                    const shape&,
                    const std::vector<argument>&,
                    const std::vector<module_ref>&,
                    F)
Paul's avatar
Paul committed
305
306
307
308
309
{
    std::string name = x.name();
    MIGRAPHX_THROW("Not computable: " + name);
}

Shucai Xiao's avatar
Shucai Xiao committed
310
311
312
313
314
315
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
316
{
Shucai Xiao's avatar
Shucai Xiao committed
317
    return compute_op(rank<1>{}, x, output, inputs, module_args, f);
Paul's avatar
Paul committed
318
319
}

Shucai Xiao's avatar
Shucai Xiao committed
320
321
322
323
324
325
326
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,
charlie's avatar
charlie committed
327
328
329
330
331
                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
332
{
charlie's avatar
charlie committed
333
334
335
336
337
    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
338
339
}

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

template <class T, class F>
Shucai Xiao's avatar
Shucai Xiao committed
355
356
357
358
359
360
auto compute_op(rank<2>,
                const T& x,
                context&,
                const shape& output,
                const std::vector<argument>& inputs,
                const std::vector<module_ref>&,
charlie's avatar
charlie committed
361
362
                F)
    -> decltype(x.compute(make_compute_output_shape(pack(x, output, inputs)), inputs))
Shucai Xiao's avatar
Shucai Xiao committed
363
{
charlie's avatar
charlie committed
364
    return x.compute(make_compute_output_shape(pack(x, output, inputs)), inputs);
Shucai Xiao's avatar
Shucai Xiao committed
365
366
367
368
369
370
371
372
373
}

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>&,
charlie's avatar
charlie committed
374
375
376
                F) -> decltype(x.compute(auto_any_cast(ctx),
                                         make_compute_output_shape(pack(x, output, inputs)),
                                         inputs))
Shucai Xiao's avatar
Shucai Xiao committed
377
{
charlie's avatar
charlie committed
378
379
    return x.compute(
        auto_any_cast(ctx), make_compute_output_shape(pack(x, output, inputs)), inputs);
Shucai Xiao's avatar
Shucai Xiao committed
380
381
382
383
384
385
386
387
388
389
}

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
390
391
392
393
394
395
396
{
    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
397
398
                    context& ctx,
                    const shape& output,
Shucai Xiao's avatar
Shucai Xiao committed
399
400
401
402
                    const std::vector<argument>& inputs,
                    const std::vector<module_ref>& module_args,
                    F f)
{
Shucai Xiao's avatar
Shucai Xiao committed
403
    return compute_op(rank<4>{}, x, ctx, output, inputs, module_args, f);
Shucai Xiao's avatar
Shucai Xiao committed
404
405
}

Paul's avatar
Paul committed
406
template <class T>
Paul's avatar
Paul committed
407
408
409
410
auto is_context_free_op(rank<1>,
                        const T& x,
                        const shape& output_shape,
                        const std::vector<argument>& input)
charlie's avatar
charlie committed
411
412
    -> decltype(x.compute(make_compute_output_shape(pack(x, output_shape, input)), input),
                std::true_type{});
Paul's avatar
Paul committed
413
414

template <class T>
Paul's avatar
Paul committed
415
416
auto is_context_free_op(rank<0>, const T&, const shape&, const std::vector<argument>&)
    -> std::false_type;
Paul's avatar
Paul committed
417
418

template <class T>
Paul's avatar
Paul committed
419
420
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
421
422
{
    return {};
Paul's avatar
Paul committed
423
424
}

Shucai Xiao's avatar
Shucai Xiao committed
425
426
427
428
429
430
431
432
433
434
435
436
437
438
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
439
template <class T>
440
std::ptrdiff_t output_alias_op(const T&, const std::vector<shape>&)
Paul's avatar
Paul committed
441
442
443
444
{
    return -1;
}

Paul's avatar
Paul committed
445
template <class T>
Paul's avatar
Paul committed
446
447
auto finalize_op(
    rank<1>, T& x, context& ctx, const shape& output_shape, const std::vector<shape>& input)
Paul's avatar
Paul committed
448
449
450
451
452
453
454
    -> 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
455
456
{
}
Paul's avatar
Paul committed
457
458
459
460
461
462
463
464

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
465
466
auto has_finalize_op(
    rank<1>, T& x, context& ctx, const shape& output_shape, const std::vector<shape>& input)
Paul's avatar
Paul committed
467
468
469
470
471
472
473
    -> 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
474
475
476
477
478
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
479
480
481
482
{
    return {};
}

483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
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);
}

506
507
508
509
510
511
template <class T>
value attributes_op(const T&)
{
    return value::object{};
}

512
513
514
515
516
517
518
519
520
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)
{
521
522
    if(not(v.is_object() or (v.empty() and v.is_array())))
        MIGRAPHX_THROW("Value is not an object");
523
524
525
    return migraphx::from_value(v, x);
}

526
template <class T>
527
lifetime get_lifetime_op(const T&)
528
{
529
    return lifetime::local;
530
531
}

532
533
} // namespace detail

534
<%
Paul's avatar
Paul committed
535
536
537
 interface(
     'operation',
     virtual('name', returns = 'std::string', const = True),
Paul's avatar
Paul committed
538
539
     virtual(
         'is_context_free', returns = 'bool', const = True, default = 'detail::is_context_free_op'),
Shucai Xiao's avatar
Shucai Xiao committed
540
541
542
543
     virtual('need_normalization',
             returns = 'bool',
             const   = True,
             default = 'detail::need_normalization_op'),
544
     virtual('has_finalize', returns = 'bool', const = True, default = 'detail::has_finalize_op'),
545
546
     virtual(
         'get_lifetime', returns = 'lifetime', const = True, default = 'detail::get_lifetime_op'),
Paul's avatar
Paul committed
547
     virtual('output_alias',
Paul's avatar
Paul committed
548
             returns = 'std::ptrdiff_t',
Paul's avatar
Paul committed
549
550
             input   = 'const std::vector<shape>&',
             const   = True,
551
             default = 'detail::output_alias_op'),
552
553
554
555
556
557
     virtual('compile',
             returns = 'value',
             ctx     = 'context&',
             output  = 'const shape&',
             input   = 'const std::vector<shape>&',
             default = 'detail::compile_op'),
Paul's avatar
Paul committed
558
559
560
561
     virtual('finalize',
             ctx     = 'context&',
             output  = 'const shape&',
             input   = 'const std::vector<shape>&',
562
             default = 'detail::finalize_op'),
Shucai Xiao's avatar
Shucai Xiao committed
563
564
565
566
     virtual('compute_shape',
             returns = 'shape',
             input   = 'const std::vector<shape>&',
             const   = True,
567
             default = 'detail::compute_shape_op'),
Shucai Xiao's avatar
Shucai Xiao committed
568
569
570
571
572
     virtual('compute_shape',
             returns  = 'shape',
             inputs   = 'const std::vector<shape>&',
             mod_args = 'const std::vector<module_ref>&',
             const    = True,
573
             default  = 'detail::mod_compute_shape_op'),
Paul's avatar
Paul committed
574
575
576
577
578
579
     virtual('compute',
             returns = 'argument',
             ctx     = 'context&',
             output  = 'const shape&',
             input   = 'const std::vector<argument>&',
             const   = True,
580
             default = 'detail::compute_op'),
Paul's avatar
Paul committed
581
582
583
584
585
     virtual('compute',
             returns = 'argument',
             output  = 'const shape&',
             input   = 'const std::vector<argument>&',
             const   = True,
586
             default = 'detail::compute_op'),
Shucai Xiao's avatar
Shucai Xiao committed
587
588
589
     virtual(
         'compute',
         returns     = 'argument',
Shucai Xiao's avatar
Shucai Xiao committed
590
591
592
593
594
595
596
597
598
599
600
601
         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
602
603
604
         input       = 'const std::vector<argument>&',
         module_args = 'const std::vector<module_ref>&',
         run =
Shucai Xiao's avatar
Shucai Xiao committed
605
             'std::function<std::vector<argument>(module_ref&, const std::unordered_map<std::string, argument>&)>',
Shucai Xiao's avatar
Shucai Xiao committed
606
607
         const   = True,
         default = 'detail::compute_op'),
608
609
     virtual('to_value', returns = 'value', const = True, default = 'detail::to_value_op'),
     virtual('from_value', v = 'const value&', default = 'detail::from_value_op'),
610
     virtual('attributes', returns = 'value', const = True, default = 'detail::attributes_op'),
Paul's avatar
Paul committed
611
612
613
614
     friend('operator<<',
            returns = 'std::ostream &',
            os      = 'std::ostream &',
            op      = 'const operation &',
615
            using   = 'migraphx::detail::operation_operators::operator<<'),
Paul's avatar
Paul committed
616
617
618
619
     friend('operator==',
            returns = 'bool',
            x       = 'const operation &',
            y       = 'const operation &',
620
            using   = 'migraphx::detail::operation_operators::operator==')) %>
Paul's avatar
Paul committed
621
622

    inline bool operator!=(const operation& x, const operation& y)
Paul's avatar
Paul committed
623
{
624
    return not(x == y);
Paul's avatar
Paul committed
625
626
}

627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
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);
}
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
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))
{
661
    return detail::compute_shape_op(op, inputs);
662
663
}

Shucai Xiao's avatar
Shucai Xiao committed
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
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))
{
686
    return detail::compute_shape_op(op, inputs, mod_args);
Shucai Xiao's avatar
Shucai Xiao committed
687
688
}

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

Paul's avatar
Paul committed
691
template <class T>
Paul's avatar
Paul committed
692
693
bool is_context_free(const T& x)
{
694
    return detail::is_context_free_op(x);
Paul's avatar
Paul committed
695
696
}

Shucai Xiao's avatar
Shucai Xiao committed
697
698
699
700
701
702
703
704
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
705
706
707
708
709
inline bool has_finalize(const operation& op) { return op.has_finalize(); }

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

713
714
715
void migraphx_to_value(value& v, const operation& op);
void migraphx_from_value(const value& v, operation& op);

Paul's avatar
Paul committed
716
717
#endif

Paul's avatar
Paul committed
718
} // namespace MIGRAPHX_INLINE_NS
Paul's avatar
Paul committed
719
} // namespace migraphx
Paul's avatar
Paul committed
720
721

#endif