module.cpp 27.1 KB
Newer Older
1
#include <iterator>
Shucai Xiao's avatar
Shucai Xiao committed
2
3
4
5
6
7
8
9
#include <migraphx/module.hpp>
#include <migraphx/stringutils.hpp>
#include <migraphx/instruction.hpp>
#include <migraphx/target.hpp>
#include <migraphx/env.hpp>
#include <migraphx/ranges.hpp>
#include <migraphx/time.hpp>
#include <migraphx/iterator_for.hpp>
10
#include <migraphx/iterator.hpp>
Shucai Xiao's avatar
Shucai Xiao committed
11
12
13
14
#include <migraphx/pass_manager.hpp>
#include <migraphx/make_op.hpp>
#include <migraphx/register_target.hpp>
#include <migraphx/make_op.hpp>
Paul's avatar
Paul committed
15
#include <migraphx/json.hpp>
Shucai Xiao's avatar
Shucai Xiao committed
16
17
18
19
20
21
22
23
24
25
#include <iostream>
#include <sstream>
#include <algorithm>
#include <set>
#include <utility>
#include <unordered_set>

namespace migraphx {
inline namespace MIGRAPHX_INLINE_NS {

Paul Fultz II's avatar
Paul Fultz II committed
26
27
MIGRAPHX_DECLARE_ENV_VAR(MIGRAPHX_TRACE_FINALIZE)

Shucai Xiao's avatar
Shucai Xiao committed
28
29
30
31
struct module_impl
{
    // A list is used to keep references to an instruction stable
    std::list<instruction> instructions;
32
    std::unordered_set<instruction*> instruction_set;
Paul Fultz II's avatar
Paul Fultz II committed
33
    std::string name;
Paul Fultz II's avatar
Paul Fultz II committed
34
    uint32_t nparams = 0;
35
    bool bypass      = false;
36
37
38

    bool contains(instruction_ref ins) const
    {
39
        if(is_end(ins, instructions.end()))
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
            return false;
        return instruction_set.count(std::addressof(*ins)) > 0;
    }

    template <class... Ts>
    instruction_ref emplace(instruction_ref pos, Ts&&... xs)
    {
        // cppcheck-suppress redundantInitialization
        auto r = instructions.emplace(pos, std::forward<Ts>(xs)...);
        instruction_set.insert(std::addressof(*r));
        return r;
    }
    instruction_ref insert(instruction_ref pos, const instruction& ins)
    {
        return emplace(pos, ins);
    }

57
58
59
60
61
62
63
    void clear()
    {
        instructions.clear();
        instruction_set.clear();
        nparams = 0;
    }

64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
    void push_front(const instruction& ins) { insert(instructions.begin(), ins); }

    void push_back(const instruction& ins) { insert(instructions.end(), ins); }

    template <class... Ts>
    void emplace_front(Ts&&... xs)
    {
        emplace(instructions.begin(), std::forward<Ts>(xs)...);
    }

    template <class... Ts>
    void emplace_back(Ts&&... xs)
    {
        emplace(instructions.end(), std::forward<Ts>(xs)...);
    }

    instruction_ref erase(instruction_ref pos)
    {
        instruction_set.erase(std::addressof(*pos));
        return instructions.erase(pos);
    }

    instruction_ref erase(instruction_ref start, instruction_ref last)
    {
        std::for_each(start, last, [&](auto& ins) { instruction_set.erase(std::addressof(ins)); });
        return instructions.erase(start, last);
    }
Shucai Xiao's avatar
Shucai Xiao committed
91
92
93
94
};

const operation& get_operation(instruction_ref ins) { return ins->get_operator(); }

Paul Fultz II's avatar
Paul Fultz II committed
95
96
97
98
module::module(const std::string& name) : impl(std::make_unique<module_impl>())
{
    impl->name = name;
}
Shucai Xiao's avatar
Shucai Xiao committed
99
100
101
102
103
104
105
106
107
108
109
110
111
112

module::module(module&&) noexcept = default;
module::~module() noexcept        = default;

// copy constructor
module::module(const module& m) { assign(m); }

// copy assignment operator
module& module::operator=(module m)
{
    std::swap(m.impl, this->impl);
    return *this;
}

Paul Fultz II's avatar
Paul Fultz II committed
113
114
std::string module::name() const { return impl->name; }

115
116
117
bool module::bypass() const { return impl->bypass; }
void module::set_bypass(bool b) { impl->bypass = b; }

Shucai Xiao's avatar
Shucai Xiao committed
118
119
void module::assign(const module& m)
{
120
    // copy the impl
Shucai Xiao's avatar
Shucai Xiao committed
121
122
    if(!impl)
        impl = std::make_unique<module_impl>();
123
124
125
126
    *impl = *m.impl;

    // clear instructions
    if(!impl->instructions.empty())
Shucai Xiao's avatar
Shucai Xiao committed
127
    {
128
        impl->clear();
Shucai Xiao's avatar
Shucai Xiao committed
129
130
131
132
133
134
135
136
137
    }

    std::unordered_map<instruction_ref, instruction_ref> ins_map;
    for(auto ins : iterator_for(m))
    {
        instruction_ref copy_ins{};
        if(ins->name() == "@literal")
        {
            auto l   = ins->get_literal();
138
            copy_ins = impl->insert(impl->instructions.end(), instruction{l});
Shucai Xiao's avatar
Shucai Xiao committed
139
140
141
142
        }
        else if(ins->name() == "@param")
        {
            auto&& name = any_cast<builtin::param>(ins->get_operator()).parameter;
143
            auto order  = any_cast<builtin::param>(ins->get_operator()).order;
Shucai Xiao's avatar
Shucai Xiao committed
144
            auto s      = ins->get_shape();
145
146
            copy_ins    = impl->insert(impl->instructions.end(),
                                    {builtin::param{name, order}, std::move(s), {}});
Shucai Xiao's avatar
Shucai Xiao committed
147
148
149
        }
        else if(ins->name() == "@outline")
        {
150
151
            auto s   = ins->get_shape();
            copy_ins = impl->insert(impl->instructions.end(), {builtin::outline{s}, s, {}});
Shucai Xiao's avatar
Shucai Xiao committed
152
153
154
        }
        else
        {
Shucai Xiao's avatar
Shucai Xiao committed
155
156
            // if there are sub_module inputs, need to make a copy of the submodule
            auto module_args = ins->module_inputs();
Shucai Xiao's avatar
Shucai Xiao committed
157
158
159
160
            // retrieve its mapped input
            auto inputs = ins->inputs();
            std::vector<instruction_ref> copy_inputs(inputs.size());
            std::transform(inputs.begin(), inputs.end(), copy_inputs.begin(), [&](auto i) {
Shucai Xiao's avatar
Shucai Xiao committed
161
                return contains(ins_map, i) ? ins_map[i] : i;
Shucai Xiao's avatar
Shucai Xiao committed
162
163
164
165
166
167
168
            });
            if(ins->name() == "@return")
            {
                copy_ins = add_return(copy_inputs);
            }
            else
            {
Shucai Xiao's avatar
Shucai Xiao committed
169
                copy_ins = add_instruction(ins->get_operator(), copy_inputs, module_args);
Shucai Xiao's avatar
Shucai Xiao committed
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
            }
        }

        ins_map[ins] = copy_ins;
    }
}

instruction_ref module::add_instruction(const operation& op, std::vector<instruction_ref> args)
{
    return insert_instruction(impl->instructions.end(), op, std::move(args));
}
instruction_ref module::insert_instruction(instruction_ref ins,
                                           const operation& op,
                                           std::vector<instruction_ref> args)
{
185
    assert(has_instruction(ins) or is_end(ins, this->end()));
Shucai Xiao's avatar
Shucai Xiao committed
186
187
    assert(not starts_with(op.name(), "@"));
    shape r     = compute_shape(op, args);
188
    auto result = impl->insert(ins, {op, r, std::move(args)});
Shucai Xiao's avatar
Shucai Xiao committed
189
190
191
192
193
    instruction::backreference(result);
    assert(result->valid(begin()));
    return result;
}

Shucai Xiao's avatar
Shucai Xiao committed
194
195
196
197
198
199
200
201
202
203
204
205
206
instruction_ref module::add_instruction(const operation& op,
                                        std::vector<instruction_ref> args,
                                        std::vector<module_ref> module_args)
{
    return insert_instruction(
        impl->instructions.end(), op, std::move(args), std::move(module_args));
}

instruction_ref module::insert_instruction(instruction_ref ins,
                                           const operation& op,
                                           std::vector<instruction_ref> args,
                                           std::vector<module_ref> module_args)
{
207
    assert(has_instruction(ins) or is_end(ins, this->end()));
Shucai Xiao's avatar
Shucai Xiao committed
208
209
    assert(not starts_with(op.name(), "@"));
    auto out_shape = compute_shape(op, args, module_args);
210
    auto result    = impl->insert(ins, {op, out_shape, std::move(args), std::move(module_args)});
Shucai Xiao's avatar
Shucai Xiao committed
211
212
213
214
215
    instruction::backreference(result);
    assert(result->valid(begin()));
    return result;
}

Shucai Xiao's avatar
Shucai Xiao committed
216
217
218
219
instruction_ref module::replace_instruction(instruction_ref ins,
                                            const operation& op,
                                            std::vector<instruction_ref> args) MIGRAPHX_TIDY_CONST
{
220
    assert(has_instruction(ins));
Shucai Xiao's avatar
Shucai Xiao committed
221
222
223
224
225
226
227
228
    assert(not starts_with(op.name(), "@"));

    shape r = compute_shape(op, args);
    instruction::replace(ins, op, r, std::move(args));
    assert(ins->valid(begin()));
    return ins;
}

Shucai Xiao's avatar
Shucai Xiao committed
229
230
231
232
233
instruction_ref module::replace_instruction(instruction_ref ins,
                                            const operation& op,
                                            std::vector<instruction_ref> args,
                                            std::vector<module_ref> module_args) MIGRAPHX_TIDY_CONST
{
234
    assert(has_instruction(ins));
Shucai Xiao's avatar
Shucai Xiao committed
235
236
237
238
239
240
241
    assert(not starts_with(op.name(), "@"));
    auto out_shape = compute_shape(op, args, module_args);
    instruction::replace(ins, op, out_shape, std::move(args), std::move(module_args));
    assert(ins->valid(begin()));
    return ins;
}

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
279
280
281
282
283
284
instruction_ref module::replace_instruction(instruction_ref ins, instruction_ref rep)
{
    assert(has_instruction(ins));
    assert(has_instruction(rep));
    assert(ins != rep);

    if(ins == std::prev(this->end()))
    {
        return replace_instruction(ins, make_op("identity"), rep);
    }

    // TODO: Should it be an error if the output is empty?
    if(ins->outputs().empty())
    {
        return rep;
    }
    // Make a copy of outputs which can be changed when calling replace_argument
    auto outputs = ins->outputs();
    for(auto out : outputs)
    {
        // TODO: Check for possible cycles
        if(out != rep)
        {
            instruction::replace_argument(out, ins, rep);
        }
        assert(out->valid(begin()));
    }
    // Replacement should not be dead code unless its the last instruction
    assert(!rep->outputs().empty() or rep == std::prev(end()));
    // Output of the original instruction should only be the replacement or empty
    assert(ins->outputs().empty() or std::all_of(ins->outputs().begin(),
                                                 ins->outputs().end(),
                                                 [&](auto i) { return i == rep; }));
    assert(ins->valid(begin()));
    assert(rep->valid(begin()));
    return rep;
}

instruction_ref module::remove_instruction(instruction_ref ins)
{
    assert(has_instruction(ins));
    assert(ins->outputs().empty());
    ins->clear_arguments();
285
    return impl->erase(ins);
Shucai Xiao's avatar
Shucai Xiao committed
286
287
288
289
290
291
292
293
294
295
}

instruction_ref module::remove_instructions(instruction_ref first, instruction_ref last)
{
    if(first == last)
        return first;
    // TODO: Check every element
    assert(has_instruction(first));
    std::for_each(first, last, [&](instruction& ins) { ins.clear_arguments(); });
    assert(std::all_of(first, last, [&](const instruction& ins) { return ins.outputs().empty(); }));
296
    return impl->erase(first, last);
Shucai Xiao's avatar
Shucai Xiao committed
297
298
299
300
}

instruction_ref module::move_instruction(instruction_ref src, instruction_ref dst)
{
301
302
    assert(has_instruction(src));
    assert(has_instruction(dst) or is_end(dst, this->end()));
Shucai Xiao's avatar
Shucai Xiao committed
303
304
305
306
307
308
309
310
311
312
313
314
    impl->instructions.splice(dst, impl->instructions, src);
    return src;
}

instruction_ref module::move_instructions(instruction_ref src, instruction_ref dst)
{
    this->move_instruction(src, dst);
    for(auto ins : src->inputs())
        this->move_instruction(ins, src);
    return src;
}

315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
std::vector<instruction_ref> module::insert_module_instructions(
    instruction_ref ins, module_ref m, std::unordered_map<instruction_ref, instruction_ref> map_ins)
{
    std::vector<instruction_ref> mod_outputs;
    for(auto sins : iterator_for(*m))
    {
        if(contains(map_ins, sins))
            continue;
        instruction_ref copy_ins;
        if(sins->name() == "@literal")
        {
            auto l   = sins->get_literal();
            copy_ins = this->add_literal(l);
        }
        else if(sins->name() == "@param")
        {
            auto&& name = any_cast<builtin::param>(sins->get_operator()).parameter;
            auto s      = sins->get_shape();
            copy_ins    = this->add_parameter(name, s);
        }
        else if(sins->name() == "@outline")
        {
            auto s   = sins->get_shape();
            copy_ins = this->add_outline(s);
        }
        else
        {
            auto mod_args = sins->module_inputs();
            auto inputs   = sins->inputs();
            std::vector<instruction_ref> copy_inputs(inputs.size());
            std::transform(inputs.begin(), inputs.end(), copy_inputs.begin(), [&](auto i) {
                return contains(map_ins, i) ? map_ins[i] : i;
            });

            if(sins->name() == "@return")
            {
                mod_outputs = copy_inputs;
                break;
            }

            copy_ins = this->insert_instruction(ins, sins->get_operator(), copy_inputs, mod_args);
        }
        map_ins[sins] = copy_ins;
    }
    if(mod_outputs.empty())
        mod_outputs = {map_ins.at(std::prev(m->end()))};
    return mod_outputs;
}

Shucai Xiao's avatar
Shucai Xiao committed
364
365
instruction_ref module::add_literal(literal l)
{
366
    impl->emplace_front(std::move(l));
Shucai Xiao's avatar
Shucai Xiao committed
367
368
369
370
371
    return impl->instructions.begin();
}

instruction_ref module::add_outline(const shape& s)
{
372
    impl->push_front({builtin::outline{s}, s, {}});
Shucai Xiao's avatar
Shucai Xiao committed
373
374
375
376
377
378
    return impl->instructions.begin();
}

instruction_ref module::add_parameter(std::string name, shape s)
{
    assert(get_parameter_shape(name) == shape{});
Paul Fultz II's avatar
Paul Fultz II committed
379
380
    impl->push_front({builtin::param{std::move(name), impl->nparams}, std::move(s), {}});
    impl->nparams++;
Shucai Xiao's avatar
Shucai Xiao committed
381
382
383
384
385
    return impl->instructions.begin();
}

instruction_ref module::add_return(std::vector<instruction_ref> args)
{
386
    impl->push_back({builtin::returns{}, {}, std::move(args)});
Shucai Xiao's avatar
Shucai Xiao committed
387
388
389
390
391
392
393
    auto result = std::prev(impl->instructions.end());
    instruction::backreference(result);
    assert(result->valid(begin()));

    return result;
}

394
395
396
397
398
399
400
401
402
403
404
405
406
407
instruction_ref module::replace_return(std::vector<instruction_ref> args)
{
    auto last = std::prev(this->end());
    // If there is no return then add a return
    if(last->name() != "@return")
        return this->add_return(args);

    shape r = compute_shape(last->get_operator(), args);
    instruction::replace(last, last->get_operator(), r, std::move(args));
    assert(last->valid(begin()));

    return last;
}

Shucai Xiao's avatar
Shucai Xiao committed
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
shape module::get_parameter_shape(std::string name) const
{
    auto ins = std::find_if(
        impl->instructions.begin(), impl->instructions.end(), [&](const instruction& x) {
            if(x.name() == "@param")
            {
                return any_cast<builtin::param>(x.get_operator()).parameter == name;
            }
            else
            {
                return false;
            }
        });
    if(ins != this->end())
        return ins->get_shape();
    else
        return {};
}

std::vector<std::string> module::get_parameter_names() const
{
Paul Fultz II's avatar
Paul Fultz II committed
429
430
    std::vector<std::string> result;
    std::vector<builtin::param> params;
Shucai Xiao's avatar
Shucai Xiao committed
431
432
433
434
    for(auto&& ins : impl->instructions)
    {
        if(ins.name() == "@param")
        {
Paul Fultz II's avatar
Paul Fultz II committed
435
436
            auto&& param = any_cast<builtin::param>(ins.get_operator());
            params.push_back(param);
Shucai Xiao's avatar
Shucai Xiao committed
437
438
        }
    }
Paul Fultz II's avatar
Paul Fultz II committed
439
440
441
442
443
    std::stable_sort(
        params.begin(), params.end(), by(std::less<>{}, [](auto&& p) { return p.order; }));
    std::transform(params.begin(), params.end(), std::back_inserter(result), [&](auto&& p) {
        return p.parameter;
    });
Shucai Xiao's avatar
Shucai Xiao committed
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
    return result;
}

instruction_ref module::get_parameter(std::string name) const
{
    auto ins = std::find_if(
        impl->instructions.begin(), impl->instructions.end(), [&](const instruction& x) {
            if(x.name() == "@param")
            {
                return any_cast<builtin::param>(x.get_operator()).parameter == name;
            }
            else
            {
                return false;
            }
        });
    if(ins != this->end())
        return ins;
    else
        return this->end();
}

std::unordered_map<std::string, shape> module::get_parameter_shapes() const
{
    std::unordered_map<std::string, shape> result;
    for(auto&& ins : impl->instructions)
    {
        if(ins.name() == "@param")
        {
            auto&& name  = any_cast<builtin::param>(ins.get_operator()).parameter;
            result[name] = ins.get_shape();
        }
    }
    return result;
}

480
bool module::has_instruction(instruction_ref ins) const { return impl->contains(ins); }
Shucai Xiao's avatar
Shucai Xiao committed
481
482
483
484
485
486
487

std::size_t module::size() const { return impl->instructions.size(); }
instruction_ref module::begin() const { return impl->instructions.begin(); }
instruction_ref module::end() const { return impl->instructions.end(); }

std::vector<shape> module::get_output_shapes() const
{
488
489
    if(impl->instructions.empty())
        return {};
Shucai Xiao's avatar
Shucai Xiao committed
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
    auto last_ins = impl->instructions.back();
    if(last_ins.name() == "@return")
    {
        const auto& output_ins = last_ins.inputs();
        std::vector<shape> output_shapes;
        std::transform(output_ins.begin(),
                       output_ins.end(),
                       std::back_inserter(output_shapes),
                       [](auto& ins) { return ins->get_shape(); });

        return output_shapes;
    }
    // The else branch is to provide backward compatibility
    else
    {
        return {last_ins.get_shape()};
    }
}

instruction_ref module::validate() const
{
Shucai Xiao's avatar
Shucai Xiao committed
511
512
513
514
515
516
517
518
    return std::find_if(
        impl->instructions.begin(), impl->instructions.end(), [&](const instruction& i) {
            auto inputs      = i.inputs();
            bool check_order = std::all_of(inputs.begin(), inputs.end(), [&](auto in) {
                return contains(impl->instructions, *in);
            });
            return !i.valid(impl->instructions.begin(), check_order);
        });
Shucai Xiao's avatar
Shucai Xiao committed
519
520
}

521
522
523
524
525
bool is_borrowed(instruction_ref ins)
{
    auto alias = instruction::get_output_alias(ins, true);
    if(alias == ins)
        return false;
526
527
    lifetime l = alias->get_operator().get_lifetime();
    if(l == lifetime::borrow)
528
529
530
531
        return true;
    return is_borrowed(alias);
}

532
bool is_global(instruction_ref ins)
533
{
534
535
    const auto& op = instruction::get_output_alias(ins)->get_operator();
    return op.name() == "@param" or op.get_lifetime() == lifetime::global;
536
537
}

538
bool is_dangling(instruction_ref ins) { return not is_global(ins) and is_borrowed(ins); }
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556

instruction_ref module::find_dangling_reference() const
{
    auto last = std::prev(end());
    if(last->name() == "@return")
    {
        auto dangling = std::find_if(
            last->inputs().begin(), last->inputs().end(), [](auto x) { return is_dangling(x); });
        if(dangling != last->inputs().end())
            return *dangling;
    }
    else if(is_dangling(last))
    {
        return last;
    }
    return end();
}

Shucai Xiao's avatar
Shucai Xiao committed
557
558
void module::finalize(context& ctx)
{
Paul Fultz II's avatar
Paul Fultz II committed
559
    const bool trace = enabled(MIGRAPHX_TRACE_FINALIZE{});
Shucai Xiao's avatar
Shucai Xiao committed
560
561
    for(auto ins : iterator_for(*this))
    {
Paul Fultz II's avatar
Paul Fultz II committed
562
563
564
565
566
        if(trace)
        {
            std::cout << "Finalize: ";
            this->debug_print(ins);
        }
Shucai Xiao's avatar
Shucai Xiao committed
567
        ins->finalize(ctx);
Shucai Xiao's avatar
Shucai Xiao committed
568
569
570
571
        for(const auto& smod : ins->module_inputs())
        {
            smod->finalize(ctx);
        }
Shucai Xiao's avatar
Shucai Xiao committed
572
    }
Shucai Xiao's avatar
Shucai Xiao committed
573

574
575
576
577
578
    // Warn when an instruction is not normalized
    auto ins = std::find_if(begin(), end(), [](auto& i) { return i.need_normalization(); });
    if(ins != end())
        std::cerr << "WARNING: Instruction needs normalization, performance may be affected."
                  << std::endl;
Shucai Xiao's avatar
Shucai Xiao committed
579
580
581
}

void module::debug_print() const { std::cout << *this << std::endl; }
Shucai Xiao's avatar
Shucai Xiao committed
582
583

void module::debug_print(instruction_ref ins,
Shucai Xiao's avatar
Shucai Xiao committed
584
                         std::unordered_map<instruction_ref, std::string>& names) const
Shucai Xiao's avatar
Shucai Xiao committed
585
{
586
    if(is_end(ins, this->end()))
Shucai Xiao's avatar
Shucai Xiao committed
587
588
589
590
591
592
593
594
595
596
    {
        std::cout << "End instruction" << std::endl;
        return;
    }
    if(not has_instruction(ins))
    {
        std::cout << "Instruction not part of module" << std::endl;
        return;
    }
    std::stringstream ss;
Shucai Xiao's avatar
Shucai Xiao committed
597
    names = this->print(
Shucai Xiao's avatar
Shucai Xiao committed
598
599
600
601
602
603
604
605
        [&](auto x, auto ins_names) {
            if(x == ins)
            {
                instruction::print(std::cout, x, ins_names);
                std::cout << std::endl;
            }
        },
        names);
Shucai Xiao's avatar
Shucai Xiao committed
606
}
Shucai Xiao's avatar
Shucai Xiao committed
607
608
609
610
611
612
613

void module::debug_print(instruction_ref ins) const
{
    std::unordered_map<instruction_ref, std::string> names;
    this->debug_print(ins, names);
}

Shucai Xiao's avatar
Shucai Xiao committed
614
615
616
617
618
619
620
void module::debug_print(const std::vector<instruction_ref>& inss) const
{
    for(auto ins : inss)
        this->debug_print(ins);
    std::cout << std::endl;
}

Shucai Xiao's avatar
Shucai Xiao committed
621
622
623
624
std::unordered_map<instruction_ref, std::string> module::print(
    const std::function<void(instruction_ref,
                             const std::unordered_map<instruction_ref, std::string>&)>& print_func,
    std::unordered_map<instruction_ref, std::string> names) const
Shucai Xiao's avatar
Shucai Xiao committed
625
626
627
628
629
630
631
632
633
634
635
{
    int count = 0;
    for(auto ins : iterator_for(*this))
    {
        std::string var_name;
        if(ins->name() == "@param")
        {
            var_name = any_cast<builtin::param>(ins->get_operator()).parameter;
        }
        else
        {
Shucai Xiao's avatar
Shucai Xiao committed
636
637
638
            var_name = this->name();
            var_name.append((this->name().empty() ? "@" : ":@"));
            var_name.append(std::to_string(count));
Shucai Xiao's avatar
Shucai Xiao committed
639
        }
Shucai Xiao's avatar
Shucai Xiao committed
640
641
        // count every instruction so index matches loc in the printout program
        count++;
Shucai Xiao's avatar
Shucai Xiao committed
642
643
644
645
        names.emplace(ins, var_name);

        print_func(ins, names);
    }
Shucai Xiao's avatar
Shucai Xiao committed
646
647
648
649
650
651
652
653
    return names;
}

void module::print(const std::function<
                   void(instruction_ref, const std::unordered_map<instruction_ref, std::string>&)>&
                       print_func) const
{
    this->print(print_func, {});
Shucai Xiao's avatar
Shucai Xiao committed
654
655
656
657
658
659
660
661
662
663
664
}

static std::string enclose_name(const std::string& name)
{
    return '"' + replace_string(name, "\"", "\\\"") + '"';
}

void module::print_graph(std::ostream& os, bool brief) const
{
    os << "digraph {" << std::endl;
    os << "\trankdir=LR;" << std::endl;
Shucai Xiao's avatar
Shucai Xiao committed
665
    this->print([&](auto ins, auto ins_names) {
Shucai Xiao's avatar
Shucai Xiao committed
666
667
668
669
670
        std::string label;
        if(brief)
            label = ins->name();
        else
            label = to_string(ins->get_operator());
Shucai Xiao's avatar
Shucai Xiao committed
671
        os << "\t" << enclose_name(ins_names.at(ins)) << "[label=" << enclose_name(label) << "]";
Shucai Xiao's avatar
Shucai Xiao committed
672
673
674
675
676
        os << ";" << std::endl;
        if(!ins->inputs().empty())
        {
            for(auto&& arg : ins->inputs())
            {
Shucai Xiao's avatar
Shucai Xiao committed
677
678
                os << "\t" << enclose_name(ins_names.at(arg)) << " -> "
                   << enclose_name(ins_names.at(ins));
Shucai Xiao's avatar
Shucai Xiao committed
679
680
681
682
683
684
685
686
687
                if(not brief)
                    os << "[label=" << enclose_name(to_string(ins->get_shape())) << "]";
                os << ";" << std::endl;
            }
        }
    });
    os << "}" << std::endl;
}

Paul's avatar
Paul committed
688
689
690
static std::string to_c_id(const std::string& name, char rep = '_')
{
    std::string id = transform_string(name, [&](auto c) {
Paul's avatar
Paul committed
691
        if(with_char(::isalnum)(c) or c == '_')
Paul's avatar
Paul committed
692
693
694
695
696
697
698
699
            return c;
        return rep;
    });
    while(contains(id, "__"))
        replace_string_inplace(id, "__", "_");
    return id;
}

Shucai Xiao's avatar
Shucai Xiao committed
700
701
static std::string cpp_var_name(const std::string& name)
{
Paul's avatar
Paul committed
702
    return to_c_id("x_" + replace_string(name, ":", "_module_"));
Shucai Xiao's avatar
Shucai Xiao committed
703
704
}

Paul's avatar
Paul committed
705
706
707
708
static void print_make_op(std::ostream& os, const operation& op)
{
    os << "migraphx::make_op(" << enclose_name(op.name());
    auto v = op.to_value();
Paul's avatar
Paul committed
709
    if(not v.empty())
Paul's avatar
Paul committed
710
    {
Paul's avatar
Format  
Paul committed
711
712
        os << ", "
           << "migraphx::from_json_string(" << enclose_name(to_json_string(v)) << ")";
Paul's avatar
Paul committed
713
714
715
716
    }
    os << ")";
}

Shucai Xiao's avatar
Shucai Xiao committed
717
718
719
720
721
722
723
724
725
static void print_cpp_shape(std::ostream& os, const migraphx::shape& s)
{
    os << "migraphx::shape{migraphx::shape::" << s.type_string();
    os << ", {" << to_string_range(s.lens()) << "}";
    if(not s.standard())
        os << ", {" << to_string_range(s.strides()) << "}";
    os << "}";
}

Shucai Xiao's avatar
Shucai Xiao committed
726
std::unordered_map<instruction_ref, std::string>
Paul's avatar
Format  
Paul committed
727
728
729
module::print_cpp(std::ostream& os,
                  const std::string& mname,
                  std::unordered_map<instruction_ref, std::string> names) const
Shucai Xiao's avatar
Shucai Xiao committed
730
731
{
    // cppcheck-suppress variableScope
Paul's avatar
Paul committed
732
    unsigned long seed = names.size();
Paul's avatar
Format  
Paul committed
733
    auto last          = std::prev(this->end());
Shucai Xiao's avatar
Shucai Xiao committed
734
735
    names              = this->print(
        [&](auto ins, auto ins_names) {
Paul's avatar
Paul committed
736
            std::vector<std::string> input_vars;
Paul's avatar
Format  
Paul committed
737
738
739
740
            std::transform(ins->inputs().begin(),
                           ins->inputs().end(),
                           std::back_inserter(input_vars),
                           [&](auto input) { return cpp_var_name(ins_names.at(input)); });
Paul's avatar
Format  
Paul committed
741
            if(ins != last)
Paul's avatar
Paul committed
742
                os << "auto " << cpp_var_name(ins_names.at(ins)) << " = ";
Shucai Xiao's avatar
Shucai Xiao committed
743
744
            if(ins->name() == "@literal")
            {
Paul's avatar
Paul committed
745
                os << mname << "->add_literal(";
Shucai Xiao's avatar
Shucai Xiao committed
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
                bool use_abs = false;
                ins->get_literal().visit([&](auto v) {
                    use_abs = std::none_of(v.begin(), v.end(), [](auto x) { return x < 0; });
                });
                if(use_abs)
                    os << "migraphx::abs(";
                os << "migraphx::generate_literal(";
                print_cpp_shape(os, ins->get_shape());
                os << ", " << seed << ")";
                if(use_abs)
                    os << ")";
                os << ");" << std::endl;
                seed++;
            }
            else if(ins->name() == "@param")
            {
                std::string name = any_cast<builtin::param>(ins->get_operator()).parameter;
Paul's avatar
Paul committed
763
                os << mname << "->add_parameter(" << enclose_name(name) << ",";
Shucai Xiao's avatar
Shucai Xiao committed
764
765
766
                print_cpp_shape(os, ins->get_shape());
                os << ");" << std::endl;
            }
Paul's avatar
Paul committed
767
768
769
770
771
772
            else if(ins->name() == "@return")
            {
                os << mname << "->add_return({";
                os << join_strings(input_vars, ", ");
                os << "});" << std::endl;
            }
Shucai Xiao's avatar
Shucai Xiao committed
773
774
            else
            {
Paul's avatar
Paul committed
775
776
777
778
                assert(ins->name().front() != '@');
                os << mname << "->add_instruction(";
                print_make_op(os, ins->get_operator());
                os << ", " << join_strings(input_vars, ", ");
Shucai Xiao's avatar
Shucai Xiao committed
779
780
781
782
783
784
                os << ");" << std::endl;
            }
        },
        names);

    return names;
Shucai Xiao's avatar
Shucai Xiao committed
785
786
}

Paul's avatar
Paul committed
787
void module::print_cpp(std::ostream& os) const { this->print_cpp(os, this->name(), {}); }
Shucai Xiao's avatar
Shucai Xiao committed
788

Shucai Xiao's avatar
Shucai Xiao committed
789
790
void module::annotate(std::ostream& os, std::function<void(instruction_ref)> a) const
{
Shucai Xiao's avatar
Shucai Xiao committed
791
792
    this->print([&](auto ins, auto ins_names) {
        instruction::print(os, ins, ins_names);
Shucai Xiao's avatar
Shucai Xiao committed
793
794
795
796
797
        a(ins);
        os << std::endl;
    });
}

Shucai Xiao's avatar
Shucai Xiao committed
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
std::vector<module_ref> module::get_sub_modules() const
{
    std::vector<module_ref> vec_modules;
    for(auto ins : iterator_for(*this))
    {
        const auto& mod_args = ins->module_inputs();
        vec_modules.insert(vec_modules.end(), mod_args.begin(), mod_args.end());
        for(const auto& smod : mod_args)
        {
            auto sub_mods = smod->get_sub_modules();
            vec_modules.insert(vec_modules.end(), sub_mods.begin(), sub_mods.end());
        }
    }

    return vec_modules;
}

Shucai Xiao's avatar
Shucai Xiao committed
815
816
817
818
819
module& module::sort()
{
    fix([&](auto self, auto ins) {
        this->move_instruction(ins, this->begin());
        for(auto child : ins->inputs())
Shucai Xiao's avatar
Shucai Xiao committed
820
821
822
823
824
        {
            if(!contains(this->impl->instructions, child))
            {
                continue;
            }
Shucai Xiao's avatar
Shucai Xiao committed
825
            self(child);
Shucai Xiao's avatar
Shucai Xiao committed
826
        }
Shucai Xiao's avatar
Shucai Xiao committed
827
828
829
830
831
    })(std::prev(this->end()));
    assert(this->validate() == this->end());
    return *this;
}

Shucai Xiao's avatar
Shucai Xiao committed
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
void module::calc_implicit_deps(const module& smod,
                                const module& pmod,
                                instruction_ref ins,
                                ins_dep_map& deps) const
{
    const auto& ins_inputs = ins->inputs();
    for(auto ii : iterator_for(smod))
    {
        const auto& ii_inputs = ii->inputs();
        for(auto iii : ii_inputs)
        {
            if(pmod.has_instruction(iii))
            {
                if(not contains(ins_inputs, iii))
                    deps[ins].insert(iii);
            }
        }

        const auto& mod_args = ii->module_inputs();
        if(not mod_args.empty())
        {
            for(const auto* ssmod : mod_args)
            {
                calc_implicit_deps(*ssmod, pmod, ins, deps);
            }
        }
    }
}

ins_dep_map module::calc_implicit_deps() const
{
    ins_dep_map mod_implicit_deps;
    for(auto ins : iterator_for(*this))
    {
        const auto& mod_args = ins->module_inputs();
        if(mod_args.empty())
        {
            continue;
        }

        for(const auto* mod : mod_args)
        {
            calc_implicit_deps(*mod, *this, ins, mod_implicit_deps);
        }
    }

    return mod_implicit_deps;
}

Shucai Xiao's avatar
Shucai Xiao committed
881
882
883
884
bool operator==(const module& x, const module& y) { return to_string(x) == to_string(y); }

std::ostream& operator<<(std::ostream& os, const module& m)
{
Shucai Xiao's avatar
Shucai Xiao committed
885
886
    m.print([&](auto ins, auto ins_names) {
        instruction::print(os, ins, ins_names);
Shucai Xiao's avatar
Shucai Xiao committed
887
888
        os << std::endl;
    });
Shucai Xiao's avatar
Shucai Xiao committed
889

Shucai Xiao's avatar
Shucai Xiao committed
890
891
892
893
894
    return os;
}

} // namespace MIGRAPHX_INLINE_NS
} // namespace migraphx