miopen.cpp 31.6 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;
    }
};

206
207
208
209
210
211
212
213
214
215
216
217
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
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
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;
    }
};

Khalique's avatar
Khalique committed
242
243
struct test_scale
{
Paul's avatar
Paul committed
244
    migraphx::program create_program() const
Khalique's avatar
Khalique committed
245
    {
Paul's avatar
Paul committed
246
247
        migraphx::program p;
        migraphx::shape s{migraphx::shape::float_type, {3}};
Khalique's avatar
Khalique committed
248
        auto x     = p.add_parameter("x", s);
Paul's avatar
Paul committed
249
250
251
        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
252
253
254
255
        return p;
    }
};

256
257
struct test_slice
{
Paul's avatar
Paul committed
258
    migraphx::program create_program() const
259
    {
Paul's avatar
Paul committed
260
261
        migraphx::program p;
        migraphx::shape s{migraphx::shape::int32_type, {2, 2, 4}};
262
        auto x      = p.add_parameter("x", s);
Paul's avatar
Paul committed
263
264
265
        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);
266
267
268
269
270

        return p;
    }
};

Paul's avatar
Paul committed
271
272
struct test_triadd
{
Paul's avatar
Paul committed
273
    migraphx::program create_program() const
Paul's avatar
Paul committed
274
    {
Paul's avatar
Paul committed
275
276
        migraphx::program p;
        migraphx::shape s{migraphx::shape::float_type, {3}};
Paul's avatar
Paul committed
277
278
279
        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
280
281
        auto sum = p.add_instruction(migraphx::op::add{}, x, y);
        p.add_instruction(migraphx::op::add{}, sum, z);
Paul's avatar
Paul committed
282
283
284
285
286
287
        return p;
    }
};

struct test_triadd2
{
Paul's avatar
Paul committed
288
    migraphx::program create_program() const
Paul's avatar
Paul committed
289
    {
Paul's avatar
Paul committed
290
291
292
        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
293
294
295
        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
296
297
298
        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
299
300
301
302
        return p;
    }
};

Paul's avatar
Paul committed
303
304
struct test_add_broadcast
{
Paul's avatar
Paul committed
305
    migraphx::program create_program() const
Paul's avatar
Paul committed
306
    {
Paul's avatar
Paul committed
307
308
309
310
311
312
        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
313
314
315
316
        return p;
    }
};

Paul's avatar
Paul committed
317
318
struct test_add_broadcast2
{
Paul's avatar
Paul committed
319
    migraphx::program create_program() const
Paul's avatar
Paul committed
320
    {
Paul's avatar
Paul committed
321
322
323
324
325
326
        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
327
328
329
330
        return p;
    }
};

Paul's avatar
Latest  
Paul committed
331
332
struct test_add_broadcast3
{
Paul's avatar
Paul committed
333
    migraphx::program create_program() const
Paul's avatar
Latest  
Paul committed
334
    {
Paul's avatar
Paul committed
335
336
337
338
339
340
        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
341
342
343
344
345
346
        return p;
    }
};

struct test_add_broadcast4
{
Paul's avatar
Paul committed
347
    migraphx::program create_program() const
Paul's avatar
Latest  
Paul committed
348
    {
Paul's avatar
Paul committed
349
350
351
352
353
354
        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
355
356
357
358
        return p;
    }
};

Paul's avatar
Paul committed
359
360
struct test_add_broadcast5
{
Paul's avatar
Paul committed
361
    migraphx::program create_program() const
Paul's avatar
Paul committed
362
    {
Paul's avatar
Paul committed
363
364
365
366
367
368
        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
369
370
371
372
        return p;
    }
};

Paul's avatar
Paul committed
373
374
struct test_triadd_broadcast
{
Paul's avatar
Paul committed
375
    migraphx::program create_program() const
Paul's avatar
Paul committed
376
    {
Paul's avatar
Paul committed
377
378
379
380
381
382
383
384
        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
385
386
387
388
        return p;
    }
};

