program.cpp 18.4 KB
Newer Older
Paul's avatar
Paul committed
1
2
3
#include <migraphx/program.hpp>
#include <migraphx/stringutils.hpp>
#include <migraphx/instruction.hpp>
4
#include <migraphx/op/identity.hpp>
Paul's avatar
Paul committed
5
#include <migraphx/target.hpp>
Paul's avatar
Paul committed
6
7
8
9
#include <migraphx/env.hpp>
#include <migraphx/ranges.hpp>
#include <migraphx/time.hpp>
#include <migraphx/iterator_for.hpp>
Paul's avatar
Paul committed
10
#include <iostream>
Paul's avatar
Paul committed
11
#include <sstream>
Paul's avatar
Paul committed
12
#include <algorithm>
Paul's avatar
Paul committed
13
#include <utility>
Paul's avatar
Paul committed
14

Paul's avatar
Paul committed
15
namespace migraphx {
Paul's avatar
Paul committed
16
inline namespace MIGRAPHX_INLINE_NS {
Paul's avatar
Paul committed
17

Paul's avatar
Paul committed
18
19
20
21
struct program_impl
{
    // A list is used to keep references to an instruction stable
    std::list<instruction> instructions;
Paul's avatar
Paul committed
22
    context ctx;
Paul's avatar
Paul committed
23
24
};

25
const operation& get_operation(instruction_ref ins) { return ins->get_operator(); }
Paul's avatar
Paul committed
26

Paul's avatar
Paul committed
27
28
29
static void print_instruction(std::ostream& os,
                              instruction_ref ins,
                              const std::unordered_map<instruction_ref, std::string>& names)
Paul's avatar
Paul committed
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
{
    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())
        {
            os << delim << names.at(arg);
            delim = ',';
        }
        os << ")";
    }
Paul's avatar
Paul committed
53

Paul's avatar
Paul committed
54
55
56
    os << " -> " << ins->get_shape();
}

57
58
59
60
61
62
63
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
static std::string enclose_name(const std::string& name)
{
    return '"' + name + '"';
}

static void print_graph_node(std::ostream& os,
                              instruction_ref ins,
                              const std::unordered_map<instruction_ref, std::string>& names)
{
    os << "\t";

    if(!ins->inputs().empty())
    {
        char delim = '{';
        for(auto&& arg : ins->inputs())
        {
            os << delim << enclose_name(names.at(arg));
            delim = ' ';
        }
        os << '}';
        os << " -> ";
    }
    os << enclose_name(names.at(ins)) << ";";
    // if(ins->name() == "@literal")
    // {
    //     if(ins->get_literal().get_shape().elements() > 10)
    //         os << "{ ... }";
    //     else
    //         os << "{" << ins->get_literal() << "}";
    // }

}

Paul's avatar
Paul committed
90
template <class F>
91
92
static void print_program(std::ostream& os, const program& p, F annonate, 
        std::function<void(std::ostream&,instruction_ref,const std::unordered_map<instruction_ref, std::string>&)>print_func=print_instruction)
Paul's avatar
Paul committed
93
{
94
    std::unordered_map<instruction_ref, std::string> names;
Paul's avatar
Paul committed
95
96
    int count = 0;

97
    for(auto ins : iterator_for(p))
Paul's avatar
Paul committed
98
99
    {
        std::string var_name = "@" + std::to_string(count);
Paul's avatar
Paul committed
100
        if(ins->name() == "@param")
Paul's avatar
Paul committed
101
        {
102
            var_name = any_cast<builtin::param>(ins->get_operator()).parameter;
Paul's avatar
Paul committed
103
        }
Paul's avatar
Paul committed
104
        names.emplace(ins, var_name);
Paul's avatar
Paul committed
105

Paul's avatar
Paul committed
106
107
        // TODO: Use all_of
        for(auto&& arg : ins->inputs())
Paul's avatar
Paul committed
108
        {
Paul's avatar
Paul committed
109
110
            assert(p.has_instruction(arg) && "Instruction not found");
            (void)arg;
Paul's avatar
Paul committed
111
112
        }

113
        print_func(os, ins, names);
Paul's avatar
Paul committed
114

Paul's avatar
Paul committed
115
        annonate(ins, names);
Paul's avatar
Paul committed
116
117
118
119
120
121
122

        os << std::endl;

        count++;
    }
}

