operation.hpp 23.3 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/dyn_output.hpp>
charlie's avatar
charlie committed
36
#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

charlie's avatar
charlie committed
99
100
101
102
103
104
105
106
107
108
109
110
111
/**
 * 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) {
112
113
114
            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
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
        });
    }

    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};
}

131
132
133
namespace detail {

namespace operation_operators {
Paul's avatar
Paul committed
134

Paul's avatar
Paul committed
135
136
template <class T>
auto operator<<(std::ostream& os, const T& x) -> decltype(os << x.name())
Paul's avatar
Paul committed
137
{
Paul's avatar
Paul committed
138
139
    os << x.name();
    char delim = '[';
Paul's avatar
Paul committed
140
    reflect_each(x, [&](auto&& y, auto name) {
Paul's avatar
Paul committed
141
        os << delim;
Paul's avatar
Paul committed
142
143
        os << name << "=";
        stream_write_value(os, y);
Paul's avatar
Paul committed
144
145
        delim = ',';
    });
Paul's avatar
Paul committed
146
147
    if(delim == ',')
        os << "]";
Paul's avatar
Paul committed
148
    return os;
Paul's avatar
Paul committed
149
150
}

Paul's avatar
Paul committed
151
152
153
template <class T, class U>
auto operator==(const T& x, const U& y) -> decltype(x.name() == y.name())
{
Paul's avatar
Paul committed
154
155
    static_assert(is_reflectable<T>{} or sizeof(T) <= 1,
                  "Missing equality operator or reflect method.");
Paul's avatar
Paul committed
156
157
158
159
160
161
    if(x.name() != y.name())
        return false;
    const auto& yy = any_cast<T>(y);
    return reflect_tie(x) == reflect_tie(yy);
}

162
} // namespace operation_operators
Paul's avatar
Paul committed
163

Shucai Xiao's avatar
Shucai Xiao committed
164
template <class T>
165
166
167
168
169
170
171
172
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
173
    -> decltype(x.normalize_compute_shape(inputs))
Shucai Xiao's avatar
Shucai Xiao committed
174
175
{
    dependent_type<operation, T> y = x;
176
    normalize_attributes(y, inputs[0].max_lens());
Shucai Xiao's avatar
Shucai Xiao committed
177
178
179
    return any_cast<T>(y).normalize_compute_shape(inputs);
}

180
template <class T>
181
auto compute_shape_op(rank<1>, const T& x, const std::vector<shape>& inputs)
182
183
184
185
186
    -> decltype(x.compute_shape(inputs, {}))
{
    return x.compute_shape(inputs, {});
}

Shucai Xiao's avatar
Shucai Xiao committed
187
template <class T>
188
shape compute_shape_op(rank<0>, const T& x, const std::vector<shape>&)
Shucai Xiao's avatar
Shucai Xiao committed
189
190
191
192
193
194
{
    std::string name = x.name();
    MIGRAPHX_THROW("Shape not computable: " + name);
}

template <class T>
195
shape compute_shape_op(const T& x, const std::vector<shape>& inputs)
Shucai Xiao's avatar
Shucai Xiao committed
196
{
197
    return compute_shape_op(rank<3>{}, x, inputs);
Shucai Xiao's avatar
Shucai Xiao committed
198
199
200
}

template <class T>
201
202
203
204
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
205
206
207
208
209
210
    -> decltype(x.compute_shape(inputs, mod_args))
{
    return x.compute_shape(inputs, mod_args);
}

template <class T>
211
212
213
214
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
215
{
216
217
    if(mod_args.empty())
        return compute_shape_op(x, inputs);
Shucai Xiao's avatar
Shucai Xiao committed
218
219
220
221
222
    std::string name = x.name();
    MIGRAPHX_THROW("Shape not computable: " + name);
}

template <class T>
223
224
225
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
226
{
227
    return mod_compute_shape_op(rank<1>{}, x, inputs, mod_args);
Shucai Xiao's avatar
Shucai Xiao committed
228
229
}

Paul's avatar
Paul committed
230
template <class T>
Shucai Xiao's avatar
Shucai Xiao committed
231
auto compute_op(rank<1>,
Paul's avatar
Paul committed
232
233
234
235
                const T& x,
                context& ctx,
                const shape& output_shape,
                const std::vector<argument>& input)
charlie's avatar
charlie committed
236
    -> decltype(x.compute(auto_any_cast(ctx),
charlie's avatar
charlie committed
237
                          make_compute_output_shape(pack(x, output_shape, input)),
charlie's avatar
charlie committed
238
                          input))
Paul's avatar
Paul committed
239
{
charlie's avatar
charlie committed
240
241
    return x.compute(
        auto_any_cast(ctx), make_compute_output_shape(pack(x, output_shape, input)), input);
Paul's avatar
Paul committed
242
243
244
}

template <class T>
Paul's avatar
Paul committed
245
argument compute_op(rank<0>, const T& x, context&, const shape&, const std::vector<argument>&)
Paul's avatar
Paul committed
246
{
Paul's avatar
Paul committed
247
    std::string name = x.name();
Paul's avatar
Paul committed
248
    MIGRAPHX_THROW("Not computable: " + name);
Paul's avatar
Paul committed
249
250
}

Paul's avatar
Paul committed
251
template <class T>
Paul's avatar
Paul committed
252
253
argument
compute_op(const T& x, context& ctx, const shape& output_shape, const std::vector<argument>& input)
Paul's avatar
Paul committed
254
{
Shucai Xiao's avatar
Shucai Xiao committed
255
    return compute_op(rank<1>{}, x, ctx, output_shape, input);
Paul's avatar
Paul committed
256
257
258
}

template <class T>
Shucai Xiao's avatar
Shucai Xiao committed
259
auto compute_op(rank<1>, const T& x, const shape& output_shape, const std::vector<argument>& input)
charlie's avatar
charlie committed
260
    -> decltype(x.compute(make_compute_output_shape(pack(x, output_shape, input)), input))
Paul's avatar
Paul committed
261
{
charlie's avatar
charlie committed
262
    return x.compute(make_compute_output_shape(pack(x, output_shape, input)), input);
Paul's avatar
Paul committed
263
264
265
}

template <class T>
Shucai Xiao's avatar
Shucai Xiao committed
266
argument compute_op(rank<0>, const T& x, const shape&, const std::vector<argument>&)
Paul's avatar
Paul committed
267
268
{
    std::string name = x.name();
Shucai Xiao's avatar
Shucai Xiao committed
269
    MIGRAPHX_THROW("Not computable: " + name);
Paul's avatar
Paul committed
270
271
272
}

template <class T>
Shucai Xiao's avatar
Shucai Xiao committed
273
274
275
276
277
278
279
280
281
282
283
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
284
                F f)
charlie's avatar
charlie committed
285
286
    -> decltype(
        x.compute(make_compute_output_shape(pack(x, output, inputs)), inputs, module_args, f))
Shucai Xiao's avatar
Shucai Xiao committed
287
{
charlie's avatar
charlie committed
288
    return x.compute(make_compute_output_shape(pack(x, output, inputs)), inputs, module_args, f);
Shucai Xiao's avatar
Shucai Xiao committed
289
290
291
292
293
294
295
296
297
}

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
298
299
300
301
302
{
    std::string name = x.name();
    MIGRAPHX_THROW("Not computable: " + name);
}

Shucai Xiao's avatar
Shucai Xiao committed
303
304
305
306
307
308
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
309
{
Shucai Xiao's avatar
Shucai Xiao committed
310
    return compute_op(rank<1>{}, x, output, inputs, module_args, f);
Paul's avatar
Paul committed
311
312
}

Shucai Xiao's avatar
Shucai Xiao committed
313
314
315
316
317
318
319
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
320
321
322
323
324
                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
325
{
charlie's avatar
charlie committed
326
327
328
329
330
    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
331
332
}

Shucai Xiao's avatar
Shucai Xiao committed
333
template <class T, class F>
Shucai Xiao's avatar
Shucai Xiao committed
334
auto compute_op(rank<3>,
Shucai Xiao's avatar
Shucai Xiao committed
335
                const T& x,
Shucai Xiao's avatar
Shucai Xiao committed
336
337
                context&,
                const shape& output,
Shucai Xiao's avatar
Shucai Xiao committed
338
339
                const std::vector<argument>& inputs,
                const std::vector<module_ref>& module_args,
charlie's avatar
charlie committed
340
                F f)
charlie's avatar
charlie committed
341
342
    -> decltype(
        x.compute(make_compute_output_shape(pack(x, output, inputs)), inputs, module_args, f))
Shucai Xiao's avatar
Shucai Xiao committed
343
{
charlie's avatar
charlie committed
344
    return x.compute(make_compute_output_shape(pack(x, output, inputs)), inputs, module_args, f);
Shucai Xiao's avatar
Shucai Xiao committed
345
346
347
}

template <class T, class F>
Shucai Xiao's avatar
Shucai Xiao committed
348
349
350
351
352
353
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
354
355
                F)
    -> decltype(x.compute(make_compute_output_shape(pack(x, output, inputs)), inputs))
Shucai Xiao's avatar
Shucai Xiao committed
356
{
charlie's avatar
charlie committed
357
    return x.compute(make_compute_output_shape(pack(x, output, inputs)), inputs);
Shucai Xiao's avatar
Shucai Xiao committed
358
359
360
361
362
363
364
365
366
}

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
367
368
369
                F) -> decltype(x.compute(auto_any_cast(ctx),
                                         make_compute_output_shape(pack(x, output, inputs)),
                                         inputs))
Shucai Xiao's avatar
Shucai Xiao committed
370
{
charlie's avatar
charlie committed
371
372
    return x.compute(
        auto_any_cast(ctx), make_compute_output_shape(pack(x, output, inputs)), inputs);
Shucai Xiao's avatar
Shucai Xiao committed
373
374
375
376
377
378
379
380
381
382
}

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
383
384
385
386
387
388
389
{
    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
390
391
                    context& ctx,
                    const shape& output,
Shucai Xiao's avatar
Shucai Xiao committed
392
393
394
395
                    const std::vector<argument>& inputs,
                    const std::vector<module_ref>& module_args,
                    F f)
{
Shucai Xiao's avatar
Shucai Xiao committed
396
    return compute_op(rank<4>{}, x, ctx, output, inputs, module_args, f);
Shucai Xiao's avatar
Shucai Xiao committed
397
398
}

Paul's avatar
Paul committed
399
template <class T>
Paul's avatar
Paul committed
400
401
402
403
auto is_context_free_op(rank<1>,
                        const T& x,
                        const shape& output_shape,
                        const std::vector<argument>& input)
charlie's avatar
charlie committed
404
405
    -> decltype(x.compute(make_compute_output_shape(pack(x, output_shape, input)), input),
                std::true_type{});
Paul's avatar
Paul committed
406
407

template <class T>
Paul's avatar
Paul committed
408
409
auto is_context_free_op(rank<0>, const T&, const shape&, const std::vector<argument>&)
    -> std::false_type;
Paul's avatar
Paul committed
410
411

template <class T>
Paul's avatar
Paul committed
412
413
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
414
415
{
    return {};
Paul's avatar
Paul committed
416
417
}

Shucai Xiao's avatar
Shucai Xiao committed
418
419
420
421
422
423
424
425
426
427
428
429
430
431
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
432
template <class T>
433
std::ptrdiff_t output_alias_op(const T&, const std::vector<shape>&)
Paul's avatar
Paul committed
434
435
436
437
{
    return -1;
}

Paul's avatar
Paul committed
438
template <class T>
Paul's avatar
Paul committed
439
440
auto finalize_op(
    rank<1>, T& x, context& ctx, const shape& output_shape, const std::vector<shape>& input)
Paul's avatar
Paul committed
441
442
443
444
445
446
447
    -> 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
448
449
{
}
Paul's avatar
Paul committed
450
451
452
453
454
455
456
457

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
458
459
auto has_finalize_op(
    rank<1>, T& x, context& ctx, const shape& output_shape, const std::vector<shape>& input)
Paul's avatar
Paul committed
460
461
462
463
464
465
466
    -> 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
467
468
469
470
471
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
472
473
474
475
{
    return {};
}

476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
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);
}

499
500
501
502
503
504
template <class T>
value attributes_op(const T&)
{
    return value::object{};
}

505
506
507
508
509
510
511
512
513
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)
{
514
515
    if(not(v.is_object() or (v.empty() and v.is_array())))
        MIGRAPHX_THROW("Value is not an object");
516
517
518
    return migraphx::from_value(v, x);
}

519
template <class T>
520
lifetime get_lifetime_op(const T&)
521
{
522
    return lifetime::local;
523
524
}

525
526
} // namespace detail

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

    inline bool operator!=(const operation& x, const operation& y)
Paul's avatar
Paul committed
616
{
617
    return not(x == y);
Paul's avatar
Paul committed
618
619
}

620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
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);
}
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
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))
{
654
    return detail::compute_shape_op(op, inputs);
655
656
}

Shucai Xiao's avatar
Shucai Xiao committed
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
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))
{
679
    return detail::compute_shape_op(op, inputs, mod_args);
Shucai Xiao's avatar
Shucai Xiao committed
680
681
}

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

Paul's avatar
Paul committed
684
template <class T>
Paul's avatar
Paul committed
685
686
bool is_context_free(const T& x)
{
687
    return detail::is_context_free_op(x);
Paul's avatar
Paul committed
688
689
}

Shucai Xiao's avatar
Shucai Xiao committed
690
691
692
693
694
695
696
697
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
698
699
700
701
702
inline bool has_finalize(const operation& op) { return op.has_finalize(); }

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

706
707
708
void migraphx_to_value(value& v, const operation& op);
void migraphx_from_value(const value& v, operation& op);

Paul's avatar
Paul committed
709
710
#endif

Paul's avatar
Paul committed
711
} // namespace MIGRAPHX_INLINE_NS
Paul's avatar
Paul committed
712
} // namespace migraphx
Paul's avatar
Paul committed
713
714

#endif