"third_party/vscode:/vscode.git/clone" did not exist on "f5d79493010d8e8475e178f204cc7b234aceb051"
miopen.cpp 37.1 KB
Newer Older
Paul's avatar
Paul committed
1

Paul's avatar
Paul committed
2
3
4
5
6
7
8
9
10
11
12
#include <migraphx/program.hpp>
#include <migraphx/operators.hpp>
#include <migraphx/generate.hpp>
#include <migraphx/cpu/target.hpp>
#include <migraphx/gpu/target.hpp>
#include <migraphx/gpu/miopen.hpp>
#include <migraphx/gpu/hip.hpp>
#include <migraphx/manage_ptr.hpp>
#include <migraphx/type_name.hpp>
#include <migraphx/verify_args.hpp>
#include <migraphx/instruction.hpp>
Paul's avatar
Paul committed
13
14
15

#include <miopen/miopen.h>

Paul's avatar
Paul committed
16
17
18
#include <future>
#include <thread>

Paul's avatar
Paul committed
19
20
#include "test.hpp"

Paul's avatar
Paul committed
21
22
23
24
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wglobal-constructors"
#endif
Paul's avatar
Paul committed
25

Paul's avatar
Paul committed
26
27
// An improved async, that doesn't block
template <class Function>
Paul's avatar
Paul committed
28
29
std::future<typename std::result_of<Function()>::type> detach_async(Function&& f,
                                                                    bool parallel = true)
Paul's avatar
Paul committed
30
{
Paul's avatar
Paul committed
31
32
33
34
35
36
37
38
    if(parallel)
    {
        using result_type = typename std::result_of<Function()>::type;
        std::packaged_task<result_type()> task(std::forward<Function>(f));
        auto fut = task.get_future();
        std::thread(std::move(task)).detach();
        return std::move(fut);
    }
39
    return std::async(std::launch::deferred, std::forward<Function>(f));
Paul's avatar
Paul committed
40
41
}

Paul's avatar
Paul committed
42
43
struct auto_print
{
Paul's avatar
Paul committed
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
    static void set_terminate_handler(const std::string& name)
    {
        static std::string pname;
        pname = name;
        std::set_terminate(+[] {
            std::cout << "FAILED: " << pname << std::endl;
            try
            {
                std::rethrow_exception(std::current_exception());
            }
            catch(const std::exception& e)
            {
                std::cout << "    what(): " << e.what() << std::endl;
            }
            std::cout << std::endl;
            for(auto&& handle : auto_print::handlers)
                handle();
        });
    }
Paul's avatar
Paul committed
63
    static std::array<std::function<void()>, 2> handlers;
Paul's avatar
Paul committed
64
    int index;
Paul's avatar
Paul committed
65
    template <class T>
Paul's avatar
Paul committed
66
    auto_print(T& x, int i) : index(i)
Paul's avatar
Paul committed
67
    {
Paul's avatar
Paul committed
68
        handlers[index] = [&x] { std::cout << x << std::endl; };
Paul's avatar
Paul committed
69
    }
Paul's avatar
Paul committed
70

Paul's avatar
Paul committed
71
    ~auto_print()
Paul's avatar
Paul committed
72
    {
Paul's avatar
Paul committed
73
        handlers[index] = [] {};
Paul's avatar
Paul committed
74
75
    }
};
Paul's avatar
Paul committed
76
std::array<std::function<void()>, 2> auto_print::handlers = {};
Paul's avatar
Paul committed
77

Paul's avatar
Paul committed
78
template <class T>
Paul's avatar
Latest  
Paul committed
79
80
81
82
83
auto get_hash(const T& x)
{
    return std::hash<T>{}(x);
}

Paul's avatar
Paul committed
84
void compile_check(migraphx::program& p, const migraphx::target& t)
Paul's avatar
Paul committed
85
86
{
    auto name = t.name();
Paul's avatar
Paul committed
87
    auto s    = p.get_shape();
Paul's avatar
Paul committed
88
    std::stringstream ss;
Paul's avatar
Paul committed
89
    p.compile(t, migraphx::tracer{ss});
Paul's avatar
Paul committed
90
    if(p.get_shape() != s)
Paul's avatar
Paul committed
91
92
93
94
95
96
    {
        std::cout << ss.str() << std::endl;
        throw std::runtime_error("Compiling program with " + name + " alters its shape");
    }
}

Paul's avatar
Paul committed
97
template <class V>
Paul's avatar
Paul committed
98
migraphx::argument run_cpu(migraphx::program& p)
Paul's avatar
Paul committed
99
{
Paul's avatar
Paul committed
100
    V v;
Paul's avatar
Paul committed
101
    p = v.create_program();
Paul's avatar
Paul committed
102
    auto_print pp{p, 0};
Paul's avatar
Paul committed
103
104
    compile_check(p, migraphx::cpu::target{});
    migraphx::program::parameter_map m;
Paul's avatar
Paul committed
105
    for(auto&& x : p.get_parameter_shapes())
Paul's avatar
Paul committed
106
    {
Paul's avatar
Paul committed
107
        m[x.first] = migraphx::generate_argument(x.second, get_hash(x.first));
Paul's avatar
Paul committed
108
    }
Paul's avatar
Paul committed
109
    return p.eval(m);
Paul's avatar
Paul committed
110
111
}

Paul's avatar
Paul committed
112
template <class V>
Paul's avatar
Paul committed
113
migraphx::argument run_gpu(migraphx::program& p)
Paul's avatar
Paul committed
114
{
Paul's avatar
Paul committed
115
    V v;
Paul's avatar
Paul committed
116
    p = v.create_program();
Paul's avatar
Paul committed
117
    auto_print pp{p, 1};
Paul's avatar
Paul committed
118
119
    compile_check(p, migraphx::gpu::target{});
    migraphx::program::parameter_map m;
Paul's avatar
Paul committed
120
    for(auto&& x : p.get_parameter_shapes())
Paul's avatar
Paul committed
121
    {
Paul's avatar
Paul committed
122
123
        m[x.first] =
            migraphx::gpu::to_gpu(migraphx::generate_argument(x.second, get_hash(x.first)));
Paul's avatar
Paul committed
124
    }
Paul's avatar
Paul committed
125
    EXPECT(bool{m.find("output") != m.end()});
Paul's avatar
Paul committed
126
    return migraphx::gpu::from_gpu(p.eval(m));
Paul's avatar
Paul committed
127
128
}

Paul's avatar
Paul committed
129
130
131
template <class V>
void verify_program()
{
Paul's avatar
Paul committed
132
133
134
135
    auto_print::set_terminate_handler(migraphx::get_type_name<V>());
    // std::cout << migraphx::get_type_name<V>() << std::endl;
    migraphx::program cpu_prog;
    migraphx::program gpu_prog;
Paul's avatar
Paul committed
136
137
    auto cpu_arg_f = detach_async([&] { return run_cpu<V>(cpu_prog); });
    auto gpu_arg   = run_gpu<V>(gpu_prog);
Paul's avatar
Paul committed
138
    auto cpu_arg   = cpu_arg_f.get();
Paul's avatar
Paul committed
139
    bool passed    = verify_args(migraphx::get_type_name<V>(), cpu_arg, gpu_arg);
Paul's avatar
Paul committed
140
141
142
143
144
145
146
147
148
    if(not passed)
    {
        V v;
        auto p = v.create_program();
        std::cout << p << std::endl;
        std::cout << "cpu:\n" << cpu_prog << std::endl;
        std::cout << "gpu:\n" << gpu_prog << std::endl;
        std::cout << std::endl;
    }
Paul's avatar
Paul committed
149
    std::set_terminate(nullptr);
Paul's avatar
Paul committed
150
151
}