Paul's avatar
Paul committed
389
390
struct test_softmax
{
Paul's avatar
Paul committed
391
    migraphx::program create_program() const
Paul's avatar
Paul committed
392
    {
Paul's avatar
Paul committed
393
394
395
        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
396
397
398
399
400
401
        return p;
    }
};

struct test_softmax2
{
Paul's avatar
Paul committed
402
    migraphx::program create_program() const
Paul's avatar
Paul committed
403
    {
Paul's avatar
Paul committed
404
        migraphx::program p;
Paul's avatar
Paul committed
405
406
        auto x =
            p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {1, 1000, 1, 1}});
Paul's avatar
Paul committed
407
        p.add_instruction(migraphx::op::softmax{}, x);
Paul's avatar
Paul committed
408
409
410
411
        return p;
    }
};

Paul's avatar
Paul committed
412
413
struct test_conv
{
Paul's avatar
Paul committed
414
    migraphx::program create_program() const
Paul's avatar
Paul committed
415
    {
Paul's avatar
Paul committed
416
        migraphx::program p;
Paul's avatar
Paul committed
417
418
        auto input =
            p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {4, 3, 3, 3}});
Paul's avatar
Paul committed
419
        auto weights =
Paul's avatar
Paul committed
420
421
            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
422
423
424
425
        return p;
    }
};

Paul's avatar
Paul committed
426
427
struct test_conv2
{
Paul's avatar
Paul committed
428
    migraphx::program create_program() const
Paul's avatar
Paul committed
429
    {
Paul's avatar
Paul committed
430
        migraphx::program p;
Paul's avatar
Paul committed
431
        auto input =
Paul's avatar
Paul committed
432
            p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {1, 512, 28, 28}});
Paul's avatar
Paul committed
433
        auto weights =
Paul's avatar
Paul committed
434
435
            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
436
437
438
439
        return p;
    }
};

Paul's avatar
Paul committed
440
struct test_conv_relu
Paul's avatar
Paul committed
441
{
Paul's avatar
Paul committed
442
    migraphx::program create_program() const
Paul's avatar
Paul committed
443
    {
Paul's avatar
Paul committed
444
        migraphx::program p;
Paul's avatar
Paul committed
445
446
        auto input =
            p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {4, 3, 3, 3}});
Paul's avatar
Paul committed
447
        auto weights =
Paul's avatar
Paul committed
448
449
450
            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
451
452
453
454
        return p;
    }
};

Paul's avatar
Paul committed
455
456
struct test_conv_relu_half
{
Paul's avatar
Paul committed
457
    migraphx::program create_program() const
Paul's avatar
Paul committed
458
    {
Paul's avatar
Paul committed
459
        migraphx::program p;
Paul's avatar
Paul committed
460
461
        auto input =
            p.add_parameter("x", migraphx::shape{migraphx::shape::half_type, {4, 3, 3, 3}});
Paul's avatar
Paul committed
462
        auto weights =
Paul's avatar
Paul committed
463
464
465
            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
466
467
468
469
        return p;
    }
};

Paul's avatar
Paul committed
470
471
struct test_add_relu
{
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
        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
479
480
481
482
        return p;
    }
};

Khalique's avatar
Khalique committed
483
484
485
486
487
struct test_sigmoid
{
    migraphx::program create_program() const
    {
        migraphx::program p;
Khalique's avatar
Khalique committed
488
        auto x = p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {4, 3, 3, 3}});
Khalique's avatar
Khalique committed
489
490
491
492
493
494
495
496
497
498
        p.add_instruction(migraphx::op::sigmoid{}, x);
        return p;
    }
};

struct test_tanh
{
    migraphx::program create_program() const
    {
        migraphx::program p;
Khalique's avatar
Khalique committed
499
        auto x = p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {4, 3, 3, 3}});
Khalique's avatar
Khalique committed
500
501
502
503
504
505
506
507
508
509
        p.add_instruction(migraphx::op::tanh{}, x);
        return p;
    }
};