Paul's avatar
Paul committed
123
program::program() : impl(std::make_unique<program_impl>()) {}
Paul's avatar
Paul committed
124

Paul's avatar
Paul committed
125
program::program(program&&) noexcept = default;
Paul's avatar
Paul committed
126
127
program& program::operator=(program&&) noexcept = default;
program::~program() noexcept                    = default;
Paul's avatar
Paul committed
128

Paul's avatar
Paul committed
129
instruction_ref program::add_instruction(const operation& op, std::vector<instruction_ref> args)
Paul's avatar
Paul committed
130
{
Paul's avatar
Paul committed
131
    return insert_instruction(impl->instructions.end(), op, std::move(args));
Paul's avatar
Paul committed
132
}
Paul's avatar
Paul committed
133
134
135
instruction_ref program::insert_instruction(instruction_ref ins,
                                            const operation& op,
                                            std::vector<instruction_ref> args)
Paul's avatar
Paul committed
136
{
Paul's avatar
Paul committed
137
138
139
    assert(std::all_of(
               args.begin(), args.end(), [&](instruction_ref x) { return has_instruction(x); }) &&
           "Argument is not an exisiting instruction");
Paul's avatar
Paul committed
140
    assert(not starts_with(op.name(), "@"));
Paul's avatar
Paul committed
141
    shape r     = compute_shape(op, args);
Paul's avatar
Paul committed
142
    auto result = impl->instructions.insert(ins, {op, r, std::move(args)});
Paul's avatar
Paul committed
143
    instruction::backreference(result);
Paul's avatar
Paul committed
144
    assert(result->valid(begin()));
Paul's avatar
Paul committed
145
    return result;
Paul's avatar
Paul committed
146
147
}

Paul's avatar
Paul committed
148
149
150
instruction_ref program::replace_instruction(instruction_ref ins,
                                             const operation& op,
                                             std::vector<instruction_ref> args)
Paul's avatar
Paul committed
151
152
153
154
{
    assert(std::all_of(
               args.begin(), args.end(), [&](instruction_ref x) { return has_instruction(x); }) &&
           "Argument is not an exisiting instruction");
Paul's avatar
Paul committed
155
    assert(not starts_with(op.name(), "@"));
Paul's avatar
Paul committed
156

Paul's avatar
Paul committed
157
    shape r = compute_shape(op, args);
158
    instruction::replace(ins, op, r, std::move(args));
Paul's avatar
Paul committed
159
    assert(ins->valid(begin()));
Paul's avatar
Paul committed
160
161
162
    return ins;
}

Paul's avatar
Paul committed
163
instruction_ref program::replace_instruction(instruction_ref ins, instruction_ref rep)
Paul's avatar
Paul committed
164
{
Paul's avatar
Paul committed
165
166
167
    assert(has_instruction(ins));
    assert(has_instruction(rep));
    assert(ins != rep);
Shucai Xiao's avatar
Shucai Xiao committed
168

Shucai Xiao's avatar
Shucai Xiao committed
169
    if(ins == std::prev(this->end()))
Shucai Xiao's avatar
Shucai Xiao committed
170
    {
Shucai Xiao's avatar
Shucai Xiao committed
171
        return replace_instruction(ins, op::identity{}, rep);
Shucai Xiao's avatar
Shucai Xiao committed
172
173
    }

Paul's avatar
Paul committed
174
    // TODO: Should it be an error if the output is empty?
Paul's avatar
Paul committed
175
    if(ins->outputs().empty())
Paul's avatar
Paul committed
176
177
178
    {
        return rep;
    }
Paul's avatar
Paul committed
179
180
181
    // Make a copy of outputs which can be changed when calling replace_argument
    auto outputs = ins->outputs();
    for(auto out : outputs)
Paul's avatar
Paul committed
182
    {
Paul's avatar
Paul committed
183
184
        // TODO: Check for possible cycles
        if(out != rep)
Paul's avatar
Paul committed
185
        {
Paul's avatar
Paul committed
186
            instruction::replace_argument(out, ins, rep);
Paul's avatar
Paul committed
187
        }
Paul's avatar
Paul committed
188
        assert(out->valid(begin()));
Paul's avatar
Paul committed
189
    }
Paul's avatar
Paul committed
190
    // Replacement should not be dead code unless its the last instruction
Paul's avatar
Paul committed
191
    assert(!rep->outputs().empty() or rep == std::prev(end()));
Paul's avatar
Paul committed
192
    // Output of the original instruction should only be the replacement or empty
Paul's avatar
Paul committed
193
194
195
    assert(ins->outputs().empty() or std::all_of(ins->outputs().begin(),
                                                 ins->outputs().end(),
                                                 [&](auto i) { return i == rep; }));
Paul's avatar
Paul committed
196
    assert(ins->valid(begin()));
Paul's avatar
Paul committed
197
    assert(rep->valid(begin()));
Paul's avatar
Paul committed
198
199
200
    return rep;
}