Paul's avatar
Paul committed
152
153
struct test_literals
{
Paul's avatar
Paul committed
154
    migraphx::program create_program() const
Paul's avatar
Paul committed
155
    {
Paul's avatar
Paul committed
156
        migraphx::program p;
Paul's avatar
Paul committed
157
        auto input = p.add_literal(
Paul's avatar
Paul committed
158
            generate_literal(migraphx::shape{migraphx::shape::float_type, {4, 3, 3, 3}}));
Paul's avatar
Paul committed
159
        auto weights = p.add_literal(
Paul's avatar
Paul committed
160
161
162
            generate_literal(migraphx::shape{migraphx::shape::float_type, {4, 3, 3, 3}}));
        auto conv = p.add_instruction(migraphx::op::convolution{}, input, weights);
        p.add_instruction(migraphx::op::relu{}, conv);
Paul's avatar
Paul committed
163
164
165
166
        return p;
    }
};

Paul's avatar
Paul committed
167
168
struct test_add
{
Paul's avatar
Paul committed
169
    migraphx::program create_program() const
Paul's avatar
Paul committed
170
    {
Paul's avatar
Paul committed
171
172
        migraphx::program p;
        migraphx::shape s{migraphx::shape::float_type, {3}};
Paul's avatar
Paul committed
173
174
        auto x = p.add_parameter("x", s);
        auto y = p.add_parameter("y", s);
Paul's avatar
Paul committed
175
        p.add_instruction(migraphx::op::add{}, x, y);
Paul's avatar
Paul committed
176
177
178
179
        return p;
    }
};

Paul's avatar
Paul committed
180
181
struct test_add_half
{
Paul's avatar
Paul committed
182
    migraphx::program create_program() const
Paul's avatar
Paul committed
183
    {
Paul's avatar
Paul committed
184
185
        migraphx::program p;
        migraphx::shape s{migraphx::shape::half_type, {3}};
Paul's avatar
Paul committed
186
187
        auto x = p.add_parameter("x", s);
        auto y = p.add_parameter("y", s);
Paul's avatar
Paul committed
188
        p.add_instruction(migraphx::op::add{}, x, y);
Paul's avatar
Paul committed
189
190
191
192
        return p;
    }
};

Khalique's avatar
Khalique committed
193
194
struct test_mul
{
Paul's avatar
Paul committed
195
    migraphx::program create_program() const
Khalique's avatar
Khalique committed
196
    {
Paul's avatar
Paul committed
197
198
        migraphx::program p;
        migraphx::shape s{migraphx::shape::float_type, {3}};
Khalique's avatar
Khalique committed
199
200
        auto x = p.add_parameter("x", s);
        auto y = p.add_parameter("y", s);
Paul's avatar
Paul committed
201
        p.add_instruction(migraphx::op::mul{}, x, y);
Khalique's avatar
Khalique committed
202
203
204
205
        return p;
    }
};

Shucai Xiao's avatar
Shucai Xiao committed
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
struct test_exp
{
    migraphx::program create_program() const
    {
        migraphx::program p;
        migraphx::shape s{migraphx::shape::float_type, {6}};
        std::vector<float> data{0.1f, 0.2f, 1.f, 2.f, 0.6f, 10.f};
        auto x = p.add_literal(s, data);
        p.add_instruction(migraphx::op::exp{}, x);
        return p;
    }
};

struct test_log
{
    migraphx::program create_program() const
    {
        migraphx::program p;
        migraphx::shape s{migraphx::shape::float_type, {6}};
        std::vector<float> data{0.1f, 0.2f, 1.f, 2.f, 0.6f, 100.f};
        auto x = p.add_literal(s, data);
        p.add_instruction(migraphx::op::log{}, x);
        return p;
    }
};

232
233
234
235
236
237
238
239
240
241
242
243
struct test_sin
{
    migraphx::program create_program() const
    {
        migraphx::program p;
        migraphx::shape s{migraphx::shape::float_type, {10}};
        auto x = p.add_parameter("x", s);
        p.add_instruction(migraphx::op::sin{}, x);
        return p;
    }
};

Shucai Xiao's avatar
Shucai Xiao committed
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
struct test_cos
{
    migraphx::program create_program() const
    {
        migraphx::program p;
        migraphx::shape s{migraphx::shape::double_type, {8}};
        auto x = p.add_parameter("x", s);
        p.add_instruction(migraphx::op::cos{}, x);
        return p;
    }
};

struct test_tan
{
    migraphx::program create_program() const
    {
        migraphx::program p;
        migraphx::shape s{migraphx::shape::float_type, {16}};
        auto x = p.add_parameter("x", s);
        p.add_instruction(migraphx::op::tan{}, x);
        return p;
    }
};

268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
struct test_sinh
{
    migraphx::program create_program() const
    {
        migraphx::program p;
        migraphx::shape s{migraphx::shape::double_type, {16}};
        auto x = p.add_parameter("x", s);
        p.add_instruction(migraphx::op::sinh{}, x);
        return p;
    }
};

struct test_cosh
{
    migraphx::program create_program() const
    {
        migraphx::program p;
        migraphx::shape s{migraphx::shape::double_type, {16}};
        auto x = p.add_parameter("x", s);
        p.add_instruction(migraphx::op::cosh{}, x);
        return p;
    }
};

292
293
294
295
296
297
298
299
300
301
302
struct test_tanh
{
    migraphx::program create_program() const
    {
        migraphx::program p;
        auto x = p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {4, 3, 3, 3}});
        p.add_instruction(migraphx::op::tanh{}, x);
        return p;
    }
};

303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
struct test_asin
{
    migraphx::program create_program() const
    {
        migraphx::program p;
        migraphx::shape s{migraphx::shape::double_type, {16}};
        auto x = p.add_parameter("x", s);
        p.add_instruction(migraphx::op::asin{}, x);
        return p;
    }
};

struct test_acos
{
    migraphx::program create_program() const
    {
        migraphx::program p;
        migraphx::shape s{migraphx::shape::double_type, {16}};
        auto x = p.add_parameter("x", s);
        p.add_instruction(migraphx::op::acos{}, x);
        return p;
    }
};

struct test_atan
{
    migraphx::program create_program() const
    {
        migraphx::program p;
        migraphx::shape s{migraphx::shape::double_type, {16}};
        auto x = p.add_parameter("x", s);
        p.add_instruction(migraphx::op::atan{}, x);
Khalique's avatar
Khalique committed
335
336
337
338
339
340
        return p;
    }
};

struct test_scale
{
Paul's avatar
Paul committed
341
    migraphx::program create_program() const
Khalique's avatar
Khalique committed
342
    {
Paul's avatar
Paul committed
343
344
        migraphx::program p;
        migraphx::shape s{migraphx::shape::float_type, {3}};
Khalique's avatar
Khalique committed
345
        auto x     = p.add_parameter("x", s);
Paul's avatar
Paul committed
346
347
348
        auto y     = p.add_parameter("y", migraphx::shape::float_type);
        auto scale = p.add_instruction(migraphx::op::scalar{s}, y);
        p.add_instruction(migraphx::op::mul{}, x, scale);
Khalique's avatar
Khalique committed
349
350
351
352
        return p;
    }
};

