program.cpp 39.7 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.
 */
24
#include <migraphx/compile_options.hpp>
Paul's avatar
Paul committed
25
26
27
#include <migraphx/program.hpp>
#include <migraphx/stringutils.hpp>
#include <migraphx/instruction.hpp>
28
#include <migraphx/op/identity.hpp>
Paul's avatar
Paul committed
29
#include <migraphx/target.hpp>
Paul's avatar
Paul committed
30
31
32
#include <migraphx/env.hpp>
#include <migraphx/ranges.hpp>
#include <migraphx/time.hpp>
33
#include <migraphx/pass_manager.hpp>
34
#include <migraphx/register_target.hpp>
Shucai Xiao's avatar
Shucai Xiao committed
35
#include <migraphx/iterator_for.hpp>
36
#include <migraphx/iterator.hpp>
37
#include <migraphx/algorithm.hpp>
38
#include <migraphx/output_iterator.hpp>
Shucai Xiao's avatar
Shucai Xiao committed
39
#include <migraphx/make_op.hpp>
40
#include <migraphx/marker.hpp>
varunsh's avatar
varunsh committed
41
#include <migraphx/supported_segments.hpp>
Paul's avatar
Paul committed
42
#include <iostream>
Paul's avatar
Paul committed
43
#include <sstream>
Paul's avatar
Paul committed
44
#include <algorithm>
45
#include <set>
46
#include <unordered_map>
Paul's avatar
Paul committed
47
#include <utility>
48

49
#include <unordered_set>
Shucai Xiao's avatar
Shucai Xiao committed
50
51
#include <map>
#include <cassert>
Paul's avatar
Paul committed
52