Paul's avatar
Paul committed
201
instruction_ref program::remove_instruction(instruction_ref ins)
Paul's avatar
Paul committed
202
203
{
    assert(has_instruction(ins));
Paul's avatar
Paul committed
204
    assert(ins->outputs().empty());
Paul's avatar
Paul committed
205
206
207
208
    ins->clear_arguments();
    return impl->instructions.erase(ins);
}

209
210
instruction_ref program::remove_instructions(instruction_ref first, instruction_ref last)
{
Paul's avatar
Paul committed
211
212
    if(first == last)
        return first;
Paul's avatar
Paul committed
213
    // TODO: Check every element
214
    assert(has_instruction(first));
Paul's avatar
Paul committed
215
    std::for_each(first, last, [&](instruction& ins) { ins.clear_arguments(); });
Paul's avatar
Paul committed
216
    assert(std::all_of(first, last, [&](instruction& ins) { return ins.outputs().empty(); }));
217
218
219
220
221
222
223
224
225
    return impl->instructions.erase(first, last);
}

instruction_ref program::move_instruction(instruction_ref src, instruction_ref dst)
{
    impl->instructions.splice(dst, impl->instructions, src);
    return src;
}

Paul's avatar
Paul committed
226
instruction_ref program::add_literal(literal l)
Paul's avatar
Paul committed
227
{
Paul's avatar
Paul committed
228
229
230
231
    impl->instructions.emplace_front(std::move(l));
    return impl->instructions.begin();
}

Paul's avatar
Paul committed
232
instruction_ref program::add_outline(const shape& s)
Paul's avatar
Paul committed
233
234
235
{
    impl->instructions.push_front({builtin::outline{s}, s, {}});
    return impl->instructions.begin();
Paul's avatar
Paul committed
236
237
}

Paul's avatar
Paul committed
238
instruction_ref program::add_parameter(std::string name, shape s)
Paul's avatar
Paul committed
239
{
240
    assert(get_parameter_shape(name) == shape{});
Paul's avatar
Paul committed
241
    impl->instructions.push_front({builtin::param{std::move(name)}, std::move(s), {}});
Paul's avatar
Paul committed
242
243
244
    return impl->instructions.begin();
}

Paul's avatar
Paul committed
245
shape program::get_parameter_shape(std::string name) const
Paul's avatar
Paul committed
246
247
{
    auto ins = std::find_if(
Paul's avatar
Paul committed
248
        impl->instructions.begin(), impl->instructions.end(), [&](const instruction& x) {
Paul's avatar
Paul committed
249
            if(x.name() == "@param")
Paul's avatar
Paul committed
250
            {
251
                return any_cast<builtin::param>(x.get_operator()).parameter == name;
Paul's avatar
Paul committed
252
253
254
255
256
257
258
            }
            else
            {
                return false;
            }
        });
    if(ins != this->end())
Paul's avatar
Paul committed
259
        return ins->get_shape();
Paul's avatar
Paul committed
260
261
    else
        return {};
Paul's avatar
Paul committed
262
263
}