353
354
struct test_slice
{
Paul's avatar
Paul committed
355
    migraphx::program create_program() const
356
    {
Paul's avatar
Paul committed
357
358
        migraphx::program p;
        migraphx::shape s{migraphx::shape::int32_type, {2, 2, 4}};
359
        auto x      = p.add_parameter("x", s);
Paul's avatar
Paul committed
360
361
362
        auto y      = p.add_parameter("y", {migraphx::shape::int32_type, {2, 2, 2}});
        auto slice0 = p.add_instruction(migraphx::op::slice{{2}, {0}, {2}}, x);
        p.add_instruction(migraphx::op::add{}, y, slice0);
363
364
365
366
367

        return p;
    }
};

Paul's avatar
Paul committed
368
369
struct test_triadd
{
Paul's avatar
Paul committed
370
    migraphx::program create_program() const
Paul's avatar
Paul committed
371
    {
Paul's avatar
Paul committed
372
373
        migraphx::program p;
        migraphx::shape s{migraphx::shape::float_type, {3}};
Paul's avatar
Paul committed
374
375
376
        auto x   = p.add_parameter("x", s);
        auto y   = p.add_parameter("y", s);
        auto z   = p.add_parameter("z", s);
Paul's avatar
Paul committed
377
378
        auto sum = p.add_instruction(migraphx::op::add{}, x, y);
        p.add_instruction(migraphx::op::add{}, sum, z);
Paul's avatar
Paul committed
379
380
381
382
383
384
        return p;
    }
};

struct test_triadd2
{
Paul's avatar
Paul committed
385
    migraphx::program create_program() const
Paul's avatar
Paul committed
386
    {
Paul's avatar
Paul committed
387
388
389
        migraphx::program p;
        migraphx::shape s{migraphx::shape::float_type, {2, 3}};
        migraphx::shape b{migraphx::shape::float_type, {3}};
Paul's avatar
Paul committed
390
391
392
        auto x   = p.add_parameter("x", s);
        auto y   = p.add_parameter("y", s);
        auto z   = p.add_parameter("z", b);
Paul's avatar
Paul committed
393
394
395
        auto zb  = p.add_instruction(migraphx::op::broadcast{1, s}, z);
        auto sum = p.add_instruction(migraphx::op::add{}, x, y);
        p.add_instruction(migraphx::op::add{}, sum, zb);
Paul's avatar
Paul committed
396
397
398
399
        return p;
    }
};

Paul's avatar
Paul committed
400
401
struct test_add_broadcast
{
Paul's avatar
Paul committed
402
    migraphx::program create_program() const
Paul's avatar
Paul committed
403
    {
Paul's avatar
Paul committed
404
405
406
407
408
409
        migraphx::program p;
        migraphx::shape s{migraphx::shape::float_type, {3}};
        auto x  = p.add_parameter("x", {migraphx::shape::float_type, {2, 2, 3}});
        auto y  = p.add_parameter("y", {migraphx::shape::float_type, {2, 2}});
        auto by = p.add_instruction(migraphx::op::broadcast{0, x->get_shape()}, y);
        p.add_instruction(migraphx::op::add{}, x, by);
Paul's avatar
Paul committed
410
411
412
413
        return p;
    }
};

Paul's avatar
Paul committed
414
415
struct test_add_broadcast2
{
Paul's avatar
Paul committed
416
    migraphx::program create_program() const
Paul's avatar
Paul committed
417
    {
Paul's avatar
Paul committed
418
419
420
421
422
423
        migraphx::program p;
        migraphx::shape s{migraphx::shape::float_type, {3}};
        auto x  = p.add_parameter("x", {migraphx::shape::float_type, {2, 3, 4}});
        auto y  = p.add_parameter("y", {migraphx::shape::float_type, {3}});
        auto by = p.add_instruction(migraphx::op::broadcast{1, x->get_shape()}, y);
        p.add_instruction(migraphx::op::add{}, x, by);
Paul's avatar
Paul committed
424
425
426
427
        return p;
    }
};

Paul's avatar
Latest  
Paul committed
428
429
struct test_add_broadcast3
{
Paul's avatar
Paul committed
430
    migraphx::program create_program() const
Paul's avatar
Latest  
Paul committed
431
    {
Paul's avatar
Paul committed
432
433
434
435
436
437
        migraphx::program p;
        migraphx::shape s{migraphx::shape::float_type, {3}};
        auto x  = p.add_parameter("x", {migraphx::shape::float_type, {2, 4, 5}});
        auto y  = p.add_parameter("y", {migraphx::shape::float_type, {4}});
        auto by = p.add_instruction(migraphx::op::broadcast{1, x->get_shape()}, y);
        p.add_instruction(migraphx::op::add{}, x, by);
Paul's avatar
Latest  
Paul committed
438
439
440
441
442
443
        return p;
    }
};

struct test_add_broadcast4
{
Paul's avatar
Paul committed
444
    migraphx::program create_program() const
Paul's avatar
Latest  
Paul committed
445
    {
Paul's avatar
Paul committed
446
447
448
449
450
451
        migraphx::program p;
        migraphx::shape s{migraphx::shape::float_type, {3}};
        auto x  = p.add_parameter("x", {migraphx::shape::float_type, {2, 3, 5}});
        auto y  = p.add_parameter("y", {migraphx::shape::float_type, {3}});
        auto by = p.add_instruction(migraphx::op::broadcast{1, x->get_shape()}, y);
        p.add_instruction(migraphx::op::add{}, x, by);
Paul's avatar
Latest  
Paul committed
452
453
454
455
        return p;
    }
};

Paul's avatar
Paul committed
456
457
struct test_add_broadcast5
{
Paul's avatar
Paul committed
458
    migraphx::program create_program() const
Paul's avatar
Paul committed
459
    {
Paul's avatar
Paul committed
460
461
462
463
464
465
        migraphx::program p;
        migraphx::shape s{migraphx::shape::float_type, {3}};
        auto x  = p.add_parameter("x", {migraphx::shape::float_type, {2, 4, 8}});
        auto y  = p.add_parameter("y", {migraphx::shape::float_type, {4}});
        auto by = p.add_instruction(migraphx::op::broadcast{1, x->get_shape()}, y);
        p.add_instruction(migraphx::op::add{}, x, by);
Paul's avatar
Paul committed
466
467
468
469
        return p;
    }
};

Paul's avatar
Paul committed
470
471
struct test_triadd_broadcast
{
Paul's avatar
Paul committed
472
    migraphx::program create_program() const
Paul's avatar
Paul committed
473
    {
Paul's avatar
Paul committed
474
475
476
477
478
479
480
481
        migraphx::program p;
        migraphx::shape s{migraphx::shape::float_type, {3}};
        auto x   = p.add_parameter("x", {migraphx::shape::float_type, {2, 2, 3}});
        auto y   = p.add_parameter("y", {migraphx::shape::float_type, {2, 2}});
        auto z   = p.add_parameter("z", {migraphx::shape::float_type, {2, 2, 3}});
        auto by  = p.add_instruction(migraphx::op::broadcast{0, x->get_shape()}, y);
        auto sum = p.add_instruction(migraphx::op::add{}, x, by);
        p.add_instruction(migraphx::op::add{}, sum, z);
Paul's avatar
Paul committed
482
483
484
485
        return p;
    }
};

Paul's avatar
Paul committed
486
487
struct test_softmax
{
Paul's avatar
Paul committed
488
    migraphx::program create_program() const
Paul's avatar
Paul committed
489
    {
Paul's avatar
Paul committed
490
491
492
        migraphx::program p;
        auto x = p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {5, 3, 4, 2}});
        p.add_instruction(migraphx::op::softmax{}, x);