Paul's avatar
Paul committed
53
namespace migraphx {
Paul's avatar
Paul committed
54
inline namespace MIGRAPHX_INLINE_NS {
Paul's avatar
Paul committed
55

56
57
using milliseconds = std::chrono::duration<double, std::milli>;

58
59
60
61
62
63
64
65
66
67
68
struct mark_instruction_target
{
    std::size_t target_id = 0;
    std::string name() const { return "mark_instruction_target"; }
    void apply(module& m) const
    {
        for(auto& ins : m)
            ins.set_target_id(target_id);
    }
};

Paul's avatar
Paul committed
69
70
struct program_impl
{
Shucai Xiao's avatar
Shucai Xiao committed
71
    // A map is used to keep references to modules of the program
72
    std::unordered_map<std::string, module> modules;
Paul's avatar
Paul committed
73
    context ctx;
74
    std::string target_name;
75
    std::vector<context> contexts;
Paul's avatar
Paul committed
76
77
};

78
program::program() : impl(std::make_unique<program_impl>()) { this->create_module("main"); }
Paul's avatar
Paul committed
79

Paul's avatar
Paul committed
80
program::program(program&&) noexcept = default;
Shucai Xiao's avatar
Shucai Xiao committed
81
program::~program() noexcept         = default;
Paul's avatar
Paul committed
82

83
// copy constructor
Shucai Xiao's avatar
Shucai Xiao committed
84
program::program(const program& p) { assign(p); }
85
86

// copy assignment operator
Shucai Xiao's avatar
Shucai Xiao committed
87
program& program::operator=(program p)
88
{
Shucai Xiao's avatar
Shucai Xiao committed
89
    std::swap(p.impl, this->impl);
90
91
92
    return *this;
}

Shucai Xiao's avatar
Shucai Xiao committed
93
void program::assign(const program& p)
94
{
95
    if(not impl)
96
97
98
    {
        impl = std::make_unique<program_impl>();
    }
99
    else if(not impl->modules.empty())
100
    {
Shucai Xiao's avatar
Shucai Xiao committed
101
        impl->modules.clear();
102
    }
Shucai Xiao's avatar
Shucai Xiao committed
103

104
    impl->ctx         = p.impl->ctx;
Shucai Xiao's avatar
Shucai Xiao committed
105
106
    impl->target_name = p.impl->target_name;
    impl->modules     = p.impl->modules;
Shucai Xiao's avatar
Shucai Xiao committed
107
108
109
110

    // build a map from old ins to new ins
    // Build a map from old module to new module
    std::unordered_map<module_ref, module_ref> mod_map;
Paul's avatar
Paul committed
111
112
113
114
115
    std::transform(
        impl->modules.begin(),
        impl->modules.end(),
        std::inserter(mod_map, mod_map.begin()),
        [&](auto&& xp) { return std::make_pair(&p.impl->modules.at(xp.first), &xp.second); });
Shucai Xiao's avatar
Shucai Xiao committed
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131

    std::unordered_map<instruction_ref, instruction_ref> ins_map;
    for(auto&& pp : mod_map)
    {
        auto old_ins = iterator_for(*pp.first);
        auto new_ins = iterator_for(*pp.second);
        std::transform(old_ins.begin(),
                       old_ins.end(),
                       new_ins.begin(),
                       std::inserter(ins_map, ins_map.begin()),
                       [](auto x, auto y) { return std::make_pair(x, y); });
    }

    // Update all references from all modules
    for(auto&& mp : impl->modules)
    {
132
        for(auto ins : iterator_for(mp.second))
Shucai Xiao's avatar
Shucai Xiao committed
133
134
            instruction::replace_refs(ins, ins_map, mod_map);
    }
135
136
}

Paul's avatar
Paul committed
137
shape program::get_parameter_shape(std::string name) const
Paul's avatar
Paul committed
138
{
Shucai Xiao's avatar
Shucai Xiao committed
139
140
    const auto* mm = this->get_main_module();
    return mm->get_parameter_shape(std::move(name));
Paul's avatar
Paul committed
141
142
}

143
144
std::vector<std::string> program::get_parameter_names() const
{
Shucai Xiao's avatar
Shucai Xiao committed
145
146
    const auto* mm = this->get_main_module();
    return mm->get_parameter_names();
147
148
}

mei-ye's avatar
mei-ye committed
149
150
instruction_ref program::get_parameter(std::string name) const
{
Shucai Xiao's avatar
Shucai Xiao committed
151
152
    const auto* mm = this->get_main_module();
    return mm->get_parameter(std::move(name));
mei-ye's avatar
mei-ye committed
153
154
}

Paul's avatar
Paul committed
155
156
std::unordered_map<std::string, shape> program::get_parameter_shapes() const
{
Shucai Xiao's avatar
Shucai Xiao committed
157
158
    const auto* mm = this->get_main_module();
    return mm->get_parameter_shapes();
Paul's avatar
Paul committed
159
160
}

Shucai Xiao's avatar
Shucai Xiao committed
161
std::size_t program::size() const { return impl->modules.size(); }
162

163
164
std::vector<shape> program::get_output_shapes() const
{
Shucai Xiao's avatar
Shucai Xiao committed
165
166
    const auto* mm = this->get_main_module();
    return mm->get_output_shapes();
167
}
Paul's avatar
Paul committed
168

Paul's avatar
Paul committed
169
170
context& program::get_context() const { return impl->ctx; }

Paul's avatar
Paul committed
171
172
instruction_ref program::validate() const
{
Shucai Xiao's avatar
Shucai Xiao committed
173
174
    const auto* mm = this->get_main_module();
    return mm->validate();
Paul's avatar
Paul committed
175
176
}

177
178
179
180
181
182
183
184
target_assignments program::get_target_assignments(const std::vector<target>& targets,
                                                   assignment_options options)
{
    const auto m = options.metric;

    target_assignments p;

    const auto* mod = get_main_module();
varunsh's avatar
varunsh committed
185
186
187
188
189
190
191
192
    std::vector<std::pair<target, supported_segments>> target_subgraphs;
    target_subgraphs.reserve(targets.size());
    std::transform(targets.begin(),
                   targets.end(),
                   std::back_inserter(target_subgraphs),
                   [&](const auto& t) { return std::make_pair(t, t.find_supported(mod, m)); });

    for(const auto ins : iterator_for(*mod))
193
    {
varunsh's avatar
varunsh committed
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
        if(contains(p, ins))
        {
            continue;
        }

        for(const auto& [target, subgraph] : target_subgraphs)
        {
            // can't pass a structured binding into lambda in C++17 so create a variable for it
            const auto& t = target;
            for(const auto& segment : subgraph)
            {
                const auto& instructions = segment.instructions;
                if(not contains(instructions, ins))
                {
                    continue;
                }
                std::transform(instructions.begin(),
                               instructions.end(),
                               std::inserter(p, p.end()),
                               [&](auto instr) { return std::make_pair(instr, t.name()); });
            }
        }
216
217
218
219
    }
    return p;
}

220
221
bool program::is_compiled() const { return not this->impl->target_name.empty(); }

222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
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
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
void program::compile(const std::vector<target>& targets, std::vector<compile_options> compile_opts)
{
    // Gather all the target roots
    std::unordered_multimap<std::size_t, module_ref> roots;
    auto mods = this->get_modules();
    for(auto* mod : mods)
    {
        for(const auto& ins : *mod)
        {
            if(ins.name() != "run_on_target")
                continue;
            auto v                     = ins.get_operator().to_value();
            module_ref root            = ins.module_inputs().front();
            std::size_t root_target_id = v.at("target_id").to<std::size_t>();
            assert(root_target_id < targets.size());
            roots.insert({root_target_id, root});
        }
    }

    auto trace = tracer{};
    // TODO: Add tracer based on compile options
    if(enabled(MIGRAPHX_TRACE_COMPILE{}))
        trace = tracer{std::cout};

    trace(*this);
    trace();
    // It is assumed that all instructions outside of any root module would run on "ref" target
    // Ref target may or may not be passed as one of the target for the "compile()".
    // If it is not passed, Create one and add context of it into the map.
    auto target_idx = [&](const std::string& t_name) {
        return static_cast<std::size_t>(
            std::find_if(
                targets.begin(), targets.end(), [&](const auto& t) { return t.name() == t_name; }) -
            targets.begin());
    };

    std::size_t ref_target_id = target_idx("ref");
    if(ref_target_id == targets.size())
    {
        this->impl->contexts.resize(targets.size() + 1);
        this->impl->contexts[ref_target_id] = migraphx::make_target("ref").get_context();
        // users could pass lessers compile_ops than targets, in that case use default compile_opts
        compile_opts.resize(targets.size() + 1, migraphx::compile_options{});
    }
    else
    {
        this->impl->contexts.resize(targets.size());
        compile_opts.resize(targets.size(), migraphx::compile_options{});
    }
    // mark all the instruction as ref target first, later change target_id based on root-target
    run_passes(*this, {mark_instruction_target{ref_target_id}});

    // Run passes on each root target
    for(const auto i : range(targets.size()))
    {
        const auto& root_target              = targets.at(i);
        auto root_target_id                  = i;
        auto root_modules_range              = roots.equal_range(root_target_id);
        this->impl->contexts[root_target_id] = root_target.get_context();
        for(const auto& [id, current_mod] : range(root_modules_range))
        {
            auto passes = root_target.get_passes(this->impl->contexts[root_target_id],
                                                 compile_opts[root_target_id]);
            passes.push_back(mark_instruction_target{static_cast<size_t>(root_target_id)});
            run_passes(*this, current_mod, passes, trace);

            auto invalid = current_mod->validate();
            if(invalid != current_mod->end())
            {
                MIGRAPHX_THROW("Invalid module " + current_mod->name() +
                               " from compilation at instruction " +
                               std::to_string(std::distance(current_mod->begin(), invalid)));
            }
            auto dangling = current_mod->find_dangling_reference();
            if(dangling != current_mod->end())
            {
                auto index = std::distance(current_mod->begin(), dangling);
                MIGRAPHX_THROW("Dangling reference in module " + current_mod->name() +
                               " from instruction " + std::to_string(index));
            }
            current_mod->finalize(this->impl->contexts[root_target_id]);
        }
    }
}

307
void program::compile(const target& t, compile_options options)
Paul's avatar
Paul committed
308
{
309
    // todo: combine with multi-target compile method
310
311
312
    assert(not this->is_compiled());
    this->impl->target_name = t.name();
    this->impl->ctx         = t.get_context();
313

Paul's avatar
Paul committed
314
    if(enabled(MIGRAPHX_TRACE_COMPILE{}))
315
        options.trace = tracer{std::cout};
Shucai Xiao's avatar
Shucai Xiao committed
316

317
318
    options.trace(*this);
    options.trace();
Shucai Xiao's avatar
Shucai Xiao committed
319
    auto&& passes = t.get_passes(this->impl->ctx, options);
320
321
322
323
    run_passes(*this, passes, options.trace);
    auto mods = this->get_modules();
    // Validate and finalize
    for(const auto& mod : reverse(mods))
Paul's avatar
Paul committed
324
    {
Shucai Xiao's avatar
Shucai Xiao committed
325
326
327
328
329
330
        auto invalid = mod->validate();
        if(invalid != mod->end())
        {
            MIGRAPHX_THROW("Invalid module " + mod->name() + " from compilation at instruction " +
                           std::to_string(std::distance(mod->begin(), invalid)));
        }
331
332
333
334
335
336
337
        auto dangling = mod->find_dangling_reference();
        if(dangling != mod->end())
        {
            auto index = std::distance(mod->begin(), dangling);
            MIGRAPHX_THROW("Dangling reference in module " + mod->name() + " from instruction " +
                           std::to_string(index));
        }
Shucai Xiao's avatar
Shucai Xiao committed
338
        mod->finalize(this->impl->ctx);
Paul's avatar
Paul committed
339
    }
Paul's avatar
Paul committed
340
341
342
343
}

void program::finalize()
{
Shucai Xiao's avatar
Shucai Xiao committed
344
345
    auto* mm = this->get_main_module();
    mm->finalize(this->impl->ctx);
Paul's avatar
Paul committed
346
347
}

348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
template <class T>
std::string classify(T x)
{
    switch(std::fpclassify(x))
    {
    case FP_INFINITE: return "inf";
    case FP_NAN: return "nan";
    case FP_NORMAL: return "normal";
    case FP_SUBNORMAL: return "subnormal";
    case FP_ZERO: return "zero";
    default: return "unknown";
    }
}

std::unordered_set<std::string> classify_argument(const argument& a)
{
    std::unordered_set<std::string> result;
    a.visit(
        [&](auto t) {
            for(const auto& x : t)
                result.insert(classify(x));
        },
        [&](const auto& xs) {
            for(const auto& x : xs)
            {
                auto r = classify_argument(x);
                result.insert(r.begin(), r.end());
            }
        });
    return result;
}

void preview_argument(std::ostream& os, const argument& a)
{
    a.visit(
        [&](auto t) {
            if(t.size() <= 10)
            {
                os << t;
            }
            else
            {
                os << to_string_range(t.begin(), t.begin() + 5);
                os << ", ..., ";
                os << to_string_range(t.end() - 5, t.end());
            }
        },
        [&](const auto& xs) {
            for(const auto& x : xs)
            {
                os << '{';
                preview_argument(os, x);
                os << '}';
            }
        });
}

Paul's avatar
Paul committed
405
template <class F>
Shucai Xiao's avatar
Shucai Xiao committed
406
std::vector<argument> generic_eval(const module* mod,
407
408
                                   context& ctx,
                                   std::unordered_map<std::string, argument> params,
Shucai Xiao's avatar
Shucai Xiao committed
409
                                   std::unordered_map<instruction_ref, argument> results,
410
                                   F make_trace)
Paul's avatar
Paul committed
411
{
Shucai Xiao's avatar
Shucai Xiao committed
412
413
    assert(mod->validate() == mod->end());
    results.reserve(mod->size() * 2);
Paul's avatar
Paul committed
414
415
    std::vector<argument> values;
    values.reserve(16);
416
    auto trace = make_trace(mod);
Shucai Xiao's avatar
Shucai Xiao committed
417
    for(auto ins : iterator_for(*mod))
Paul's avatar
Paul committed
418
    {
419
        assert(results.find(ins) == results.end());
420
421
        const auto& name = ins->name();
        if(name == "@literal")
Paul's avatar
Paul committed
422
        {
Paul's avatar
Paul committed
423
            results.emplace(ins, trace(ins, [&] { return ins->get_literal().get_argument(); }));
Paul's avatar
Paul committed
424
        }
425
        else if(name == "@param")
Paul's avatar
Paul committed
426
        {
Paul's avatar
Paul committed
427
428
429
430
431
            results.emplace(
                ins, trace(ins, [&] {
                    auto param_name = any_cast<builtin::param>(ins->get_operator()).parameter;
                    if(not contains(params, param_name))
                        MIGRAPHX_THROW("Parameter not found: " + param_name);
432
                    auto param = params[param_name];
433
                    // TODO: may want to check correct number of dimensions and/or was within bounds
434
435
                    if(not ins->get_shape().any_of_dynamic() and
                       param.get_shape() != ins->get_shape())
436
                    {
Paul's avatar
Paul committed
437
                        MIGRAPHX_THROW("Incorrect shape {" + to_string(param.get_shape()) +
Brian Pickrell's avatar
Brian Pickrell committed
438
439
                                       "} for parameter: " + param_name +
                                       " should be: " + to_string(ins->get_shape()));
440
                    }
Paul's avatar
Paul committed
441
442
                    return param;
                }));
Paul's avatar
Paul committed
443
        }
444
        else if(name == "@outline")
Paul's avatar
Paul committed
445
        {
Paul's avatar
Paul committed
446
            results.emplace(ins, trace(ins, [&] { return argument{ins->get_shape(), nullptr}; }));
Paul's avatar
Paul committed
447
        }
448
449
450
451
452
453
454
455
456
457
458
459
460
        else if(name == "@return")
        {
            std::vector<argument> prog_outputs;
            std::transform(ins->inputs().begin(),
                           ins->inputs().end(),
                           std::back_inserter(prog_outputs),
                           [&](instruction_ref i) {
                               assert(results.find(i) != results.end());
                               return results[i];
                           });

            return prog_outputs;
        }
Paul's avatar
Paul committed
461
462
        else
        {
Paul's avatar
Paul committed
463
            values.resize(ins->inputs().size());
Paul's avatar
Paul committed
464
465
466
467
468
            std::transform(
                ins->inputs().begin(), ins->inputs().end(), values.begin(), [&](instruction_ref i) {
                    assert(results.find(i) != results.end());
                    return results[i];
                });
Shucai Xiao's avatar
Shucai Xiao committed
469
470
471
            const auto& mod_args = ins->module_inputs();
            auto module_eval     = [&](module_ref smod,
                                   const std::unordered_map<std::string, argument>& inputs) {
Shucai Xiao's avatar
Shucai Xiao committed
472
473
                auto ssctx = ctx;
                return generic_eval(smod, ssctx, inputs, results, make_trace);
Shucai Xiao's avatar
Shucai Xiao committed
474
475
            };

Shucai Xiao's avatar
Shucai Xiao committed
476
477
478
479
            results.emplace(ins, trace(ins, [&] {
                                return ins->normalized_operator().compute(
                                    ctx, ins->get_shape(), values, mod_args, module_eval);
                            }));
Paul's avatar
Paul committed
480
        }
481
        assert(results.find(ins) != results.end());
Charlie Lin's avatar
Charlie Lin committed
482
        if(not ins->get_shape().any_of_dynamic())
483
484
485
        {
            assert(results.at(ins).get_shape() == ins->get_shape());
        }
Paul's avatar
Paul committed
486
    }
Shucai Xiao's avatar
Shucai Xiao committed
487
    return {results.at(std::prev(mod->end()))};
Paul's avatar
Paul committed
488
489
}

Shucai Xiao's avatar
Shucai Xiao committed
490
491
492
493
template <class F>
std::vector<argument> generic_eval(const program& p,
                                   context& ctx,
                                   std::unordered_map<std::string, argument> params,
494
                                   F make_trace)
Shucai Xiao's avatar
Shucai Xiao committed
495
{
Shucai Xiao's avatar
Shucai Xiao committed
496
    const module* mm = p.get_main_module();
497
    return generic_eval(mm, ctx, params, {}, make_trace);
Shucai Xiao's avatar
Shucai Xiao committed
498
499
}

500
std::vector<argument> program::eval(parameter_map params, execution_environment exec_env) const
Paul's avatar
Paul committed
501
{
Paul's avatar
Paul committed
502
503
    auto& ctx = this->impl->ctx;
#ifndef NDEBUG
504
505
506
507
508
509
510
511
512
513
514
    auto with_check_context = [&](auto f) {
        return [=, &ctx](auto&&) {
            auto sctx          = std::make_shared<context>(ctx);
            auto check_context = [=, &ctx](auto g) {
                assert(is_shared(ctx, *sctx));
                auto x = g();
                *sctx  = ctx;
                return x;
            };
            return [=](auto&&... xs) { return f(xs..., check_context); };
        };
Paul's avatar
Paul committed
515
516
    };
#else
517
518
519
520
521
    auto with_check_context = [](auto f) {
        return [=](auto&&) {
            return [=](auto&&... xs) { return f(xs..., [](auto g) { return g(); }); };
        };
    };
Paul's avatar
Paul committed
522
#endif
Paul's avatar
Paul committed
523
524

    auto trace_level = value_of(MIGRAPHX_TRACE_EVAL{});
525
526
527
528
529
530
    std::vector<argument> ret;

    if(exec_env.async)
    {
        ctx.wait_for(exec_env.queue);
    }
Paul's avatar
Paul committed
531
532

    if(trace_level > 0)
Paul's avatar
Paul committed
533
    {
Shucai Xiao's avatar
Shucai Xiao committed
534
535
536
537
538
539
540
541
        std::unordered_map<instruction_ref, std::string> ins_out;
        // get instruction names
        this->print([&](auto x, auto ins_names) {
            std::stringstream ss;
            instruction::print(ss, x, ins_names);
            ins_out[x] = ss.str();
        });

542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
        ret = generic_eval(*this,
                           ctx,
                           std::move(params),
                           with_check_context([&](auto& ins, auto f, auto&& check_context) {
                               ctx.finish();
                               std::cout << "Run instruction: " << ins_out.at(ins) << std::endl;
                               timer t{};
                               auto result = check_context(f);
                               double t1   = t.record<milliseconds>();
                               ctx.finish();
                               double t2 = t.record<milliseconds>();
                               std::cout << "Time: " << t1 << "ms, " << t2 << "ms" << std::endl;
                               if(trace_level > 1 and ins->name().front() != '@' and
                                  ins->name() != "load" and not result.empty())
                               {
                                   target tgt  = make_target(this->impl->target_name);
                                   auto buffer = tgt.copy_from(result);
                                   if(trace_level == 2)
                                   {
                                       std::cout << "Output has "
                                                 << to_string_range(classify_argument(buffer))
                                                 << std::endl;
                                       std::cout << "Output: ";
                                       preview_argument(std::cout, buffer);
                                       std::cout << std::endl;
                                   }
                                   else
                                   {
                                       std::cout << "Output: " << buffer << std::endl;
                                   }
                               }
                               return result;
                           }));
Paul's avatar
Paul committed
575
576
577
    }
    else
    {
578
579
580
581
582
583
        ret = generic_eval(*this,
                           ctx,
                           std::move(params),
                           with_check_context([&](auto&, auto f, auto&& check_context) {
                               return check_context(f);
                           }));
Paul's avatar
Paul committed
584
    }
585
586
587
588
589
590
591

    if(exec_env.async)
    {
        ctx.finish_on(exec_env.queue);
    }

    return ret;
Paul's avatar
Paul committed
592
593
}

594
const int program_file_version = 5;
595
596
597
598
599
600
601
602

value program::to_value() const
{
    value result;
    result["version"] = program_file_version;
    result["target"]  = this->impl->target_name;
    if(not this->impl->target_name.empty())
        result["context"] = this->impl->ctx.to_value();
Shucai Xiao's avatar
Shucai Xiao committed
603

604
    value module_vals = value::object{};
Shucai Xiao's avatar
Shucai Xiao committed
605
    std::unordered_map<instruction_ref, std::string> names;
606
    for(auto& mod : this->get_modules())
Shucai Xiao's avatar
Shucai Xiao committed
607
    {
Shucai Xiao's avatar
Shucai Xiao committed
608
609
        value mod_val;
        value nodes;
610
611
        mod_val["name"] = mod->name();
        names           = mod->print(
Shucai Xiao's avatar
Shucai Xiao committed
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
            [&](auto ins, auto ins_names) {
                value node;
                node["output"]     = ins_names.at(ins);
                node["name"]       = ins->name();
                node["shape"]      = migraphx::to_value(ins->get_shape());
                node["normalized"] = ins->is_normalized();
                if(ins->name() == "@literal")
                    node["literal"] = migraphx::to_value(ins->get_literal());
                node["operator"] = ins->get_operator().to_value();
                std::vector<std::string> inputs;
                std::transform(ins->inputs().begin(),
                               ins->inputs().end(),
                               std::back_inserter(inputs),
                               [&](auto i) {
                                   assert(contains(ins_names, i));
                                   return ins_names.at(i);
                               });
                node["inputs"]   = inputs;
                auto module_args = ins->module_inputs();
                if(not module_args.empty())
                {
                    std::vector<std::string> module_inputs;
                    std::transform(module_args.begin(),
                                   module_args.end(),
                                   std::back_inserter(module_inputs),
                                   [&](auto mod_ref) { return mod_ref->name(); });
                    node["module_inputs"] = module_inputs;
                }

                nodes.push_back(node);
            },
            names);
        mod_val["nodes"] = nodes;

646
        module_vals[mod->name()] = mod_val;
Shucai Xiao's avatar
Shucai Xiao committed
647
    }
Shucai Xiao's avatar
Shucai Xiao committed
648
649
650

    result["modules"] = module_vals;

651
652
    return result;
}
Shucai Xiao's avatar
Shucai Xiao committed
653

Shucai Xiao's avatar
Shucai Xiao committed
654
655
656
657
658
static void mod_from_val(module_ref mod,
                         const value& v,
                         std::unordered_map<std::string, instruction_ref>& instructions,
                         const std::unordered_map<std::string, module_ref>& map_mods)
{
659
    const auto& module_val = v.at(mod->name());
Shucai Xiao's avatar
Shucai Xiao committed
660
661
662
663
664
665
666
667
668
    for(const value& node : module_val.at("nodes"))
    {
        instruction_ref output;
        auto name       = node.at("name").to<std::string>();
        auto fields     = node.at("operator");
        auto normalized = node.at("normalized").to<bool>();

        if(name == "@param")
        {
Paul Fultz II's avatar
Paul Fultz II committed
669
670
671
            output = mod->insert_parameter(mod->end(),
                                           fields["parameter"].to<std::string>(),
                                           migraphx::from_value<shape>(node.at("shape")));
Shucai Xiao's avatar
Shucai Xiao committed
672
673
674
        }
        else if(name == "@literal")
        {
Paul Fultz II's avatar
Paul Fultz II committed
675
676
            output =
                mod->insert_literal(mod->end(), migraphx::from_value<literal>(node.at("literal")));
Shucai Xiao's avatar
Shucai Xiao committed
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
        }
        else
        {
            auto op = make_op(name, fields);
            std::vector<instruction_ref> inputs;
            std::transform(node.at("inputs").begin(),
                           node.at("inputs").end(),
                           std::back_inserter(inputs),
                           [&](const value& i) {
                               auto i_name = i.to<std::string>();
                               assert(contains(instructions, i_name));
                               return instructions.at(i_name);
                           });

            std::vector<module_ref> module_inputs;
            if(node.contains("module_inputs"))
            {
                std::transform(node.at("module_inputs").begin(),
                               node.at("module_inputs").end(),
                               std::back_inserter(module_inputs),
                               [&](const value& i) { return map_mods.at(i.to<std::string>()); });

                for(auto& smod : module_inputs)
                {
                    mod_from_val(smod, v, instructions, map_mods);
                }
            }

            if(name == "@return")
            {
                output = mod->add_return(inputs);
            }
            else if(module_inputs.empty())
            {
Paul Fultz II's avatar
Paul Fultz II committed
711
                output = mod->insert_instruction(mod->end(), op, inputs);
Shucai Xiao's avatar
Shucai Xiao committed
712
713
714
            }
            else
            {
Paul Fultz II's avatar
Paul Fultz II committed
715
                output = mod->insert_instruction(mod->end(), op, inputs, module_inputs);
Shucai Xiao's avatar
Shucai Xiao committed
716
717
718
719
720
721
722
            }
        }
        output->set_normalized(normalized);
        instructions[node.at("output").to<std::string>()] = output;
    }
}

723
724
725
726
void program::from_value(const value& v)
{
    auto version = v.at("version").to<int>();
    if(version != program_file_version)
Shucai Xiao's avatar
Shucai Xiao committed
727
728
729
730
    {
        MIGRAPHX_THROW("Warning: Program version mismatch");
    }

731
732
733
734
735
736
737
738
    this->impl->target_name = v.at("target").to<std::string>();
    if(not this->impl->target_name.empty())
    {
        target t        = make_target(this->impl->target_name);
        this->impl->ctx = t.get_context();
        this->impl->ctx.from_value(v.at("context"));
    }

Shucai Xiao's avatar
Shucai Xiao committed
739
740
    auto module_vals = v.at("modules");
    for(const auto& vv : module_vals)
741
    {
742
        const auto& name = vv.get_key();
Shucai Xiao's avatar
Shucai Xiao committed
743
744
        if(name == "main")
            continue;
745
        impl->modules.emplace(name, name);
746
    }
747
    std::unordered_map<std::string, module_ref> map_mods;
Paul's avatar
Paul committed
748
749
750
751
    std::transform(impl->modules.begin(),
                   impl->modules.end(),
                   std::inserter(map_mods, map_mods.end()),
                   [&](auto&& pp) { return std::make_pair(pp.first, &pp.second); });
Shucai Xiao's avatar
Shucai Xiao committed
752
753
754
755
756

    std::unordered_map<std::string, instruction_ref> map_insts;
    auto* mm = get_main_module();
    mod_from_val(mm, module_vals, map_insts, map_mods);

757
758
759
    this->finalize();
}

Paul's avatar
Paul committed
760
761
762
double common_average(const std::vector<double>& v)
{
    std::size_t n = v.size() / 4;
Paul's avatar
Paul committed
763
764
    double total  = std::accumulate(v.begin() + n, v.end() - n, 0.0);
    return total / std::distance(v.begin() + n, v.end() - n);
Paul's avatar
Paul committed
765
766
}

Paul Fultz II's avatar
Paul Fultz II committed
767
768
769
770
771
772
773
774
std::string perf_group(const operation& op)
{
    auto attr = op.attributes();
    if(attr.contains("group"))
        return attr.at("group").to<std::string>();
    return op.name();
}

775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
void program::mark(const parameter_map& params, marker&& m)
{
    auto& ctx = this->impl->ctx;
    // Run once by itself
    eval(params);
    ctx.finish();
    // Start marking
    m.mark_start(*this);
    generic_eval(*this, ctx, params, always([&](auto ins, auto f) {
        argument result;
        m.mark_start(ins);
        result = f();
        m.mark_stop(ins);
        return result;
    }));
    m.mark_stop(*this);
}

793
794
795
796
void program::perf_report(std::ostream& os,
                          std::size_t n,
                          parameter_map params,
                          std::size_t batch) const
Paul's avatar
Paul committed
797
{
798
    auto& ctx = this->impl->ctx;
Paul's avatar
Paul committed
799
800
    // Run once by itself
    eval(params);
Paul's avatar
Paul committed
801
    ctx.finish();
Paul's avatar
Paul committed
802
    // Run and time entire program
Paul's avatar
Paul committed
803
804
    std::vector<double> total_vec;
    total_vec.reserve(n);
Paul's avatar
Paul committed
805
    for(std::size_t i = 0; i < n; i++)
Paul's avatar
Paul committed
806
    {
Paul's avatar
Paul committed
807
808
809
810
        total_vec.push_back(time<milliseconds>([&] {
            eval(params);
            ctx.finish();
        }));
Paul's avatar
Paul committed
811
    }
Paul's avatar
Paul committed
812
813
    std::sort(total_vec.begin(), total_vec.end());
    std::unordered_map<instruction_ref, std::vector<double>> ins_vec;
Paul's avatar
Paul committed
814
    // Fill the map
815
    generic_eval(*this, ctx, params, always([&](auto ins, auto) {
Paul's avatar
Paul committed
816
        ins_vec[ins].reserve(n);
817
        return argument{ins->get_shape(), nullptr};
818
    }));
819

Paul's avatar
Paul committed
820
    // Run and time each instruction
Paul's avatar
Paul committed
821
    for(std::size_t i = 0; i < n; i++)
Paul's avatar
Paul committed
822
    {
823
        generic_eval(*this, ctx, params, always([&](auto ins, auto f) {
824
            argument result;
Paul's avatar
Paul committed
825
826
827
828
            ins_vec[ins].push_back(time<milliseconds>([&] {
                result = f();
                ctx.finish();
            }));
829
            return result;
830
        }));
Paul's avatar
Paul committed
831
    }
Paul's avatar
Paul committed
832
833
    for(auto&& p : ins_vec)
        std::sort(p.second.begin(), p.second.end());
Paul's avatar
Paul committed
834
    // Run and time implicit overhead
Paul's avatar
Paul committed
835
836
    std::vector<double> overhead_vec;
    overhead_vec.reserve(n);
Paul's avatar
Paul committed
837
    for(std::size_t i = 0; i < n; i++)
Paul's avatar
Paul committed
838
    {
Paul's avatar
Paul committed
839
        overhead_vec.push_back(time<milliseconds>([&] { dry_run(params); }));
Paul's avatar
Paul committed
840
841
    }

Paul's avatar
Paul committed
842
    double total_time             = common_average(total_vec);
Paul's avatar
Paul committed
843
    double rate                   = 1000.0 / total_time;
Paul's avatar
Paul committed
844
    double overhead_time          = common_average(overhead_vec);
Paul's avatar
Paul committed
845
    double overhead_percent       = overhead_time * 100.0 / total_time;
Paul's avatar
Paul committed
846
    double total_instruction_time = 0.0;
Paul's avatar
Paul committed
847
    std::unordered_map<std::string, double> op_times;
848
    std::unordered_map<std::string, std::size_t> op_n;
Paul's avatar
Paul committed
849
    for(auto&& p : ins_vec)
Paul's avatar
Paul committed
850
851
    {
        double avg = common_average(p.second);
Paul Fultz II's avatar
Paul Fultz II committed
852
        op_times[perf_group(p.first->get_operator())] += avg;
Paul's avatar
Paul committed
853
        total_instruction_time += avg;
854
        op_n[perf_group(p.first->get_operator())]++;
Paul's avatar
Paul committed
855
    }
Paul's avatar
Paul committed
856
857
    double calculate_overhead_time    = total_time - total_instruction_time;
    double calculate_overhead_percent = calculate_overhead_time * 100.0 / total_time;
Paul's avatar
Paul committed
858

Shucai Xiao's avatar
Shucai Xiao committed
859
860
861
    std::unordered_map<instruction_ref, std::string> names;
    this->print(names, [&](auto ins, auto ins_names) {
        instruction::print(std::cout, ins, ins_names);
862
863
864
865
866

        // skip return instruction
        if(ins->name() == "@return")
            return;

Paul's avatar
Paul committed
867
868
869
        double avg     = common_average(ins_vec[ins]);
        double percent = std::ceil(100.0 * avg / total_instruction_time);
        os << ": " << avg << "ms, " << percent << "%";
870
        os << std::endl;
Paul's avatar
Paul committed
871
    });
Paul's avatar
Paul committed
872
873
874

    os << std::endl;
    os << "Summary:" << std::endl;
875
876
877
878
879
880
    std::vector<std::tuple<double, std::size_t, std::string>> op_times_sorted;
    std::transform(
        op_times.begin(), op_times.end(), std::back_inserter(op_times_sorted), [&](auto p) {
            auto&& name = p.first;
            return std::make_tuple(p.second, op_n.at(name), name);
        });
881
    std::sort(op_times_sorted.begin(), op_times_sorted.end(), std::greater<>{});
882
    for(auto&& [avg, nn, name] : op_times_sorted)
Paul's avatar
Paul committed
883
884
    {
        double percent = std::ceil(100.0 * avg / total_instruction_time);
885
886
887
        double per_ins = avg / nn;
        os << name << ": " << avg << "ms / " << nn << " = " << per_ins << "ms, " << percent << "%"
           << std::endl;
Paul's avatar
Paul committed
888
889
890
    }

    os << std::endl;
Paul's avatar
Paul committed
891

892
893
    os << "Batch size: " << batch << std::endl;
    os << "Rate: " << rate * batch << "/sec" << std::endl;
Paul's avatar
Paul committed
894
895
    os << "Total time: " << total_time << "ms" << std::endl;
    os << "Total instructions time: " << total_instruction_time << "ms" << std::endl;
Paul's avatar
Paul committed
896
897
898
899
    os << "Overhead time: " << overhead_time << "ms"
       << ", " << calculate_overhead_time << "ms" << std::endl;
    os << "Overhead: " << std::round(overhead_percent) << "%"
       << ", " << std::round(calculate_overhead_percent) << "%" << std::endl;
Paul's avatar
Paul committed
900
901
}

Paul's avatar
Paul committed
902
903
void program::debug_print() const { std::cout << *this << std::endl; }
void program::debug_print(instruction_ref ins) const
Paul's avatar
Paul committed
904
{
Shucai Xiao's avatar
Shucai Xiao committed
905
    std::unordered_map<instruction_ref, std::string> names;
906
    if(std::any_of(this->impl->modules.begin(), this->impl->modules.end(), [&](const auto& pp) {
907
           return is_end(pp.second.end(), ins);
Shucai Xiao's avatar
Shucai Xiao committed
908
       }))
Paul's avatar
Paul committed
909
910
911
912
    {
        std::cout << "End instruction" << std::endl;
        return;
    }
913
914
    else if(std::none_of(this->impl->modules.begin(),
                         this->impl->modules.end(),
915
                         [&](const auto& pp) { return pp.second.has_instruction(ins); }))
Paul's avatar
Paul committed
916
917
918
919
    {
        std::cout << "Instruction not part of program" << std::endl;
        return;
    }
Shucai Xiao's avatar
Shucai Xiao committed
920

Paul's avatar
Paul committed
921
    std::stringstream ss;
Shucai Xiao's avatar
Shucai Xiao committed
922
    this->print(names, [&](auto x, auto ins_names) {
Paul's avatar
Paul committed
923
        if(x == ins)
Paul's avatar
Paul committed
924
        {
Shucai Xiao's avatar
Shucai Xiao committed
925
            instruction::print(std::cout, x, ins_names);
Paul's avatar
Paul committed
926
927
928
929
930
            std::cout << std::endl;
        }
    });
}

Shucai Xiao's avatar
Shucai Xiao committed
931
932
933
934
void program::print(
    std::unordered_map<instruction_ref, std::string>& names,
    const std::function<void(instruction_ref, std::unordered_map<instruction_ref, std::string>)>&
        print_func) const
935
{
936
    for(const auto& pp : this->impl->modules)
937
    {
938
        names = pp.second.print(print_func, names);
939
940
941
    }
}

Shucai Xiao's avatar
Shucai Xiao committed
942
943
944
945
946
947
948
949
void program::print(
    const std::function<void(instruction_ref ins,
                             std::unordered_map<instruction_ref, std::string>)>& print_func) const
{
    std::unordered_map<instruction_ref, std::string> names;
    this->print(names, print_func);
}

Shucai Xiao's avatar
Shucai Xiao committed
950
void program::print_graph(std::ostream& os, bool brief) const
951
{
Shucai Xiao's avatar
Shucai Xiao committed
952
953
    const auto* mm = this->get_main_module();
    mm->print_graph(os, brief);
954
955
}

956
957
958
959
960
961
962
void program::print_py(std::ostream& os) const
{
    auto vec_modules = this->get_modules();
    std::unordered_map<instruction_ref, std::string> names;
    os << "p = migraphx.program()\n";
    for(auto& mod : vec_modules)
    {
963
964
965
        std::string var_name = "m";
        if(mod->name() != "main")
            var_name += mod->name();
966
967
968
969
970
971
972
973
974
975
976
        os << var_name << " = ";
        if(mod->name() == "main")
            os << "p.get_main_module()";
        else
            os << "p.create_module(\"" << mod->name() << "\");";
        os << std::endl;
        names = mod->print_py(os, var_name, names);
        os << std::endl;
    }
}

977
978
void program::print_cpp(std::ostream& os) const
{
Shucai Xiao's avatar
Shucai Xiao committed
979
980
    auto vec_modules = this->get_modules();
    std::unordered_map<instruction_ref, std::string> names;
981
    os << "migraphx::program p;\n";
Shucai Xiao's avatar
Shucai Xiao committed
982
983
    for(auto& mod : vec_modules)
    {
984
985
986
987
988
989
990
991
        std::string var_name = "m" + mod->name();
        os << "migraphx::module_ref " << var_name << " = ";
        if(mod->name() == "main")
            os << "p.get_main_module();";
        else
            os << "p.create_module(\"" << mod->name() << "\");";
        os << std::endl;
        names = mod->print_cpp(os, var_name, names);
Shucai Xiao's avatar
Shucai Xiao committed
992
993
        os << std::endl;
    }
994
995
}

Paul's avatar
Paul committed
996
997
void program::dry_run(std::unordered_map<std::string, argument> params) const
{
Paul's avatar
Paul committed
998
    auto& ctx = this->impl->ctx;
999
1000
1001
    generic_eval(*this, ctx, std::move(params), always([](auto ins, auto&&...) {
        return argument{ins->get_shape(), nullptr};
    }));
Paul's avatar
Paul committed
1002
1003
}

Shucai Xiao's avatar
Shucai Xiao committed
1004
void program::annotate(std::ostream& os, const std::function<void(instruction_ref)>& a) const
Paul's avatar
Paul committed
1005
{
1006
    for(auto& pp : this->impl->modules)
Shucai Xiao's avatar
Shucai Xiao committed
1007
    {
1008
1009
        std::cout << pp.first << ":" << std::endl;
        pp.second.annotate(os, a);
Shucai Xiao's avatar
Shucai Xiao committed
1010
    }
Paul's avatar
Paul committed
1011
1012
}

Paul's avatar
Paul committed
1013
const module* program::get_module(const std::string& name) const { return &impl->modules.at(name); }
Shucai Xiao's avatar
Shucai Xiao committed
1014
1015
1016

module* program::create_module(const std::string& name)
{
1017
    assert(not contains(impl->modules, name));
1018
1019
    auto r = impl->modules.emplace(name, name);
    return &(r.first->second);
Shucai Xiao's avatar
Shucai Xiao committed
1020
1021
}

Paul's avatar
Paul committed
1022
module* program::get_module(const std::string& name) { return &impl->modules.at(name); }
Shucai Xiao's avatar
Shucai Xiao committed
1023
1024
1025
1026
1027

module* program::get_main_module() { return get_module("main"); }

const module* program::get_main_module() const { return get_module("main"); }

Paul's avatar
Paul committed
1028
template <class T>
1029
std::vector<T*> generic_get_modules(T* mm)
Shucai Xiao's avatar
Shucai Xiao committed
1030
{
1031
    std::vector<T*> vec_modules;
Shucai Xiao's avatar
Shucai Xiao committed
1032
1033
1034
1035
1036
    vec_modules.push_back(mm);
    auto sub_modules = mm->get_sub_modules();
    vec_modules.insert(vec_modules.end(), sub_modules.begin(), sub_modules.end());
    return vec_modules;
}
Shucai Xiao's avatar
Shucai Xiao committed
1037

Paul's avatar
Paul committed
1038
template <class Map, class T, class OutputIterator>
1039
void generic_get_unused_modules(Map& m, const std::vector<T*>& mods, OutputIterator out)
Shucai Xiao's avatar
Shucai Xiao committed
1040
{
1041
1042
1043
1044
    std::unordered_set<std::string> used;
    std::transform(mods.begin(), mods.end(), std::inserter(used, used.end()), [](auto&& mod) {
        return mod->name();
    });
bpickrel's avatar
bpickrel committed
1045
1046
1047
1048
1049
1050
    transform_if(
        m.begin(),
        m.end(),
        out,
        [&](auto&& pp) { return not contains(used, pp.first); },
        [](auto&& pp) { return &pp.second; });
1051
}
Shucai Xiao's avatar
Shucai Xiao committed
1052

1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
std::vector<const module*> program::get_modules() const
{
    auto result = generic_get_modules(this->get_main_module());
    generic_get_unused_modules(impl->modules, result, std::back_inserter(result));
    return result;
}

std::vector<module*> program::get_modules()
{
    auto result = generic_get_modules(this->get_main_module());
    generic_get_unused_modules(impl->modules, result, std::back_inserter(result));
    return result;
Shucai Xiao's avatar
Shucai Xiao committed
1065
1066
}

1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
template <class Module, class Map>
void generic_insert_module_tree(Module* pm, Map& m)
{
    for(auto* sm : pm->get_sub_modules(true))
    {
        m.insert(std::make_pair(sm, pm));
        generic_insert_module_tree(sm, m);
    }
}

std::unordered_multimap<module_ref, module_ref> program::get_module_tree()
{
    std::unordered_multimap<module_ref, module_ref> result;
    generic_insert_module_tree(this->get_main_module(), result);
    return result;
}

1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
template <class Map, class T>
bool is_unused_module(Map& m, const std::vector<T*>& mods, const std::string& name)
{
    bool is_unused = false;
    generic_get_unused_modules(m, mods, make_function_output_iterator([&](auto* mod) {
                                   if(mod->name() == name)
                                       is_unused = true;
                               }));
    return is_unused;
}

template <class Map>
bool references_instruction(Map& m, const instruction& ins, const std::string& name)
{
    return std::any_of(m.begin(), m.end(), [&](auto&& p) {
        if(p.first == name)
            return false;
        return std::any_of(p.second.begin(), p.second.end(), [&](auto&& i) {
            return std::any_of(i.inputs().begin(), i.inputs().end(), [&](auto&& j) {
                return std::addressof(*j) == std::addressof(ins);
            });
        });
    });
}

void program::remove_module(const std::string& name)
{
    // cppcheck-suppress assertWithSideEffect
    assert(is_unused_module(impl->modules, generic_get_modules(this->get_main_module()), name) &&
           "Module used in program");
    assert(std::none_of(
               impl->modules.at(name).begin(),
               impl->modules.at(name).end(),
               [&](auto&& ins) { return references_instruction(impl->modules, ins, name); }) &&
           "Instruction referenced in another module");
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134

    // if an instruction has an input out side of the current module, need to remove
    // the instruction from its input's outputs
    auto& mod = impl->modules.at(name);
    for(auto ins : iterator_for(mod))
    {
        auto inputs = ins->inputs();
        for(auto in : inputs)
        {
            if(not mod.has_instruction(in))
            {
                in->remove_output(ins);
            }
        }
    }

1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
    impl->modules.erase(name);
}

void program::remove_unused_modules()
{
    std::vector<module*> unused;
    generic_get_unused_modules(
        impl->modules, generic_get_modules(this->get_main_module()), std::back_inserter(unused));
    for(auto* m : unused)
        this->remove_module(m->name());
}

1147
1148
program& program::sort()
{
1149
    for(auto& pp : this->impl->modules)
Shucai Xiao's avatar
Shucai Xiao committed
1150
    {
1151
        pp.second.sort();
Shucai Xiao's avatar
Shucai Xiao committed
1152
1153
    }

1154
1155
1156
    return *this;
}

Paul's avatar
Paul committed
1157
bool operator==(const program& x, const program& y) { return to_string(x) == to_string(y); }
Paul's avatar
Paul committed
1158

Paul's avatar
Paul committed
1159
std::ostream& operator<<(std::ostream& os, const program& p)
Paul's avatar
Paul committed
1160
{
Shucai Xiao's avatar
Shucai Xiao committed
1161
1162
1163
    auto vec_modules = p.get_modules();
    std::unordered_map<instruction_ref, std::string> names;
    for(auto& mod : vec_modules)
Shucai Xiao's avatar
Shucai Xiao committed
1164
    {
Shucai Xiao's avatar
Shucai Xiao committed
1165
1166
1167
1168
1169
1170
1171
        os << "module: \"" << mod->name() << "\"" << std::endl;
        names = mod->print(
            [&](auto ins, auto ins_names) {
                instruction::print(os, ins, ins_names);
                os << std::endl;
            },
            names);
1172
        os << std::endl;
Shucai Xiao's avatar
Shucai Xiao committed
1173
1174
    }

Paul's avatar
Paul committed
1175
    return os;
Paul's avatar
Paul committed
1176
}
Paul's avatar
Paul committed
1177

Paul's avatar
Paul committed
1178
} // namespace MIGRAPHX_INLINE_NS
Paul's avatar
Paul committed
1179
} // namespace migraphx