mei-ye's avatar
mei-ye committed
264
265
266
267
instruction_ref program::get_parameter(std::string name) const
{
    auto ins = std::find_if(
        impl->instructions.begin(), impl->instructions.end(), [&](const instruction& x) {
Paul's avatar
Paul committed
268
            if(x.name() == "@param")
mei-ye's avatar
mei-ye committed
269
            {
Paul's avatar
Paul committed
270
                return any_cast<builtin::param>(x.get_operator()).parameter == name;
mei-ye's avatar
mei-ye committed
271
272
273
274
275
276
277
278
279
            }
            else
            {
                return false;
            }
        });
    if(ins != this->end())
        return ins;
    else
mei-ye's avatar
mei-ye committed
280
        return this->end();
mei-ye's avatar
mei-ye committed
281
282
}

Paul's avatar
Paul committed
283
284
285
std::unordered_map<std::string, shape> program::get_parameter_shapes() const
{
    std::unordered_map<std::string, shape> result;
Paul's avatar
Paul committed
286
    for(auto&& ins : impl->instructions)
Paul's avatar
Paul committed
287
    {
Paul's avatar
Paul committed
288
        if(ins.name() == "@param")
Paul's avatar
Paul committed
289
        {
290
            auto&& name  = any_cast<builtin::param>(ins.get_operator()).parameter;
Paul's avatar
Paul committed
291
            result[name] = ins.get_shape();
Paul's avatar
Paul committed
292
293
294
295
296
        }
    }
    return result;
}

Paul's avatar
Paul committed
297
bool program::has_instruction(instruction_ref ins) const
Paul's avatar
Paul committed
298
{
Paul's avatar
Paul committed
299
300
301
302
    return std::find_if(
               impl->instructions.begin(), impl->instructions.end(), [&](const instruction& x) {
                   return std::addressof(*ins) == std::addressof(x);
               }) != impl->instructions.end();
Paul's avatar
Paul committed
303
304
}

Paul's avatar
Paul committed
305
std::size_t program::size() const { return impl->instructions.size(); }
Paul's avatar
Paul committed
306
307
instruction_ref program::begin() const { return impl->instructions.begin(); }
instruction_ref program::end() const { return impl->instructions.end(); }
308

Paul's avatar
Paul committed
309
shape program::get_shape() const { return impl->instructions.back().get_shape(); }
Paul's avatar
Paul committed
310

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

Paul's avatar
Paul committed
313
314
instruction_ref program::validate() const
{
Paul's avatar
Paul committed
315
316
    return std::find_if(impl->instructions.begin(),
                        impl->instructions.end(),
Paul's avatar
Paul committed
317
                        [&](const instruction& i) { return !i.valid(impl->instructions.begin()); });
Paul's avatar
Paul committed
318
319
}

mei-ye's avatar
mei-ye committed
320
void program::compile(const target& t, tracer trace)
Paul's avatar
Paul committed
321
{
Paul's avatar
Paul committed
322
    assert(this->validate() == impl->instructions.end());
mei-ye's avatar
mei-ye committed
323
    this->impl->ctx = t.get_context();
Paul's avatar
Paul committed
324
    if(enabled(MIGRAPHX_TRACE_COMPILE{}))
Paul's avatar
Paul committed
325
326
327
        trace = tracer{std::cout};
    trace(*this);
    trace();
Paul's avatar
Paul committed
328
    for(auto&& p : t.get_passes(this->impl->ctx))
Paul's avatar
Paul committed
329
    {
Paul's avatar
Paul committed
330
        trace("Pass: ", p.name());
Paul's avatar
Paul committed
331
        p.apply(*this);
Paul's avatar
Paul committed
332
        trace(*this);
Paul's avatar
Paul committed
333
#ifndef NDEBUG
Paul's avatar
Paul committed
334
        trace("Validate ...");
Paul's avatar
Paul committed
335
        auto invalid = this->validate();
Paul's avatar
Paul committed
336
337
        if(invalid != impl->instructions.end())
        {
Paul's avatar
Paul committed
338
            auto index = std::distance(impl->instructions.begin(), invalid);
Paul's avatar
Paul committed
339
            MIGRAPHX_THROW(p.name() + " pass produces invalid program at instruction " +
Paul's avatar
Paul committed
340
                           std::to_string(index) + ": " + invalid->name());
Paul's avatar
Paul committed
341
        }
Paul's avatar
Paul committed
342
        trace();
Paul's avatar
Paul committed
343
344
#endif
    }
Paul's avatar
Paul committed
345
    auto invalid = this->validate();
Paul's avatar
Paul committed
346
347
    if(invalid != impl->instructions.end())
    {
Paul's avatar
Paul committed
348
        auto index = std::distance(impl->instructions.begin(), invalid);
Paul's avatar
Paul committed
349
        MIGRAPHX_THROW("Invalid program from compilation at instruction " + std::to_string(index));
Paul's avatar
Paul committed
350
    }
Paul's avatar
Paul committed
351
352
353
354
355
356
357
358
359
    this->finalize();
}