Paul's avatar
Paul committed
493
494
495
496
497
498
        return p;
    }
};

struct test_softmax2
{
Paul's avatar
Paul committed
499
    migraphx::program create_program() const
Paul's avatar
Paul committed
500
    {
Paul's avatar
Paul committed
501
        migraphx::program p;
Paul's avatar
Paul committed
502
503
        auto x =
            p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {1, 1000, 1, 1}});
Paul's avatar
Paul committed
504
        p.add_instruction(migraphx::op::softmax{}, x);
Paul's avatar
Paul committed
505
506
507
508
        return p;
    }
};

Paul's avatar
Paul committed
509
510
struct test_conv
{
Paul's avatar
Paul committed
511
    migraphx::program create_program() const
Paul's avatar
Paul committed
512
    {
Paul's avatar
Paul committed
513
        migraphx::program p;
Paul's avatar
Paul committed
514
515
        auto input =
            p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {4, 3, 3, 3}});
Paul's avatar
Paul committed
516
        auto weights =
Paul's avatar
Paul committed
517
518
            p.add_parameter("w", migraphx::shape{migraphx::shape::float_type, {4, 3, 3, 3}});
        p.add_instruction(migraphx::op::convolution{}, input, weights);
Paul's avatar
Paul committed
519
520
521
522
        return p;
    }
};

Paul's avatar
Paul committed
523
524
struct test_conv2
{
Paul's avatar
Paul committed
525
    migraphx::program create_program() const
Paul's avatar
Paul committed
526
    {
Paul's avatar
Paul committed
527
        migraphx::program p;
Paul's avatar
Paul committed
528
        auto input =
Paul's avatar
Paul committed
529
            p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {1, 512, 28, 28}});
Paul's avatar
Paul committed
530
        auto weights =
Paul's avatar
Paul committed
531
532
            p.add_parameter("w", migraphx::shape{migraphx::shape::float_type, {256, 512, 1, 1}});
        p.add_instruction(migraphx::op::convolution{{0, 0}, {1, 1}, {1, 1}}, input, weights);
Paul's avatar
Paul committed
533
534
535
536
        return p;
    }
};

Khalique's avatar
Khalique committed
537
538
539
540
541
struct test_group_conv
{
    migraphx::program create_program() const
    {
        migraphx::program p;
Paul's avatar
Paul committed
542
        auto input =
Khalique's avatar
Khalique committed
543
            p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {1, 4, 16, 16}});
Paul's avatar
Paul committed
544
        auto weights =
Khalique's avatar
Khalique committed
545
546
547
548
            p.add_parameter("w", migraphx::shape{migraphx::shape::float_type, {4, 1, 3, 3}});
        migraphx::op::convolution op;
        op.group = 4;
        p.add_instruction(op, input, weights);
Paul's avatar
Paul committed
549
550
551
552
        return p;
    }
};

Paul's avatar
Paul committed
553
struct test_conv_relu
Paul's avatar
Paul committed
554
{
Paul's avatar
Paul committed
555
    migraphx::program create_program() const
Paul's avatar
Paul committed
556
    {
Paul's avatar
Paul committed
557
        migraphx::program p;
Paul's avatar
Paul committed
558
559
        auto input =
            p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {4, 3, 3, 3}});
Paul's avatar
Paul committed
560
        auto weights =
Paul's avatar
Paul committed
561
562
563
            p.add_parameter("w", migraphx::shape{migraphx::shape::float_type, {4, 3, 3, 3}});
        auto conv = p.add_instruction(migraphx::op::convolution{}, input, weights);
        p.add_instruction(migraphx::op::relu{}, conv);
Paul's avatar
Paul committed
564
565
566
567
        return p;
    }
};

Paul's avatar
Paul committed
568
569
struct test_conv_relu_half
{
Paul's avatar
Paul committed
570
    migraphx::program create_program() const
Paul's avatar
Paul committed
571
    {
Paul's avatar
Paul committed
572
        migraphx::program p;
Paul's avatar
Paul committed
573
574
        auto input =
            p.add_parameter("x", migraphx::shape{migraphx::shape::half_type, {4, 3, 3, 3}});
Paul's avatar
Paul committed
575
        auto weights =
Paul's avatar
Paul committed
576
577
578
            p.add_parameter("w", migraphx::shape{migraphx::shape::half_type, {4, 3, 3, 3}});
        auto conv = p.add_instruction(migraphx::op::convolution{}, input, weights);
        p.add_instruction(migraphx::op::relu{}, conv);
Paul's avatar
Paul committed
579
580
581
582
        return p;
    }
};

Paul's avatar
Paul committed
583
584
struct test_add_relu
{
Paul's avatar
Paul committed
585
    migraphx::program create_program() const
Paul's avatar
Paul committed
586
    {
Paul's avatar
Paul committed
587
588
589
590
591
        migraphx::program p;
        auto x   = p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {4, 3, 3, 3}});
        auto y   = p.add_parameter("y", migraphx::shape{migraphx::shape::float_type, {4, 3, 3, 3}});
        auto add = p.add_instruction(migraphx::op::add{}, x, y);
        p.add_instruction(migraphx::op::relu{}, add);
Paul's avatar
Paul committed
592
593
594
595
        return p;
    }
};

Khalique's avatar
Khalique committed
596
597
598
599
600
struct test_sigmoid
{
    migraphx::program create_program() const
    {
        migraphx::program p;
Khalique's avatar
Khalique committed
601
        auto x = p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {4, 3, 3, 3}});
Khalique's avatar
Khalique committed
602
603
604
605
606
607
608
609
610
611
        p.add_instruction(migraphx::op::sigmoid{}, x);
        return p;
    }
};

struct test_abs
{
    migraphx::program create_program() const
    {
        migraphx::program p;
Khalique's avatar
Khalique committed
612
        auto x = p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {4, 3, 3, 3}});
Khalique's avatar
Khalique committed
613
        p.add_instruction(migraphx::op::abs{}, x);
Paul's avatar
Paul committed
614
615
616
617
        return p;
    }
};

618
619
struct test_leaky_relu
{
Paul's avatar
Paul committed
620
    migraphx::program create_program() const
621
    {
Paul's avatar
Paul committed
622
623
624
        migraphx::program p;
        auto x = p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {4, 3, 3, 3}});
        p.add_instruction(migraphx::op::leaky_relu{0.01}, x);
625
626
627
628
        return p;
    }
};

Khalique's avatar
Khalique committed
629
630
631
632
633
634
635
struct test_elu
{
    migraphx::program create_program() const
    {
        migraphx::program p;
        auto x = p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {4, 3, 3, 3}});
        p.add_instruction(migraphx::op::leaky_relu{1.0}, x);
636
637
638
639
        return p;
    }
};

Khalique's avatar
Khalique committed
640
struct test_lrn
Khalique's avatar
Khalique committed
641
642
643
644
645
{
    migraph::program create_program() const
    {
        migraph::program p;
        auto x = p.add_parameter("x", migraph::shape{migraph::shape::float_type, {1, 5, 2, 2}});
Khalique's avatar
Khalique committed
646
        p.add_instruction(migraph::op::lrn{0.0001, 0.75, 1.0, 5}, x);
Khalique's avatar
Khalique committed
647
648
649
650
        return p;
    }
};

Paul's avatar
Paul committed
651
652
struct test_conv_pooling
{
Paul's avatar
Paul committed
653
    migraphx::program create_program() const
Paul's avatar
Paul committed
654
    {
Paul's avatar
Paul committed
655
        migraphx::program p;
Paul's avatar
Paul committed
656
        auto input =
Paul's avatar
Paul committed
657
            p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {4, 3, 32, 32}});