struct test_abs
{
    migraphx::program create_program() const
    {
        migraphx::program p;
Khalique's avatar
Khalique committed
510
        auto x = p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {4, 3, 3, 3}});
Khalique's avatar
Khalique committed
511
512
513
514
515
        p.add_instruction(migraphx::op::abs{}, x);
        return p;
    }
};

516
517
struct test_leaky_relu
{
Paul's avatar
Paul committed
518
    migraphx::program create_program() const
519
    {
Paul's avatar
Paul committed
520
521
522
        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);
523
524
525
526
        return p;
    }
};

Khalique's avatar
Khalique committed
527
528
529
530
531
532
533
534
535
536
537
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);
        return p;
    }
};

Paul's avatar
Paul committed
538
539
struct test_conv_pooling
{
Paul's avatar
Paul committed
540
    migraphx::program create_program() const
Paul's avatar
Paul committed
541
    {
Paul's avatar
Paul committed
542
        migraphx::program p;
Paul's avatar
Paul committed
543
        auto input =
Paul's avatar
Paul committed
544
            p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {4, 3, 32, 32}});
Paul's avatar
Paul committed
545
        auto weights =
Paul's avatar
Paul committed
546
547
548
549
            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
550
551
552
553
        return p;
    }
};

554
555
struct test_global_avg_pooling
{
Paul's avatar
Paul committed
556
    migraphx::program create_program() const
557
    {
Paul's avatar
Paul committed
558
        migraphx::program p;
559
        auto input =
Paul's avatar
Paul committed
560
561
            p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {1, 3, 16, 16}});
        auto op    = migraphx::op::pooling{"average"};
562
        auto lens  = input->get_shape().lens();
Khalique's avatar
Khalique committed
563
        op.lengths = {lens[2], lens[3]};
564
565
566
567
568
569
570
        p.add_instruction(op, input);
        return p;
    }
};

struct test_global_max_pooling
{
Paul's avatar
Paul committed
571
    migraphx::program create_program() const
572
    {
Paul's avatar
Paul committed
573
        migraphx::program p;
574
        auto input =
Paul's avatar
Paul committed
575
576
            p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {1, 3, 16, 16}});
        auto op    = migraphx::op::pooling{"max"};
577
        auto lens  = input->get_shape().lens();
Khalique's avatar
Khalique committed
578
        op.lengths = {lens[2], lens[3]};
579
580
581
582
583
        p.add_instruction(op, input);
        return p;
    }
};

Paul's avatar
Paul committed
584
585
struct test_gemm
{
Paul's avatar
Paul committed
586
    migraphx::program create_program() const
Paul's avatar
Paul committed
587
    {
Paul's avatar
Paul committed
588
589
590
591
        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
592
593
594
595
        return p;
    }
};

Paul's avatar
Paul committed
596
597
struct test_gemm_half
{
Paul's avatar
Paul committed
598
    migraphx::program create_program() const
Paul's avatar
Paul committed
599
    {
Paul's avatar
Paul committed
600
601
602
603
        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
604
605
606
607
        return p;
    }
};

Paul's avatar
Paul committed
608
609
struct test_gemm_ld
{
Paul's avatar
Paul committed
610
    migraphx::program create_program() const
Paul's avatar
Paul committed
611
    {
Paul's avatar
Paul committed
612
        migraphx::program p;
Paul's avatar
Paul committed
613
614
615
616
        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
617
        p.add_instruction(migraphx::op::dot{}, a, b);
Paul's avatar
Paul committed
618
619
620
621
        return p;
    }
};

622
623
struct test_gemm_transposeb
{
Paul's avatar
Paul committed
624
    migraphx::program create_program() const
625
    {
Paul's avatar
Paul committed
626
627
628
629
630
        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);
631
632
633
634
635
636
        return p;
    }
};

struct test_gemm_transposea
{
Paul's avatar
Paul committed
637
    migraphx::program create_program() const
638
    {
Paul's avatar
Paul committed
639
640
641
642
643
        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);
644
645
646
647
648
649
        return p;
    }
};