void program::finalize()
{
    for(auto ins : iterator_for(*this))
    {
        ins->finalize(this->impl->ctx);
    }
Paul's avatar
Paul committed
360
361
}

Paul's avatar
Paul committed
362
363
364
365
366
template <class F>
argument generic_eval(const program& p,
                      context& ctx,
                      std::unordered_map<std::string, argument> params,
                      F trace)
Paul's avatar
Paul committed
367
{
Paul's avatar
Paul committed
368
    assert(p.validate() == p.end());
369
    std::unordered_map<instruction_ref, argument> results;
Paul's avatar
Paul committed
370
    results.reserve(p.size() * 2);
Paul's avatar
Paul committed
371
372
    std::vector<argument> values;
    values.reserve(16);
373
    for(auto ins : iterator_for(p))
Paul's avatar
Paul committed
374
    {
Paul's avatar
Paul committed
375
        if(ins->name() == "@literal")
Paul's avatar
Paul committed
376
        {
Paul's avatar
Paul committed
377
            results.emplace(ins, trace(ins, [&] { return ins->get_literal().get_argument(); }));
Paul's avatar
Paul committed
378
        }
Paul's avatar
Paul committed
379
        else if(ins->name() == "@param")
Paul's avatar
Paul committed
380
        {
Paul's avatar
Paul committed
381
382
383
384
385
386
387
388
389
390
391
            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);
                    auto param = params.at(param_name);
                    if(param.get_shape() != ins->get_shape())
                        MIGRAPHX_THROW("Incorrect shape {" + to_string(param.get_shape()) +
                                       "} for parameter: " + param_name);
                    return param;
                }));
Paul's avatar
Paul committed
392
        }
Paul's avatar
Paul committed
393
        else if(ins->name() == "@outline")
Paul's avatar
Paul committed
394
        {
Paul's avatar
Paul committed
395
            results.emplace(ins, trace(ins, [&] { return argument{ins->get_shape(), nullptr}; }));
Paul's avatar
Paul committed
396
        }
Paul's avatar
Paul committed
397
398
        else
        {
Paul's avatar
Paul committed
399
            values.resize(ins->inputs().size());
Paul's avatar
Paul committed
400
401
402
403
404
            std::transform(
                ins->inputs().begin(), ins->inputs().end(), values.begin(), [&](instruction_ref i) {
                    assert(results.find(i) != results.end());
                    return results[i];
                });
Paul's avatar
Paul committed
405
406
407
            results.emplace(ins, trace(ins, [&] {
                                return ins->get_operator().compute(ctx, ins->get_shape(), values);
                            }));
Paul's avatar
Paul committed
408
        }
409
        assert(results.find(ins) != results.end());
Paul's avatar
Paul committed
410
    }
411
    return results.at(std::prev(p.end()));
Paul's avatar
Paul committed
412
413
}

Paul's avatar
Paul committed
414
415
argument program::eval(std::unordered_map<std::string, argument> params) const
{
Paul's avatar
Paul committed
416
417
    auto& ctx = this->impl->ctx;
#ifndef NDEBUG
Paul's avatar
Paul committed
418
    auto sctx          = ctx;
Paul's avatar
Paul committed
419
420
421
    auto check_context = [&](auto f) {
        assert(is_shared(ctx, sctx));
        auto x = f();
Paul's avatar
Paul committed
422
        sctx   = ctx;
Paul's avatar
Paul committed
423
424
425
        return x;
    };
#else
Paul's avatar
Paul committed
426
    auto check_context = [](auto f) { return f(); };
Paul's avatar
Paul committed
427
#endif
Paul's avatar
Paul committed
428
    if(enabled(MIGRAPHX_TRACE_EVAL{}))
Paul's avatar
Paul committed
429
    {
Paul's avatar
Paul committed
430
        return generic_eval(*this, ctx, std::move(params), [&](auto& ins, auto f) {
Paul's avatar
Paul committed
431
            ctx.finish();
Paul's avatar
Paul committed
432
433
            std::cout << "Run instruction: ";
            this->debug_print(ins);
Paul's avatar
Paul committed
434
            return check_context(f);
Paul's avatar
Paul committed
435
        });
Paul's avatar
Paul committed
436
437
438
439
    }
    else
    {
        return generic_eval(
Paul's avatar
Paul committed
440
            *this, ctx, std::move(params), [&](auto&, auto f) { return check_context(f); });
Paul's avatar
Paul committed
441
    }
Paul's avatar
Paul committed
442
443
}