Paul's avatar
Paul committed
658
        auto weights =
Paul's avatar
Paul committed
659
660
661
662
            p.add_parameter("w", migraphx::shape{migraphx::shape::float_type, {4, 3, 3, 3}});
        auto conv    = p.add_instruction(migraphx::op::convolution{}, input, weights);
        auto pooling = p.add_instruction(migraphx::op::pooling{"max"}, conv);
        p.add_instruction(migraphx::op::relu{}, pooling);
Paul's avatar
Paul committed
663
664
665
666
        return p;
    }
};

667
668
struct test_global_avg_pooling
{
Paul's avatar
Paul committed
669
    migraphx::program create_program() const
670
    {
Paul's avatar
Paul committed
671
        migraphx::program p;
672
        auto input =
Paul's avatar
Paul committed
673
674
            p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {1, 3, 16, 16}});
        auto op    = migraphx::op::pooling{"average"};
675
        auto lens  = input->get_shape().lens();
Khalique's avatar
Khalique committed
676
        op.lengths = {lens[2], lens[3]};
677
678
679
680
681
682
683
        p.add_instruction(op, input);
        return p;
    }
};

struct test_global_max_pooling
{
Paul's avatar
Paul committed
684
    migraphx::program create_program() const
685
    {
Paul's avatar
Paul committed
686
        migraphx::program p;
687
        auto input =
Paul's avatar
Paul committed
688
689
            p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {1, 3, 16, 16}});
        auto op    = migraphx::op::pooling{"max"};
690
        auto lens  = input->get_shape().lens();
Khalique's avatar
Khalique committed
691
        op.lengths = {lens[2], lens[3]};
692
693
694
695
696
        p.add_instruction(op, input);
        return p;
    }
};

Paul's avatar
Paul committed
697
698
struct test_gemm
{
Paul's avatar
Paul committed
699
    migraphx::program create_program() const
Paul's avatar
Paul committed
700
    {
Paul's avatar
Paul committed
701
702
703
704
        migraphx::program p;
        auto a = p.add_parameter("a", migraphx::shape{migraphx::shape::float_type, {4, 5}});
        auto b = p.add_parameter("b", migraphx::shape{migraphx::shape::float_type, {5, 3}});
        p.add_instruction(migraphx::op::dot{}, a, b);
Paul's avatar
Paul committed
705
706
707
708
        return p;
    }
};

Paul's avatar
Paul committed
709
710
struct test_gemm_half
{
Paul's avatar
Paul committed
711
    migraphx::program create_program() const
Paul's avatar
Paul committed
712
    {
Paul's avatar
Paul committed
713
714
715
716
        migraphx::program p;
        auto a = p.add_parameter("a", migraphx::shape{migraphx::shape::half_type, {4, 5}});
        auto b = p.add_parameter("b", migraphx::shape{migraphx::shape::half_type, {5, 3}});
        p.add_instruction(migraphx::op::dot{}, a, b);
Paul's avatar
Paul committed
717
718
719
720
        return p;
    }
};

Paul's avatar
Paul committed
721
722
struct test_gemm_ld
{
Paul's avatar
Paul committed
723
    migraphx::program create_program() const
Paul's avatar
Paul committed
724
    {
Paul's avatar
Paul committed
725
        migraphx::program p;
Paul's avatar
Paul committed
726
727
728
729
        auto a =
            p.add_parameter("a", migraphx::shape{migraphx::shape::float_type, {4, 5}, {10, 1}});
        auto b =
            p.add_parameter("b", migraphx::shape{migraphx::shape::float_type, {5, 3}, {20, 1}});
Paul's avatar
Paul committed
730
        p.add_instruction(migraphx::op::dot{}, a, b);
Paul's avatar
Paul committed
731
732
733
734
        return p;
    }
};

735
736
struct test_gemm_transposeb
{
Paul's avatar
Paul committed
737
    migraphx::program create_program() const
738
    {
Paul's avatar
Paul committed
739
740
741
742
743
        migraphx::program p;
        auto a  = p.add_parameter("a", migraphx::shape{migraphx::shape::float_type, {4, 5}});
        auto b  = p.add_parameter("b", migraphx::shape{migraphx::shape::float_type, {3, 5}});
        auto bt = p.add_instruction(migraphx::op::transpose{{1, 0}}, b);
        p.add_instruction(migraphx::op::dot{}, a, bt);
744
745
746
747
748
749
        return p;
    }
};

struct test_gemm_transposea
{
Paul's avatar
Paul committed
750
    migraphx::program create_program() const
751
    {
Paul's avatar
Paul committed
752
753
754
755
756
        migraphx::program p;
        auto a  = p.add_parameter("a", migraphx::shape{migraphx::shape::float_type, {5, 4}});
        auto b  = p.add_parameter("b", migraphx::shape{migraphx::shape::float_type, {5, 3}});
        auto at = p.add_instruction(migraphx::op::transpose{{1, 0}}, a);
        p.add_instruction(migraphx::op::dot{}, at, b);
757
758
759
760
761
762
        return p;
    }
};

struct test_gemm_transposeab
{
Paul's avatar
Paul committed
763
    migraphx::program create_program() const
764
    {
Paul's avatar
Paul committed
765
766
767
768
769
770
        migraphx::program p;
        auto a  = p.add_parameter("a", migraphx::shape{migraphx::shape::float_type, {5, 4}});
        auto b  = p.add_parameter("b", migraphx::shape{migraphx::shape::float_type, {3, 5}});
        auto at = p.add_instruction(migraphx::op::transpose{{1, 0}}, a);
        auto bt = p.add_instruction(migraphx::op::transpose{{1, 0}}, b);
        p.add_instruction(migraphx::op::dot{}, at, bt);
771
772
773
774
        return p;
    }
};

775
776
struct test_contiguous
{
Paul's avatar
Paul committed
777
    migraphx::program create_program() const
778
    {
Paul's avatar
Paul committed
779
780
        migraphx::program p;
        migraphx::shape s{migraphx::shape::float_type, {4, 4, 4, 3}, {48, 4, 1, 16}};
781
        auto x = p.add_parameter("x", s);
Paul's avatar
Paul committed
782
        p.add_instruction(migraphx::op::contiguous{}, x);
Paul's avatar
Paul committed
783
        EXPECT(p.get_shape().standard());
784
785
786
787
        return p;
    }
};

788
struct test_transpose
789
{
Paul's avatar
Paul committed
790
    migraphx::program create_program() const
791
    {
Paul's avatar
Paul committed
792
793
        migraphx::program p;
        migraphx::shape s{migraphx::shape::float_type, {4, 3, 4, 4}};
794
795
        auto x                    = p.add_parameter("x", s);
        std::vector<int64_t> perm = {0, 2, 3, 1};
Paul's avatar
Paul committed
796
797
        auto l                    = p.add_instruction(migraphx::op::transpose{perm}, x);
        p.add_instruction(migraphx::op::contiguous{}, l);
798
799
800
        return p;
    }
};
801