struct test_gemm_transposeab
{
Paul's avatar
Paul committed
650
    migraphx::program create_program() const
651
    {
Paul's avatar
Paul committed
652
653
654
655
656
657
        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);
658
659
660
661
        return p;
    }
};

662
663
struct test_contiguous
{
Paul's avatar
Paul committed
664
    migraphx::program create_program() const
665
    {
Paul's avatar
Paul committed
666
667
        migraphx::program p;
        migraphx::shape s{migraphx::shape::float_type, {4, 4, 4, 3}, {48, 4, 1, 16}};
668
        auto x = p.add_parameter("x", s);
Paul's avatar
Paul committed
669
        p.add_instruction(migraphx::op::contiguous{}, x);
Paul's avatar
Paul committed
670
        EXPECT(p.get_shape().standard());
671
672
673
674
        return p;
    }
};

675
struct test_transpose
676
{
Paul's avatar
Paul committed
677
    migraphx::program create_program() const
678
    {
Paul's avatar
Paul committed
679
680
        migraphx::program p;
        migraphx::shape s{migraphx::shape::float_type, {4, 3, 4, 4}};
681
682
        auto x                    = p.add_parameter("x", s);
        std::vector<int64_t> perm = {0, 2, 3, 1};
Paul's avatar
Paul committed
683
684
        auto l                    = p.add_instruction(migraphx::op::transpose{perm}, x);
        p.add_instruction(migraphx::op::contiguous{}, l);
685
686
687
        return p;
    }
};
688

Paul's avatar
Paul committed
689
690
691
692
693
694
695
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
696
    migraphx::program create_program() const
Paul's avatar
Paul committed
697
    {
Paul's avatar
Paul committed
698
        migraphx::program p;
Paul's avatar
Paul committed
699

Paul's avatar
Paul committed
700
701
        migraphx::shape s{migraphx::shape::float_type, {batches, channels, height, width}};
        migraphx::shape vars{migraphx::shape::float_type, {channels}};
Paul's avatar
Paul committed
702
        auto x        = p.add_parameter("x", s);
Paul's avatar
Paul committed
703
704
705
706
707
        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
708
709
710
711
        return p;
    }
};

wsttiger's avatar
wsttiger committed
712
713
714
715
716
717
718
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
719
    migraphx::program create_program() const
wsttiger's avatar
wsttiger committed
720
    {
Paul's avatar
Paul committed
721
        migraphx::program p;
wsttiger's avatar
wsttiger committed
722

Paul's avatar
Paul committed
723
724
        migraphx::shape s{migraphx::shape::float_type, {batches, channels, height, width}};
        migraphx::shape vars{migraphx::shape::float_type, {channels}};
wsttiger's avatar
wsttiger committed
725
        auto x        = p.add_parameter("x", s);
Paul's avatar
Paul committed
726
727
728
729
730
        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
731
732
733
734
        return p;
    }
};

Paul's avatar
Paul committed
735
736
struct test_conv_bn
{
Paul's avatar
Paul committed
737
    migraphx::program create_program() const
Paul's avatar
Paul committed
738
    {
Paul's avatar
Paul committed
739
        migraphx::program p;
Paul's avatar
Paul committed
740

Paul's avatar
Paul committed
741
742
743
        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
744
745
        auto x        = p.add_parameter("x", xs);
        auto w        = p.add_parameter("w", ws);
Paul's avatar
Paul committed
746
747
748
749
750
751
        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
752
753
754
755
        return p;
    }
};

Paul's avatar
Paul committed
756
757
struct test_conv_bn_relu_pooling
{
Paul's avatar
Paul committed
758
    migraphx::program create_program() const
Paul's avatar
Paul committed
759
    {
Paul's avatar
Paul committed
760
        migraphx::program p;
Paul's avatar
Paul committed
761

Paul's avatar
Paul committed
762
763
764
        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
765
766
        auto x        = p.add_parameter("x", xs);
        auto w        = p.add_parameter("w", ws);
Paul's avatar
Paul committed
767
768
769
770
771
        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
772
        auto bn       = p.add_instruction(
Paul's avatar
Paul committed
773
774
775
            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
776
777
778
779
        return p;
    }
};

780
781
struct test_concat
{
Paul's avatar
Paul committed
782
    migraphx::program create_program() const
783
    {
Paul's avatar
Paul committed
784
        migraphx::program p;
wsttiger's avatar
wsttiger committed
785
        std::size_t axis = 1;
Paul's avatar
Paul committed
786
787
788
        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}};
789
790
791
        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
792
        p.add_instruction(migraphx::op::concat{axis}, l0, l1, l2);
793
794
795
796
797
798
        return p;
    }
};