Paul's avatar
Paul committed
444
445
446
double common_average(const std::vector<double>& v)
{
    std::size_t n = v.size() / 4;
Paul's avatar
Paul committed
447
448
    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
449
450
}

Paul's avatar
Paul committed
451
452
453
void program::perf_report(std::ostream& os, std::size_t n, parameter_map params) const
{
    using milliseconds = std::chrono::duration<double, std::milli>;
Paul's avatar
Paul committed
454
    auto& ctx          = this->impl->ctx;
Paul's avatar
Paul committed
455
456
    // Run once by itself
    eval(params);
Paul's avatar
Paul committed
457
    ctx.finish();
Paul's avatar
Paul committed
458
    // Run and time entire program
Paul's avatar
Paul committed
459
460
    std::vector<double> total_vec;
    total_vec.reserve(n);
Paul's avatar
Paul committed
461
    for(std::size_t i = 0; i < n; i++)
Paul's avatar
Paul committed
462
    {
Paul's avatar
Paul committed
463
464
465
466
        total_vec.push_back(time<milliseconds>([&] {
            eval(params);
            ctx.finish();
        }));
Paul's avatar
Paul committed
467
    }
Paul's avatar
Paul committed
468
469
    std::sort(total_vec.begin(), total_vec.end());
    std::unordered_map<instruction_ref, std::vector<double>> ins_vec;
Paul's avatar
Paul committed
470
    // Fill the map
Paul's avatar
Paul committed
471
    generic_eval(*this, ctx, params, [&](auto ins, auto) {
Paul's avatar
Paul committed
472
        ins_vec[ins].reserve(n);
Paul's avatar
Paul committed
473
474
        return argument{};
    });
Paul's avatar
Paul committed
475
    // Run and time each instruction
Paul's avatar
Paul committed
476
    for(std::size_t i = 0; i < n; i++)
Paul's avatar
Paul committed
477
    {
Paul's avatar
Paul committed
478
        generic_eval(*this, ctx, params, [&](auto ins, auto f) {
479
            argument result;
Paul's avatar
Paul committed
480
481
482
483
            ins_vec[ins].push_back(time<milliseconds>([&] {
                result = f();
                ctx.finish();
            }));
484
            return result;
Paul's avatar
Paul committed
485
486
        });
    }
Paul's avatar
Paul committed
487
488
    for(auto&& p : ins_vec)
        std::sort(p.second.begin(), p.second.end());
Paul's avatar
Paul committed
489
    // Run and time implicit overhead
Paul's avatar
Paul committed
490
491
    std::vector<double> overhead_vec;
    overhead_vec.reserve(n);
Paul's avatar
Paul committed
492
    for(std::size_t i = 0; i < n; i++)
Paul's avatar
Paul committed
493
    {
Paul's avatar
Paul committed
494
        overhead_vec.push_back(time<milliseconds>([&] { dry_run(params); }));
Paul's avatar
Paul committed
495
496
    }

Paul's avatar
Paul committed
497
    double total_time             = common_average(total_vec);
Paul's avatar
Paul committed
498
    double rate                   = 1000.0 / total_time;
Paul's avatar
Paul committed
499
    double overhead_time          = common_average(overhead_vec);
Paul's avatar
Paul committed
500
    double overhead_percent       = overhead_time * 100.0 / total_time;
Paul's avatar
Paul committed
501
    double total_instruction_time = 0.0;
Paul's avatar
Paul committed
502
    std::unordered_map<std::string, double> op_times;
Paul's avatar
Paul committed
503
    for(auto&& p : ins_vec)
Paul's avatar
Paul committed
504
505
    {
        double avg = common_average(p.second);
Paul's avatar
Paul committed
506
        op_times[p.first->name()] += avg;
Paul's avatar
Paul committed
507
508
        total_instruction_time += avg;
    }
Paul's avatar
Paul committed
509
510
    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
511

Paul's avatar
Paul committed
512
513
514
515
516
    print_program(os, *this, [&](auto ins, auto&&) {
        double avg     = common_average(ins_vec[ins]);
        double percent = std::ceil(100.0 * avg / total_instruction_time);
        os << ": " << avg << "ms, " << percent << "%";
    });
Paul's avatar
Paul committed
517
518
519

    os << std::endl;
    os << "Summary:" << std::endl;
Paul's avatar
Paul committed
520
    for(auto&& p : op_times)
Paul's avatar
Paul committed
521
    {
Paul's avatar
Paul committed
522
523
        auto&& name    = p.first;
        double avg     = p.second;
Paul's avatar
Paul committed
524
525
526
527
528
        double percent = std::ceil(100.0 * avg / total_instruction_time);
        os << name << ": " << avg << "ms, " << percent << "%" << std::endl;
    }

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

Paul's avatar
Paul committed
530
    os << "Rate: " << rate << "/sec" << std::endl;
Paul's avatar
Paul committed
531
532
    os << "Total time: " << total_time << "ms" << std::endl;
    os << "Total instructions time: " << total_instruction_time << "ms" << std::endl;
Paul's avatar
Paul committed
533
534
535
536
    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
537
538
}