Paul's avatar
Paul committed
802
803
804
805
806
807
808
struct test_batchnorm_inference_2
{
    const size_t width    = 14;
    const size_t height   = 14;
    const size_t channels = 256;
    const size_t batches  = 1;

Paul's avatar
Paul committed
809
    migraphx::program create_program() const
Paul's avatar
Paul committed
810
    {
Paul's avatar
Paul committed
811
        migraphx::program p;
Paul's avatar
Paul committed
812

Paul's avatar
Paul committed
813
814
        migraphx::shape s{migraphx::shape::float_type, {batches, channels, height, width}};
        migraphx::shape vars{migraphx::shape::float_type, {channels}};
Paul's avatar
Paul committed
815
        auto x        = p.add_parameter("x", s);
Paul's avatar
Paul committed
816
817
818
819
820
        auto scale    = p.add_literal(migraphx::abs(migraphx::generate_literal(vars, 1)));
        auto bias     = p.add_literal(migraphx::abs(migraphx::generate_literal(vars, 2)));
        auto mean     = p.add_literal(migraphx::abs(migraphx::generate_literal(vars, 3)));
        auto variance = p.add_literal(migraphx::abs(migraphx::generate_literal(vars, 4)));
        p.add_instruction(migraphx::op::batch_norm_inference{}, x, scale, bias, mean, variance);
Paul's avatar
Paul committed
821
822
823
824
        return p;
    }
};

wsttiger's avatar
wsttiger committed
825
826
827
828
829
830
831
struct test_batchnorm_inference
{
    const size_t width    = 3;
    const size_t height   = 3;
    const size_t channels = 3;
    const size_t batches  = 4;

Paul's avatar
Paul committed
832
    migraphx::program create_program() const
wsttiger's avatar
wsttiger committed
833
    {
Paul's avatar
Paul committed
834
        migraphx::program p;
wsttiger's avatar
wsttiger committed
835

Paul's avatar
Paul committed
836
837
        migraphx::shape s{migraphx::shape::float_type, {batches, channels, height, width}};
        migraphx::shape vars{migraphx::shape::float_type, {channels}};
wsttiger's avatar
wsttiger committed
838
        auto x        = p.add_parameter("x", s);
Paul's avatar
Paul committed
839
840
841
842
843
        auto scale    = p.add_literal(migraphx::abs(migraphx::generate_literal(vars, 1)));
        auto bias     = p.add_literal(migraphx::abs(migraphx::generate_literal(vars, 2)));
        auto mean     = p.add_literal(migraphx::abs(migraphx::generate_literal(vars, 3)));
        auto variance = p.add_literal(migraphx::abs(migraphx::generate_literal(vars, 4)));
        p.add_instruction(migraphx::op::batch_norm_inference{}, x, scale, bias, mean, variance);
wsttiger's avatar
wsttiger committed
844
845
846
847
        return p;
    }
};

Paul's avatar
Paul committed
848
849
struct test_conv_bn
{
Paul's avatar
Paul committed
850
    migraphx::program create_program() const
Paul's avatar
Paul committed
851
    {
Paul's avatar
Paul committed
852
        migraphx::program p;
Paul's avatar
Paul committed
853

Paul's avatar
Paul committed
854
855
856
        migraphx::shape xs{migraphx::shape::float_type, {1, 3, 224, 224}};
        migraphx::shape ws{migraphx::shape::float_type, {64, 3, 7, 7}};
        migraphx::shape vars{migraphx::shape::float_type, {64}};
Paul's avatar
Paul committed
857
858
        auto x        = p.add_parameter("x", xs);
        auto w        = p.add_parameter("w", ws);
Paul's avatar
Paul committed
859
860
861
862
863
864
        auto conv     = p.add_instruction(migraphx::op::convolution{{3, 3}, {2, 2}, {1, 1}}, x, w);
        auto scale    = p.add_literal(migraphx::abs(migraphx::generate_literal(vars, 1)));
        auto bias     = p.add_literal(migraphx::abs(migraphx::generate_literal(vars, 2)));
        auto mean     = p.add_literal(migraphx::abs(migraphx::generate_literal(vars, 3)));
        auto variance = p.add_literal(migraphx::abs(migraphx::generate_literal(vars, 4)));
        p.add_instruction(migraphx::op::batch_norm_inference{}, conv, scale, bias, mean, variance);
Paul's avatar
Paul committed
865
866
867
868
        return p;
    }
};

Paul's avatar
Paul committed
869
870
struct test_conv_bn_relu_pooling
{
Paul's avatar
Paul committed
871
    migraphx::program create_program() const
Paul's avatar
Paul committed
872
    {
Paul's avatar
Paul committed
873
        migraphx::program p;
Paul's avatar
Paul committed
874

Paul's avatar
Paul committed
875
876
877
        migraphx::shape xs{migraphx::shape::float_type, {1, 3, 224, 224}};
        migraphx::shape ws{migraphx::shape::float_type, {64, 3, 7, 7}};
        migraphx::shape vars{migraphx::shape::float_type, {64}};
Paul's avatar
Paul committed
878
879
        auto x        = p.add_parameter("x", xs);
        auto w        = p.add_parameter("w", ws);
Paul's avatar
Paul committed
880
881
882
883
884
        auto conv     = p.add_instruction(migraphx::op::convolution{{3, 3}, {2, 2}, {1, 1}}, x, w);
        auto scale    = p.add_literal(migraphx::abs(migraphx::generate_literal(vars, 1)));
        auto bias     = p.add_literal(migraphx::abs(migraphx::generate_literal(vars, 2)));
        auto mean     = p.add_literal(migraphx::abs(migraphx::generate_literal(vars, 3)));
        auto variance = p.add_literal(migraphx::abs(migraphx::generate_literal(vars, 4)));
wsttiger's avatar
wsttiger committed
885
        auto bn       = p.add_instruction(
Paul's avatar
Paul committed
886
887
888
            migraphx::op::batch_norm_inference{}, conv, scale, bias, mean, variance);
        auto relu = p.add_instruction(migraphx::op::relu{}, bn);
        p.add_instruction(migraphx::op::pooling{"average", {1, 1}, {2, 2}, {3, 3}}, relu);
Paul's avatar
Paul committed
889
890
891
892
        return p;
    }
};

893
894
struct test_concat
{
Paul's avatar
Paul committed
895
    migraphx::program create_program() const
896
    {
Paul's avatar
Paul committed
897
        migraphx::program p;
wsttiger's avatar
wsttiger committed
898
        std::size_t axis = 1;
Paul's avatar
Paul committed
899
900
901
        migraphx::shape s0{migraphx::shape::int32_type, {2, 2}};
        migraphx::shape s1{migraphx::shape::int32_type, {2, 3}};
        migraphx::shape s2{migraphx::shape::int32_type, {2, 1}};
902
903
904
        auto l0 = p.add_parameter("x", s0);
        auto l1 = p.add_parameter("y", s1);
        auto l2 = p.add_parameter("z", s2);
Paul's avatar
Paul committed
905
        p.add_instruction(migraphx::op::concat{axis}, l0, l1, l2);
906
907
908
909
910
911
        return p;
    }
};

struct test_concat2
{
Paul's avatar
Paul committed
912
    migraphx::program create_program() const
913
    {
Paul's avatar
Paul committed
914
        migraphx::program p;
wsttiger's avatar
wsttiger committed
915
        std::size_t axis = 0;
Paul's avatar
Paul committed
916
917
918
        migraphx::shape s0{migraphx::shape::int32_type, {2, 2}};
        migraphx::shape s1{migraphx::shape::int32_type, {3, 2}};
        migraphx::shape s2{migraphx::shape::int32_type, {1, 2}};
919
920
921
        auto l0 = p.add_parameter("x", s0);
        auto l1 = p.add_parameter("y", s1);
        auto l2 = p.add_parameter("z", s2);
Paul's avatar
Paul committed
922
        p.add_instruction(migraphx::op::concat{axis}, l0, l1, l2);
923
924
925
926
        return p;
    }
};