struct test_concat2
{
Paul's avatar
Paul committed
799
    migraphx::program create_program() const
800
    {
Paul's avatar
Paul committed
801
        migraphx::program p;
wsttiger's avatar
wsttiger committed
802
        std::size_t axis = 0;
Paul's avatar
Paul committed
803
804
805
        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}};
806
807
808
        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
809
        p.add_instruction(migraphx::op::concat{axis}, l0, l1, l2);
810
811
812
813
        return p;
    }
};

wsttiger's avatar
wsttiger committed
814
815
struct test_concat_relu
{
Paul's avatar
Paul committed
816
    migraphx::program create_program() const
wsttiger's avatar
wsttiger committed
817
    {
Paul's avatar
Paul committed
818
        migraphx::program p;
wsttiger's avatar
wsttiger committed
819
        std::size_t axis = 0;
Paul's avatar
Paul committed
820
821
822
        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
823
824
825
        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
826
827
828
829
830
        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
831
832
833
834
835
836
        return p;
    }
};

void manual_identity()
{
Paul's avatar
Paul committed
837
    migraphx::program p;
wsttiger's avatar
wsttiger committed
838
    std::vector<float> data0 = {0, 1, 2, 3};
Paul's avatar
Paul committed
839
840
841
842
843
    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
844
845
    for(auto&& x : p.get_parameter_shapes())
    {
Paul's avatar
Paul committed
846
        m[x.first] = migraphx::gpu::to_gpu(migraphx::generate_argument(x.second));
wsttiger's avatar
wsttiger committed
847
    }
Paul's avatar
Paul committed
848
    auto result = migraphx::gpu::from_gpu(p.eval(m));
wsttiger's avatar
wsttiger committed
849
850
851
852
853
    std::cout << result << std::endl;
}

void manual_test_concat_relu()
{
Paul's avatar
Paul committed
854
    migraphx::program p;
wsttiger's avatar
wsttiger committed
855
    std::size_t axis         = 0;
wsttiger's avatar
wsttiger committed
856
857
858
    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
859
860
861
862
863
864
865
866
867
868
869
870
871
872
    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
873
874
    for(auto&& x : p.get_parameter_shapes())
    {
Paul's avatar
Paul committed
875
        m[x.first] = migraphx::gpu::to_gpu(migraphx::generate_argument(x.second));
wsttiger's avatar
wsttiger committed
876
    }
Paul's avatar
Paul committed
877
    auto result = migraphx::gpu::from_gpu(p.eval(m));
wsttiger's avatar
wsttiger committed
878
879
880
    std::cout << result << std::endl;
}