Paul's avatar
Paul committed
539
540
void program::debug_print() const { std::cout << *this << std::endl; }
void program::debug_print(instruction_ref ins) const
Paul's avatar
Paul committed
541
{
Paul's avatar
Paul committed
542
543
544
545
546
547
548
549
550
551
    if(ins == this->end())
    {
        std::cout << "End instruction" << std::endl;
        return;
    }
    if(not has_instruction(ins))
    {
        std::cout << "Instruction not part of program" << std::endl;
        return;
    }
Paul's avatar
Paul committed
552
553
    std::stringstream ss;
    print_program(ss, *this, [&](auto x, auto&& names) {
Paul's avatar
Paul committed
554
        if(x == ins)
Paul's avatar
Paul committed
555
556
557
558
559
560
        {
            print_instruction(std::cout, x, names);
            std::cout << std::endl;
        }
    });
}
Paul's avatar
Paul committed
561
void program::debug_print(const std::vector<instruction_ref>& inss) const
Paul's avatar
Paul committed
562
{
Paul's avatar
Paul committed
563
    for(auto ins : inss)
Paul's avatar
Paul committed
564
565
566
567
        debug_print(ins);
    std::cout << std::endl;
}

568
569
570
571
572
573
574
575
void program::print_graph(std::ostream& os) const
{
    os << "digraph {" << std::endl;
    os << "\trankdir=LR;" << std::endl;
    print_program(os, *this, [](auto&&...) {}, print_graph_node);
    os << "}" << std::endl;
}

Paul's avatar
Paul committed
576
577
void program::dry_run(std::unordered_map<std::string, argument> params) const
{
Paul's avatar
Paul committed
578
    auto& ctx = this->impl->ctx;
Paul's avatar
Paul committed
579
    generic_eval(*this, ctx, std::move(params), [](auto&&...) { return argument{}; });
Paul's avatar
Paul committed
580
581
}

Paul's avatar
Paul committed
582
583
584
585
586
void program::annotate(std::ostream& os, std::function<void(instruction_ref)> a) const
{
    print_program(os, *this, [&](auto ins, auto&&) { a(ins); });
}

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

Paul's avatar
Paul committed
589
std::ostream& operator<<(std::ostream& os, const program& p)
Paul's avatar
Paul committed
590
{
Paul's avatar
Paul committed
591
    print_program(os, p, [](auto&&...) {});
Paul's avatar
Paul committed
592
    return os;
Paul's avatar
Paul committed
593
}
Paul's avatar
Paul committed
594

Paul's avatar
Paul committed
595
} // namespace MIGRAPHX_INLINE_NS
Paul's avatar
Paul committed
596
} // namespace migraphx