wsttiger's avatar
wsttiger committed
927
928
struct test_concat_relu
{
Paul's avatar
Paul committed
929
    migraphx::program create_program() const
wsttiger's avatar
wsttiger committed
930
    {
Paul's avatar
Paul committed
931
        migraphx::program p;
wsttiger's avatar
wsttiger committed
932
        std::size_t axis = 0;
Paul's avatar
Paul committed
933
934
935
        migraphx::shape s0{migraphx::shape::float_type, {2, 2}};
        migraphx::shape s1{migraphx::shape::float_type, {3, 2}};
        migraphx::shape s2{migraphx::shape::float_type, {1, 2}};
wsttiger's avatar
wsttiger committed
936
937
938
        auto l0 = p.add_parameter("x", s0);
        auto l1 = p.add_parameter("y", s1);
        auto l2 = p.add_parameter("z", s2);
Paul's avatar
Paul committed
939
940
941
942
943
        auto r0 = p.add_instruction(migraphx::op::relu{}, l0);
        auto r1 = p.add_instruction(migraphx::op::relu{}, l1);
        auto r2 = p.add_instruction(migraphx::op::relu{}, l2);
        auto c0 = p.add_instruction(migraphx::op::concat{axis}, r0, r1, r2);
        p.add_instruction(migraphx::op::relu{}, c0);
wsttiger's avatar
wsttiger committed
944
945
946
947
        return p;
    }
};

948
949
950
951
952
953
struct test_pad
{
    migraphx::program create_program() const
    {
        migraphx::program p;
        migraphx::shape s0{migraphx::shape::int32_type, {1, 96, 165, 165}};
Khalique's avatar
Khalique committed
954
955
956
957
        std::vector<int64_t> pads0 = {0, 0, 0, 0, 0, 0, 1, 1};
        std::vector<int64_t> pads1 = {0, 0, 0, 0, 1, 1, 1, 1};
        std::vector<int64_t> pads2 = {1, 1, 1, 1, 0, 0, 0, 0};
        std::vector<int64_t> pads3 = {1, 0, 1, 0, 1, 0, 2, 0};
Khalique's avatar
Khalique committed
958
        auto l0                    = p.add_parameter("x", s0);
Khalique's avatar
Khalique committed
959
960
961
        p.add_instruction(migraphx::op::pad{pads0}, l0);
        p.add_instruction(migraphx::op::pad{pads1}, l0);
        p.add_instruction(migraphx::op::pad{pads2}, l0);
Khalique's avatar
Khalique committed
962
        p.add_instruction(migraphx::op::pad{pads3}, l0);
Khalique's avatar
Khalique committed
963
        return p;
Khalique's avatar
Khalique committed
964
    }
Khalique's avatar
Khalique committed
965
};
Khalique's avatar
Khalique committed
966

967
968
969
970
971
972
973
974
975
struct test_pooling_autopad
{
    migraphx::program create_program() const
    {
        migraphx::program p;
        migraphx::shape s0{migraphx::shape::float_type, {1, 3, 63, 63}};
        auto l0 = p.add_parameter("x", s0);
        migraphx::op::pooling op{"max"};
        op.padding_mode = migraphx::op::padding_mode_t::same;
Khalique's avatar
Khalique committed
976
977
        op.lengths      = {2, 2};
        op.stride       = {2, 2};
978
979
980
981
982
        p.add_instruction(op, l0);
        return p;
    }
};

983
984
985
986
987
988
989
990
struct test_gather
{
    migraphx::program create_program() const
    {
        migraphx::program p;
        migraphx::shape s{migraphx::shape::float_type, {3, 3}};
        migraphx::shape s_indices{migraphx::shape::int32_type, {2, 2}};
        std::vector<int> indices{1, 2, 2, 1};
Shucai Xiao's avatar
Shucai Xiao committed
991
992
        auto a0  = p.add_parameter("data", s);
        auto a1  = p.add_literal(migraphx::literal{s_indices, indices});
993
        int axis = 0;
994
        p.add_instruction(migraphx::op::gather{axis}, a0, a1);
995
996
997
998
        return p;
    }
};

999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
struct test_gather_neg_axis
{
    migraphx::program create_program() const
    {
        migraphx::program p;
        migraphx::shape s{migraphx::shape::float_type, {3, 3}};
        migraphx::shape s_indices{migraphx::shape::int32_type, {2, 2}};
        std::vector<int> indices{1, 2, 2, 1};
        auto a0  = p.add_parameter("data", s);
        auto a1  = p.add_literal(migraphx::literal{s_indices, indices});
        int axis = -1;
1010
        p.add_instruction(migraphx::op::gather{axis}, a0, a1);
wsttiger's avatar
wsttiger committed
1011
1012
1013
1014
1015
1016
        return p;
    }
};

void manual_identity()
{
Paul's avatar
Paul committed
1017
    migraphx::program p;
wsttiger's avatar
wsttiger committed
1018
    std::vector<float> data0 = {0, 1, 2, 3};
Paul's avatar
Paul committed
1019
1020
1021
1022
1023
    migraphx::shape s0{migraphx::shape::float_type, {2, 2}};
    auto l0 = p.add_literal(migraphx::literal{s0, data0});
    p.add_instruction(migraphx::op::identity{}, l0);
    p.compile(migraphx::gpu::target{});
    migraphx::program::parameter_map m;
wsttiger's avatar
wsttiger committed
1024
1025
    for(auto&& x : p.get_parameter_shapes())
    {
Paul's avatar
Paul committed
1026
        m[x.first] = migraphx::gpu::to_gpu(migraphx::generate_argument(x.second));
wsttiger's avatar
wsttiger committed
1027
    }
Paul's avatar
Paul committed
1028
    auto result = migraphx::gpu::from_gpu(p.eval(m));
wsttiger's avatar
wsttiger committed
1029
1030
1031
1032
1033
    std::cout << result << std::endl;
}

void manual_test_concat_relu()
{
Paul's avatar
Paul committed
1034
    migraphx::program p;
wsttiger's avatar
wsttiger committed
1035
    std::size_t axis         = 0;
wsttiger's avatar
wsttiger committed
1036
1037
1038
    std::vector<float> data0 = {0, 1, 2, 3};
    std::vector<float> data1 = {4, 5, 6, 7, 8, 9};
    std::vector<float> data2 = {10, 11};
Paul's avatar
Paul committed
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
    migraphx::shape s0{migraphx::shape::float_type, {2, 2}};
    migraphx::shape s1{migraphx::shape::float_type, {3, 2}};
    migraphx::shape s2{migraphx::shape::float_type, {1, 2}};
    auto l0 = p.add_literal(migraphx::literal{s0, data0});
    auto l1 = p.add_literal(migraphx::literal{s1, data1});
    auto l2 = p.add_literal(migraphx::literal{s2, data2});
    auto r0 = p.add_instruction(migraphx::op::relu{}, l0);
    auto r1 = p.add_instruction(migraphx::op::relu{}, l1);
    auto r2 = p.add_instruction(migraphx::op::relu{}, l2);
    auto c0 = p.add_instruction(migraphx::op::concat{axis}, r0, r1, r2);
    p.add_instruction(migraphx::op::relu{}, c0);

    p.compile(migraphx::gpu::target{});
    migraphx::program::parameter_map m;
wsttiger's avatar
wsttiger committed
1053
1054
    for(auto&& x : p.get_parameter_shapes())
    {
Paul's avatar
Paul committed
1055
        m[x.first] = migraphx::gpu::to_gpu(migraphx::generate_argument(x.second));
wsttiger's avatar
wsttiger committed
1056
    }
Paul's avatar
Paul committed
1057
    auto result = migraphx::gpu::from_gpu(p.eval(m));
wsttiger's avatar
wsttiger committed
1058
1059
1060
    std::cout << result << std::endl;
}

