instruction.cpp 13.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
26
#include <migraphx/instruction.hpp>
#include <migraphx/builtin.hpp>
#include <migraphx/erase.hpp>
Shucai Xiao's avatar
Shucai Xiao committed
27
28
#include <migraphx/module.hpp>
#include <migraphx/ranges.hpp>
Paul's avatar
Paul committed
29

Paul's avatar
Paul committed
30
namespace migraphx {
Paul's avatar
Paul committed
31
inline namespace MIGRAPHX_INLINE_NS {
Paul's avatar
Paul committed
32

33
34
35
36
37
38
template <class T>
auto equal_to(const T& x)
{
    return [&](const T& y) { return std::equal_to<T>{}(x, y); };
}

Paul's avatar
Paul committed
39
40
41
42
instruction::instruction(operation o, shape r, std::vector<instruction_ref> args)
    : op(std::move(o)), result(std::move(r)), arguments(std::move(args))
{
}
Paul's avatar
Paul committed
43

Shucai Xiao's avatar
Shucai Xiao committed
44
45
46
47
48
49
50
51
52
53
54
instruction::instruction(operation o,
                         shape r,
                         std::vector<instruction_ref> args,
                         std::vector<module_ref> modules)
    : op(std::move(o)),
      result(std::move(r)),
      arguments(std::move(args)),
      module_args(std::move(modules))
{
}

Paul's avatar
Paul committed
55
56
57
58
instruction::instruction(literal l)
    : op(builtin::literal{}), result(l.get_shape()), lit(std::move(l))
{
}
Paul's avatar
Paul committed
59

Paul's avatar
Paul committed
60
61
62
void instruction::replace(const shape& r)
{
    if(r != result)
Paul's avatar
Paul committed
63
    {
Paul's avatar
Paul committed
64
65
        result = r;
        for(auto&& ins : output)
Paul's avatar
Paul committed
66
        {
67
68
69
            if(ins->name() == "@return")
                continue;

Paul's avatar
Paul committed
70
71
            assert(ins->name().front() != '@');
            ins->recompute_shape();
Paul's avatar
Paul committed
72
73
        }
    }
Paul's avatar
Paul committed
74
}
Paul's avatar
Paul committed
75

Paul's avatar
Paul committed
76
void instruction::replace(operation o)
Paul's avatar
Paul committed
77
{
78
79
    normalized = false;
    op         = std::move(o);
Paul's avatar
Paul committed
80
81
82
    recompute_shape();
}

Shucai Xiao's avatar
Shucai Xiao committed
83
void instruction::recompute_shape() { replace(compute_shape(op, arguments, module_args)); }
Paul's avatar
Paul committed
84

Paul's avatar
Paul committed
85
86
87
void instruction::clear_arguments()
{
    for(auto&& arg : arguments)
Paul's avatar
Paul committed
88
    {
Paul's avatar
Paul committed
89
        arg->remove_output(*this);
Paul's avatar
Paul committed
90
    }
Paul's avatar
Paul committed
91
    arguments.clear();
Shucai Xiao's avatar
Shucai Xiao committed
92
    module_args.clear();
Paul's avatar
Paul committed
93
94
95
96
97
98
}

bool operator==(const instruction& i, instruction_ref ref)
{
    return std::addressof(i) == std::addressof(*ref);
}
Paul's avatar
Paul committed
99

Shucai Xiao's avatar
Shucai Xiao committed
100
bool instruction::valid(instruction_ref start, bool check_order) const
Paul's avatar
Paul committed
101
102
103
{
    return valid() && std::all_of(arguments.begin(), arguments.end(), [&](instruction_ref i) {
               auto self = std::find(i->outputs().begin(), i->outputs().end(), *this);
Shucai Xiao's avatar
Shucai Xiao committed
104
105
106
               bool ret  = self != i->outputs().end();
               if(check_order)
               {
107
                   // check arguments for this instruction before this instruction
Shucai Xiao's avatar
Shucai Xiao committed
108
109
110
                   ret = ret and (std::distance(start, i) < std::distance(start, *self));
               }
               return ret;
Paul's avatar
Paul committed
111
112
113
114
115
116
117
           });
}

bool instruction::valid() const
{
    shape computed;
    if(op.name() == "@literal")
Paul's avatar
Paul committed
118
    {
Paul's avatar
Paul committed
119
        computed = lit.get_shape();
Paul's avatar
Paul committed
120
    }
Paul's avatar
Paul committed
121
    else if(op.name() == "@param")
Paul's avatar
Paul committed
122
    {
Paul's avatar
Paul committed
123
        computed = result;
Paul's avatar
Paul committed
124
    }
125
126
127
128
    else if(op.name() == "@return")
    {
        computed = {};
    }
Paul's avatar
Paul committed
129
    else
Paul's avatar
Paul committed
130
    {
Paul's avatar
Paul committed
131
        try
Paul's avatar
Paul committed
132
        {
Shucai Xiao's avatar
Shucai Xiao committed
133
            computed = compute_shape(op, arguments, module_args);
Paul's avatar
Paul committed
134
        }
Paul's avatar
Paul committed
135
        catch(migraphx::exception&)
Paul's avatar
Paul committed
136
        {
Paul's avatar
Paul committed
137
            return false;
Paul's avatar
Paul committed
138
139
        }
    }
140

Shucai Xiao's avatar
Shucai Xiao committed
141
142
    return (result == computed) &&
           std::all_of(output.begin(), output.end(), [&](instruction_ref i) {
Paul's avatar
Paul committed
143
144
145
               return std::find(i->inputs().begin(), i->inputs().end(), *this) != i->inputs().end();
           });
}
Paul's avatar
Paul committed
146

Paul's avatar
Paul committed
147
148
149
150
151
152
shape instruction::get_shape() const { return result; }
const literal& instruction::get_literal() const
{
    assert(op.name() == "@literal");
    return lit;
}
Paul's avatar
Paul committed
153

Paul's avatar
Paul committed
154
const operation& instruction::get_operator() const { return op; }
Paul's avatar
Paul committed
155

Paul's avatar
Paul committed
156
std::string instruction::name() const { return op.name(); }
Paul's avatar
Paul committed
157

Paul's avatar
Paul committed
158
const std::vector<instruction_ref>& instruction::inputs() const { return arguments; }
Paul's avatar
Paul committed
159

Shucai Xiao's avatar
Shucai Xiao committed
160
161
const std::vector<module_ref>& instruction::module_inputs() const { return module_args; }

Paul's avatar
Paul committed
162
const std::vector<instruction_ref>& instruction::outputs() const { return output; }
Paul's avatar
Paul committed
163

Paul's avatar
Paul committed
164
165
bool operator==(const instruction& x, const instruction& y)
{
166
167
168
169
170
171
172
    if(not std::equal(x.arguments.begin(),
                      x.arguments.end(),
                      y.arguments.begin(),
                      y.arguments.end(),
                      std::equal_to<instruction_ref>{}))
        return false;
    if(std::tie(x.result, x.op, x.module_args) != std::tie(y.result, y.op, y.module_args))
Paul's avatar
Paul committed
173
174
175
176
177
        return false;
    if(x.name() == "@literal")
        return x.lit == y.lit;
    return true;
}
Paul's avatar
Paul committed
178

Paul's avatar
Paul committed
179
180
bool operator!=(const instruction& x, const instruction& y) { return !(x == y); }

Paul's avatar
Paul committed
181
bool operator==(instruction_ref ref, const instruction& i) { return i == ref; }
Paul's avatar
Paul committed
182

Paul's avatar
Paul committed
183
bool operator!=(const instruction& i, instruction_ref ref) { return !(i == ref); }
Paul's avatar
Paul committed
184

Paul's avatar
Paul committed
185
bool operator!=(instruction_ref ref, const instruction& i) { return !(i == ref); }
Paul's avatar
Paul committed
186

Paul's avatar
Paul committed
187
188
void instruction::add_output(instruction_ref ins)
{
189
    if(std::find_if(output.begin(), output.end(), equal_to(ins)) == output.end())
Paul's avatar
Paul committed
190
191
        output.push_back(ins);
}
Paul's avatar
Paul committed
192

Paul's avatar
Paul committed
193
194
195
196
197
void instruction::backreference(instruction_ref ref)
{
    for(auto&& arg : ref->inputs())
        arg->add_output(ref);
}
Paul's avatar
Paul committed
198

Paul's avatar
Paul committed
199
200
201
202
203
204
205
206
void instruction::replace_argument(instruction_ref ins,
                                   instruction_ref old,
                                   instruction_ref new_ins)
{
    ins->replace_argument(old, new_ins);
    backreference(ins);
    ins->recompute_shape();
}
Paul's avatar
Paul committed
207

Shucai Xiao's avatar
Shucai Xiao committed
208
209
210
211
212
213
214
void instruction::replace_mod_argument(instruction_ref ins, module_ref old, module_ref new_mod)
{
    ins->replace_mod_argument(old, new_mod);
    backreference(ins);
    ins->recompute_shape();
}

Paul's avatar
Paul committed
215
216
217
218
219
220
221
222
void instruction::replace(instruction_ref ins,
                          operation o,
                          const shape& r,
                          std::vector<instruction_ref> args)
{
    ins->replace(std::move(o), r, std::move(args));
    backreference(ins);
}
Paul's avatar
Paul committed
223

Shucai Xiao's avatar
Shucai Xiao committed
224
225
226
227
228
229
230
231
232
233
void instruction::replace(instruction_ref ins,
                          operation o,
                          const shape& r,
                          std::vector<instruction_ref> args,
                          std::vector<module_ref> module_args)
{
    ins->replace(std::move(o), r, std::move(args), std::move(module_args));
    backreference(ins);
}

Paul's avatar
Paul committed
234
235
void instruction::replace(operation o, const shape& r, std::vector<instruction_ref> args)
{
236
237
    normalized = false;
    op         = std::move(o);
Paul's avatar
Paul committed
238
239
240
    replace(r);
    replace(std::move(args));
}
Paul's avatar
Paul committed
241

Shucai Xiao's avatar
Shucai Xiao committed
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
void instruction::replace(operation o,
                          const shape& r,
                          std::vector<instruction_ref> args,
                          std::vector<module_ref> mdl_args)
{
    op = std::move(o);
    replace(r);
    replace(std::move(args), std::move(mdl_args));
}

void instruction::replace_refs(
    instruction_ref ins,
    const std::unordered_map<instruction_ref, instruction_ref>& map_insts,
    const std::unordered_map<module_ref, module_ref>& map_mods)
{
    const auto& args = ins->inputs();
    for(const auto& arg : args)
    {
        if(contains(map_insts, arg))
        {
            instruction::replace_argument(ins, arg, map_insts.at(arg));
        }
    }

    const auto& module_args = ins->module_inputs();
    if(module_args.empty())
        return;

    for(const auto& mod : module_args)
    {
        if(contains(map_mods, mod))
        {
            instruction::replace_mod_argument(ins, mod, map_mods.at(mod));
        }
    }
}

Paul's avatar
Paul committed
279
280
281
282
283
void instruction::replace(std::vector<instruction_ref> args)
{
    clear_arguments();
    arguments = std::move(args);
}
Paul's avatar
Paul committed
284

Shucai Xiao's avatar
Shucai Xiao committed
285
286
287
288
289
290
291
void instruction::replace(std::vector<instruction_ref> args, std::vector<module_ref> mdl_args)
{
    clear_arguments();
    arguments   = std::move(args);
    module_args = std::move(mdl_args);
}

Paul's avatar
Paul committed
292
293
void instruction::replace_argument(instruction_ref old, instruction_ref new_ins)
{
294
295
    assert(std::any_of(arguments.begin(), arguments.end(), equal_to(old)));
    std::replace_if(arguments.begin(), arguments.end(), equal_to(old), new_ins);
Paul's avatar
Paul committed
296
297
    old->remove_output(*this);
}
Paul's avatar
Paul committed
298

Shucai Xiao's avatar
Shucai Xiao committed
299
300
301
302
303
304
void instruction::replace_mod_argument(module_ref old, module_ref new_mod)
{
    assert(std::any_of(module_args.begin(), module_args.end(), [&](auto i) { return i == old; }));
    std::replace(module_args.begin(), module_args.end(), old, new_mod);
}

Paul's avatar
Paul committed
305
306
307
308
309
310
bool instruction::can_eval() const
{
    if(op.name() == "@literal")
    {
        return true;
    }
Paul's avatar
Paul committed
311
    else if(is_context_free(op))
Paul's avatar
Paul committed
312
    {
Paul's avatar
Paul committed
313
314
        return std::all_of(
            this->inputs().begin(), this->inputs().end(), [](auto arg) { return arg->can_eval(); });
Paul's avatar
Paul committed
315
316
317
318
319
320
321
    }
    else
    {
        return false;
    }
}

Paul's avatar
Paul committed
322
argument instruction::eval(bool check_eval) const
Paul's avatar
Paul committed
323
324
325
326
327
{
    if(op.name() == "@literal")
    {
        return this->get_literal().get_argument();
    }
Paul's avatar
Paul committed
328
    if(is_context_free(op))
Paul's avatar
Paul committed
329
    {
Paul's avatar
Paul committed
330
        if(check_eval and not this->can_eval())
Paul's avatar
Paul committed
331
            return {};
Paul's avatar
Paul committed
332
        std::vector<argument> args;
Paul's avatar
Paul committed
333
334
335
        std::transform(this->inputs().begin(),
                       this->inputs().end(),
                       std::back_inserter(args),
Paul's avatar
Paul committed
336
                       [](auto arg) { return arg->eval(false); });
337
        return normalized_operator().compute(result, args);
Paul's avatar
Paul committed
338
339
340
341
    }
    return {};
}

Paul's avatar
Paul committed
342
343
void instruction::finalize(context& ctx)
{
Paul's avatar
Paul committed
344
    if(has_finalize(this->op))
Paul's avatar
Paul committed
345
346
347
        this->op.finalize(ctx, this->get_shape(), to_shapes(this->inputs()));
}

348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
void instruction::print(std::ostream& os,
                        instruction_ref ins,
                        const std::unordered_map<instruction_ref, std::string>& names)
{
    os << names.at(ins) << " = ";

    os << ins->get_operator();

    if(ins->name() == "@literal")
    {
        if(ins->get_literal().get_shape().elements() > 10)
            os << "{ ... }";
        else
            os << "{" << ins->get_literal() << "}";
    }

    if(!ins->inputs().empty())
    {
        char delim = '(';
        for(auto&& arg : ins->inputs())
        {
Shucai Xiao's avatar
Shucai Xiao committed
369
370
            std::string arg_name = contains(names, arg) ? names.at(arg) : "?";
            os << delim << arg_name;
371
372
373
374
375
            delim = ',';
        }
        os << ")";
    }

Shucai Xiao's avatar
Shucai Xiao committed
376
377
378
379
380
381
382
383
384
385
386
387
    // print module inputs
    if(!ins->module_inputs().empty())
    {
        std::string delim = ", [";
        for(auto&& mod_arg : ins->module_inputs())
        {
            os << delim << mod_arg->name();
            delim = ", ";
        }
        os << "]";
    }

388
389
390
391
392
    // skip return instruction shape
    if(ins->name() != "@return")
        os << " -> " << ins->get_shape();
}

Paul Fultz II's avatar
Paul Fultz II committed
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
static void debug_name(std::ostream& os, const instruction& ins)
{
    if(ins.name() == "@literal")
    {
        os << "@literal";
        if(ins.get_literal().get_shape().elements() > 10)
            os << "{ ... }";
        else
            os << "{" << ins.get_literal() << "}";
    }
    else
    {
        os << ins.get_operator();
    }
}

void instruction::debug_print() const
{
    debug_name(std::cout, *this);
    std::string delim = "(";
    for(auto arg : this->inputs())
    {
        std::cout << delim;
        debug_name(std::cout, *arg);
        delim = ", ";
    }
    if(not this->inputs().empty())
        std::cout << ")";
    std::cout << " -> " << this->get_shape() << std::endl;
}

Paul's avatar
Paul committed
424
instruction_ref instruction::get_output_alias(instruction_ref ins, bool shallow)
Paul's avatar
Paul committed
425
{
Paul's avatar
Paul committed
426
    auto i = ins->get_operator().output_alias(to_shapes(ins->inputs()));
Paul's avatar
Paul committed
427
428
    if(i < 0)
        return ins;
Paul's avatar
Paul committed
429
    if(shallow)
Paul's avatar
Paul committed
430
        return ins->inputs().at(i);
Paul's avatar
Paul committed
431
432
433
    return get_output_alias(ins->inputs().at(i));
}

434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
void instruction::set_normalized(bool value) { normalized = value; }

bool instruction::is_normalized() const { return normalized; }

bool instruction::need_normalization() const
{
    return this->get_operator().need_normalization() and not normalized;
}

operation instruction::normalized_operator() const
{
    operation o = this->get_operator();
    if(this->need_normalization())
    {
        auto lens = this->inputs().front()->get_shape().lens();
        if(!normalize_attributes(o, lens))
            return this->get_operator();
    }
    return o;
}

Paul's avatar
Paul committed
455
456
457
458
459
460
461
462
std::vector<shape> to_shapes(const std::vector<instruction_ref>& args)
{
    std::vector<shape> shapes(args.size());
    std::transform(
        args.begin(), args.end(), shapes.begin(), [](instruction_ref i) { return i->get_shape(); });
    return shapes;
}

Paul's avatar
Paul committed
463
464
shape compute_shape(const operation& op, const std::vector<instruction_ref>& args)
{
Paul's avatar
Paul committed
465
    return op.compute_shape(to_shapes(args));
Paul's avatar
Paul committed
466
467
}

Shucai Xiao's avatar
Shucai Xiao committed
468
469
470
471
472
473
474
475
476
477
478
479
480
shape compute_shape(const operation& op,
                    const std::vector<instruction_ref>& args,
                    const std::vector<module_ref>& mods)
{
    if(mods.empty())
    {
        return op.compute_shape(to_shapes(args));
    }
    else
    {
        return op.compute_shape(to_shapes(args), mods);
    }
}
481
482
483
484
485
486
487
488
489
490
491
492
493
494

std::vector<shape> try_compute_shape(const operation& op, const std::vector<shape>& inputs)
{
    shape new_shape;
    try
    {
        new_shape = op.compute_shape(inputs);
    }
    catch(...)
    {
        return {};
    }
    return {new_shape};
}
495
496
497
498
499
500

migraphx::instruction* as_address(const instruction_ref& ins) noexcept
{
    return std::addressof(*ins);
}

Paul's avatar
Paul committed
501
} // namespace MIGRAPHX_INLINE_NS
Paul's avatar
Paul committed
502
} // namespace migraphx