Paul's avatar
Paul committed
881
882
struct test_conv_bn_relu_pooling2
{
Paul's avatar
Paul committed
883
884
    static migraphx::instruction_ref
    add_bn(migraphx::program& p, migraphx::instruction_ref x, std::size_t channels)
Paul's avatar
Paul committed
885
    {
Paul's avatar
Paul committed
886
        migraphx::shape vars{migraphx::shape::float_type, {channels}};
Paul's avatar
Paul committed
887
888
889
890
891
        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
892
        return p.add_instruction(
Paul's avatar
Paul committed
893
            migraphx::op::batch_norm_inference{}, x, scale, bias, mean, variance);
Paul's avatar
Paul committed
894
    }
Paul's avatar
Paul committed
895
    migraphx::program create_program() const
Paul's avatar
Paul committed
896
    {
Paul's avatar
Paul committed
897
        migraphx::program p;
Paul's avatar
Paul committed
898

Paul's avatar
Paul committed
899
900
901
902
        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
903
904
        auto x1    = p.add_parameter("x1", xs1);
        auto w1    = p.add_parameter("w1", ws1);
Paul's avatar
Paul committed
905
        auto conv1 = p.add_instruction(migraphx::op::convolution{{0, 0}, {1, 1}, {1, 1}}, x1, w1);
Paul's avatar
Paul committed
906
907
908
        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
909
        auto conv2 = p.add_instruction(migraphx::op::convolution{{0, 0}, {2, 2}, {1, 1}}, x2, w2);
Paul's avatar
Paul committed
910
        auto bn2   = add_bn(p, conv2, 2048);
Paul's avatar
Paul committed
911
912
913
        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
914
915
916
917
        return p;
    }
};

Paul's avatar
Paul committed
918
919
int main()
{
Khalique's avatar
Khalique committed
920
    verify_program<test_abs>();
921
922
    verify_program<test_concat>();
    verify_program<test_concat2>();
wsttiger's avatar
wsttiger committed
923
    verify_program<test_concat_relu>();
Paul's avatar
Paul committed
924
    verify_program<test_add>();
Paul's avatar
Paul committed
925
    verify_program<test_add_half>();
Khalique's avatar
Khalique committed
926
    verify_program<test_mul>();
927
    verify_program<test_sin>();
Khalique's avatar
Khalique committed
928
    verify_program<test_scale>();
Paul's avatar
Paul committed
929
930
    verify_program<test_triadd>();
    verify_program<test_triadd2>();
Paul's avatar
Paul committed
931
    verify_program<test_add_broadcast>();
Paul's avatar
Paul committed
932
    verify_program<test_add_broadcast2>();
Paul's avatar
Latest  
Paul committed
933
934
    verify_program<test_add_broadcast3>();
    verify_program<test_add_broadcast4>();
Paul's avatar
Paul committed
935
    verify_program<test_add_broadcast5>();
Paul's avatar
Paul committed
936
    verify_program<test_triadd_broadcast>();
Paul's avatar
Paul committed
937
    verify_program<test_softmax>();
Paul's avatar
Paul committed
938
    verify_program<test_softmax2>();
Paul's avatar
Paul committed
939
    verify_program<test_conv>();
Paul's avatar
Paul committed
940
    verify_program<test_conv2>();
Paul's avatar
Paul committed
941
    verify_program<test_conv_relu>();
Paul's avatar
Paul committed
942
    verify_program<test_conv_relu_half>();
Paul's avatar
Paul committed
943
    verify_program<test_add_relu>();
944
    verify_program<test_leaky_relu>();
Khalique's avatar
Khalique committed
945
946
947
    verify_program<test_sigmoid>();
    verify_program<test_tanh>();
    verify_program<test_elu>();
Paul's avatar
Paul committed
948
    verify_program<test_conv_pooling>();
949
950
    verify_program<test_global_avg_pooling>();
    verify_program<test_global_max_pooling>();
Paul's avatar
Paul committed
951
    verify_program<test_gemm>();
Paul's avatar
Paul committed
952
    verify_program<test_gemm_half>();
953
    // verify_program<test_gemm_ld>();
954
955
956
    verify_program<test_gemm_transposeb>();
    verify_program<test_gemm_transposea>();
    verify_program<test_gemm_transposeab>();
957
958
    verify_program<test_contiguous>();
    verify_program<test_transpose>();
959
    verify_program<test_batchnorm_inference>();
Paul's avatar
Paul committed
960
    verify_program<test_batchnorm_inference_2>();
Paul's avatar
Paul committed
961
    verify_program<test_conv_bn>();
Paul's avatar
Paul committed
962
    verify_program<test_conv_bn_relu_pooling>();
Paul's avatar
Paul committed
963
    verify_program<test_conv_bn_relu_pooling2>();
964
    verify_program<test_slice>();
Paul's avatar
Paul committed
965
}