Paul's avatar
Paul committed
1061
1062
struct test_conv_bn_relu_pooling2
{
Paul's avatar
Paul committed
1063
1064
    static migraphx::instruction_ref
    add_bn(migraphx::program& p, migraphx::instruction_ref x, std::size_t channels)
Paul's avatar
Paul committed
1065
    {
Paul's avatar
Paul committed
1066
        migraphx::shape vars{migraphx::shape::float_type, {channels}};
Paul's avatar
Paul committed
1067
1068
1069
1070
1071
        auto scale = p.add_literal(migraphx::abs(migraphx::generate_literal(vars, 1 + channels)));
        auto bias  = p.add_literal(migraphx::abs(migraphx::generate_literal(vars, 2 + channels)));
        auto mean  = p.add_literal(migraphx::abs(migraphx::generate_literal(vars, 3 + channels)));
        auto variance =
            p.add_literal(migraphx::abs(migraphx::generate_literal(vars, 4 + channels)));
wsttiger's avatar
wsttiger committed
1072
        return p.add_instruction(
Paul's avatar
Paul committed
1073
            migraphx::op::batch_norm_inference{}, x, scale, bias, mean, variance);
Paul's avatar
Paul committed
1074
    }
Paul's avatar
Paul committed
1075
    migraphx::program create_program() const
Paul's avatar
Paul committed
1076
    {
Paul's avatar
Paul committed
1077
        migraphx::program p;
Paul's avatar
Paul committed
1078

Paul's avatar
Paul committed
1079
1080
1081
1082
        migraphx::shape xs1{migraphx::shape::float_type, {1, 512, 7, 7}};
        migraphx::shape xs2{migraphx::shape::float_type, {1, 1024, 14, 14}};
        migraphx::shape ws1{migraphx::shape::float_type, {2048, 512, 1, 1}};
        migraphx::shape ws2{migraphx::shape::float_type, {2048, 1024, 1, 1}};
Paul's avatar
Paul committed
1083
1084
        auto x1    = p.add_parameter("x1", xs1);
        auto w1    = p.add_parameter("w1", ws1);
Paul's avatar
Paul committed
1085
        auto conv1 = p.add_instruction(migraphx::op::convolution{{0, 0}, {1, 1}, {1, 1}}, x1, w1);
Paul's avatar
Paul committed
1086
1087
1088
        auto bn1   = add_bn(p, conv1, 2048);
        auto x2    = p.add_parameter("x2", xs2);
        auto w2    = p.add_parameter("w2", ws2);
Paul's avatar
Paul committed
1089
        auto conv2 = p.add_instruction(migraphx::op::convolution{{0, 0}, {2, 2}, {1, 1}}, x2, w2);
Paul's avatar
Paul committed
1090
        auto bn2   = add_bn(p, conv2, 2048);
Paul's avatar
Paul committed
1091
1092
1093
        auto add   = p.add_instruction(migraphx::op::add{}, bn1, bn2);
        auto relu  = p.add_instruction(migraphx::op::relu{}, add);
        p.add_instruction(migraphx::op::pooling{"average", {1, 1}, {2, 2}, {3, 3}}, relu);
Paul's avatar
Paul committed
1094
1095
1096
1097
        return p;
    }
};

Paul's avatar
Paul committed
1098
1099
int main()
{
Khalique's avatar
Khalique committed
1100
    verify_program<test_lrn>();
1101
    verify_program<test_pooling_autopad>();
Khalique's avatar
Khalique committed
1102
    verify_program<test_abs>();
1103
1104
    verify_program<test_concat>();
    verify_program<test_concat2>();
wsttiger's avatar
wsttiger committed
1105
    verify_program<test_concat_relu>();
1106
    verify_program<test_pad>();
Paul's avatar
Paul committed
1107
    verify_program<test_add>();
Paul's avatar
Paul committed
1108
    verify_program<test_add_half>();
Khalique's avatar
Khalique committed
1109
    verify_program<test_mul>();
Shucai Xiao's avatar
Shucai Xiao committed
1110
1111
    verify_program<test_exp>();
    verify_program<test_log>();
1112
    verify_program<test_sin>();
1113
1114
    verify_program<test_cos>();
    verify_program<test_tan>();
1115
1116
    verify_program<test_sinh>();
    verify_program<test_cosh>();
1117
    verify_program<test_tanh>();
1118
1119
1120
    verify_program<test_asin>();
    verify_program<test_acos>();
    verify_program<test_atan>();
Khalique's avatar
Khalique committed
1121
    verify_program<test_scale>();
Paul's avatar
Paul committed
1122
1123
    verify_program<test_triadd>();
    verify_program<test_triadd2>();
Paul's avatar
Paul committed
1124
    verify_program<test_add_broadcast>();
Paul's avatar
Paul committed
1125
    verify_program<test_add_broadcast2>();
Paul's avatar
Latest  
Paul committed
1126
1127
    verify_program<test_add_broadcast3>();
    verify_program<test_add_broadcast4>();
Paul's avatar
Paul committed
1128
    verify_program<test_add_broadcast5>();
Paul's avatar
Paul committed
1129
    verify_program<test_triadd_broadcast>();
Paul's avatar
Paul committed
1130
    verify_program<test_softmax>();
Paul's avatar
Paul committed
1131
    verify_program<test_softmax2>();
Paul's avatar
Paul committed
1132
    verify_program<test_conv>();
Paul's avatar
Paul committed
1133
    verify_program<test_conv2>();
Khalique's avatar
Khalique committed
1134
    verify_program<test_group_conv>();
Paul's avatar
Paul committed
1135
    verify_program<test_conv_relu>();
Paul's avatar
Paul committed
1136
    verify_program<test_conv_relu_half>();
Paul's avatar
Paul committed
1137
    verify_program<test_add_relu>();
1138
    verify_program<test_leaky_relu>();
Khalique's avatar
Khalique committed
1139
1140
    verify_program<test_sigmoid>();
    verify_program<test_elu>();
Paul's avatar
Paul committed
1141
    verify_program<test_conv_pooling>();
1142
1143
    verify_program<test_global_avg_pooling>();
    verify_program<test_global_max_pooling>();
Paul's avatar
Paul committed
1144
    verify_program<test_gemm>();
Paul's avatar
Paul committed
1145
    verify_program<test_gemm_half>();
1146
    // verify_program<test_gemm_ld>();
1147
1148
1149
    verify_program<test_gemm_transposeb>();
    verify_program<test_gemm_transposea>();
    verify_program<test_gemm_transposeab>();
1150
1151
    verify_program<test_contiguous>();
    verify_program<test_transpose>();
1152
    verify_program<test_batchnorm_inference>();
Paul's avatar
Paul committed
1153
    verify_program<test_batchnorm_inference_2>();
Paul's avatar
Paul committed
1154
    verify_program<test_conv_bn>();
Paul's avatar
Paul committed
1155
    verify_program<test_conv_bn_relu_pooling>();
Paul's avatar
Paul committed
1156
    verify_program<test_conv_bn_relu_pooling2>();
1157
    verify_program<test_slice>();
1158
1159
    verify_program<test_gather>();
    verify_program<test_gather_neg_axis>();
Paul's avatar
Paul committed
1160
}