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

218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
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;
    }
};

struct test_tanh
{
    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::tanh{}, x);
        return p;
    }
};


Khalique's avatar
Khalique committed
255
256
struct test_scale
{
Paul's avatar
Paul committed
257
    migraphx::program create_program() const
Khalique's avatar
Khalique committed
258
    {
Paul's avatar
Paul committed
259
260
        migraphx::program p;
        migraphx::shape s{migraphx::shape::float_type, {3}};
Khalique's avatar
Khalique committed
261
        auto x     = p.add_parameter("x", s);
Paul's avatar
Paul committed
262
263
264
        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
265
266
267
268
        return p;
    }
};

269
270
struct test_slice
{
Paul's avatar
Paul committed
271
    migraphx::program create_program() const
272
    {
Paul's avatar
Paul committed
273
274
        migraphx::program p;
        migraphx::shape s{migraphx::shape::int32_type, {2, 2, 4}};
275
        auto x      = p.add_parameter("x", s);
Paul's avatar
Paul committed
276
277
278
        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);
279
280
281
282
283

        return p;
    }
};

Paul's avatar
Paul committed
284
285
struct test_triadd
{
Paul's avatar
Paul committed
286
    migraphx::program create_program() const
Paul's avatar
Paul committed
287
    {
Paul's avatar
Paul committed
288
289
        migraphx::program p;
        migraphx::shape s{migraphx::shape::float_type, {3}};
Paul's avatar
Paul committed
290
291
292
        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
293
294
        auto sum = p.add_instruction(migraphx::op::add{}, x, y);
        p.add_instruction(migraphx::op::add{}, sum, z);
Paul's avatar
Paul committed
295
296
297
298
299
300
        return p;
    }
};

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

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

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

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

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

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

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

Paul's avatar
Paul committed
402
403
struct test_softmax
{
Paul's avatar
Paul committed
404
    migraphx::program create_program() const
Paul's avatar
Paul committed
405
    {
Paul's avatar
Paul committed
406
407
408
        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
409
410
411
412
413
414
        return p;
    }
};

struct test_softmax2
{
Paul's avatar
Paul committed
415
    migraphx::program create_program() const
Paul's avatar
Paul committed
416
    {
Paul's avatar
Paul committed
417
        migraphx::program p;
Paul's avatar
Paul committed
418
419
        auto x =
            p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {1, 1000, 1, 1}});
Paul's avatar
Paul committed
420
        p.add_instruction(migraphx::op::softmax{}, x);
Paul's avatar
Paul committed
421
422
423
424
        return p;
    }
};

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

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

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

Paul's avatar
Paul committed
468
469
struct test_conv_relu_half
{
Paul's avatar
Paul committed
470
    migraphx::program create_program() const
Paul's avatar
Paul committed
471
    {
Paul's avatar
Paul committed
472
        migraphx::program p;
Paul's avatar
Paul committed
473
474
        auto input =
            p.add_parameter("x", migraphx::shape{migraphx::shape::half_type, {4, 3, 3, 3}});
Paul's avatar
Paul committed
475
        auto weights =
Paul's avatar
Paul committed
476
477
478
            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
479
480
481
482
        return p;
    }
};

Paul's avatar
Paul committed
483
484
struct test_add_relu
{
Paul's avatar
Paul committed
485
    migraphx::program create_program() const
Paul's avatar
Paul committed
486
    {
Paul's avatar
Paul committed
487
488
489
490
491
        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
492
493
494
495
        return p;
    }
};

496
497
struct test_leaky_relu
{
Paul's avatar
Paul committed
498
    migraphx::program create_program() const
499
    {
Paul's avatar
Paul committed
500
501
502
        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);
503
504
505
506
        return p;
    }
};

Paul's avatar
Paul committed
507
508
struct test_conv_pooling
{
Paul's avatar
Paul committed
509
    migraphx::program create_program() const
Paul's avatar
Paul committed
510
    {
Paul's avatar
Paul committed
511
        migraphx::program p;
Paul's avatar
Paul committed
512
        auto input =
Paul's avatar
Paul committed
513
            p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {4, 3, 32, 32}});
Paul's avatar
Paul committed
514
        auto weights =
Paul's avatar
Paul committed
515
516
517
518
            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
519
520
521
522
        return p;
    }
};

523
524
struct test_global_avg_pooling
{
Paul's avatar
Paul committed
525
    migraphx::program create_program() const
526
    {
Paul's avatar
Paul committed
527
        migraphx::program p;
528
        auto input =
Paul's avatar
Paul committed
529
530
            p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {1, 3, 16, 16}});
        auto op    = migraphx::op::pooling{"average"};
531
        auto lens  = input->get_shape().lens();
Khalique's avatar
Khalique committed
532
        op.lengths = {lens[2], lens[3]};
533
534
535
536
537
538
539
        p.add_instruction(op, input);
        return p;
    }
};

struct test_global_max_pooling
{
Paul's avatar
Paul committed
540
    migraphx::program create_program() const
541
    {
Paul's avatar
Paul committed
542
        migraphx::program p;
543
        auto input =
Paul's avatar
Paul committed
544
545
            p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {1, 3, 16, 16}});
        auto op    = migraphx::op::pooling{"max"};
546
        auto lens  = input->get_shape().lens();
Khalique's avatar
Khalique committed
547
        op.lengths = {lens[2], lens[3]};
548
549
550
551
552
        p.add_instruction(op, input);
        return p;
    }
};

Paul's avatar
Paul committed
553
554
struct test_gemm
{
Paul's avatar
Paul committed
555
    migraphx::program create_program() const
Paul's avatar
Paul committed
556
    {
Paul's avatar
Paul committed
557
558
559
560
        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
561
562
563
564
        return p;
    }
};

Paul's avatar
Paul committed
565
566
struct test_gemm_half
{
Paul's avatar
Paul committed
567
    migraphx::program create_program() const
Paul's avatar
Paul committed
568
    {
Paul's avatar
Paul committed
569
570
571
572
        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
573
574
575
576
        return p;
    }
};

Paul's avatar
Paul committed
577
578
struct test_gemm_ld
{
Paul's avatar
Paul committed
579
    migraphx::program create_program() const
Paul's avatar
Paul committed
580
    {
Paul's avatar
Paul committed
581
        migraphx::program p;
Paul's avatar
Paul committed
582
583
584
585
        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
586
        p.add_instruction(migraphx::op::dot{}, a, b);
Paul's avatar
Paul committed
587
588
589
590
        return p;
    }
};

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

struct test_gemm_transposea
{
Paul's avatar
Paul committed
606
    migraphx::program create_program() const
607
    {
Paul's avatar
Paul committed
608
609
610
611
612
        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);
613
614
615
616
617
618
        return p;
    }
};

struct test_gemm_transposeab
{
Paul's avatar
Paul committed
619
    migraphx::program create_program() const
620
    {
Paul's avatar
Paul committed
621
622
623
624
625
626
        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);
627
628
629
630
        return p;
    }
};

631
632
struct test_contiguous
{
Paul's avatar
Paul committed
633
    migraphx::program create_program() const
634
    {
Paul's avatar
Paul committed
635
636
        migraphx::program p;
        migraphx::shape s{migraphx::shape::float_type, {4, 4, 4, 3}, {48, 4, 1, 16}};
637
        auto x = p.add_parameter("x", s);
Paul's avatar
Paul committed
638
        p.add_instruction(migraphx::op::contiguous{}, x);
Paul's avatar
Paul committed
639
        EXPECT(p.get_shape().standard());
640
641
642
643
        return p;
    }
};

644
struct test_transpose
645
{
Paul's avatar
Paul committed
646
    migraphx::program create_program() const
647
    {
Paul's avatar
Paul committed
648
649
        migraphx::program p;
        migraphx::shape s{migraphx::shape::float_type, {4, 3, 4, 4}};
650
651
        auto x                    = p.add_parameter("x", s);
        std::vector<int64_t> perm = {0, 2, 3, 1};
Paul's avatar
Paul committed
652
653
        auto l                    = p.add_instruction(migraphx::op::transpose{perm}, x);
        p.add_instruction(migraphx::op::contiguous{}, l);
654
655
656
        return p;
    }
};
657

Paul's avatar
Paul committed
658
659
660
661
662
663
664
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
665
    migraphx::program create_program() const
Paul's avatar
Paul committed
666
    {
Paul's avatar
Paul committed
667
        migraphx::program p;
Paul's avatar
Paul committed
668

Paul's avatar
Paul committed
669
670
        migraphx::shape s{migraphx::shape::float_type, {batches, channels, height, width}};
        migraphx::shape vars{migraphx::shape::float_type, {channels}};
Paul's avatar
Paul committed
671
        auto x        = p.add_parameter("x", s);
Paul's avatar
Paul committed
672
673
674
675
676
        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
677
678
679
680
        return p;
    }
};

wsttiger's avatar
wsttiger committed
681
682
683
684
685
686
687
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
688
    migraphx::program create_program() const
wsttiger's avatar
wsttiger committed
689
    {
Paul's avatar
Paul committed
690
        migraphx::program p;
wsttiger's avatar
wsttiger committed
691

Paul's avatar
Paul committed
692
693
        migraphx::shape s{migraphx::shape::float_type, {batches, channels, height, width}};
        migraphx::shape vars{migraphx::shape::float_type, {channels}};
wsttiger's avatar
wsttiger committed
694
        auto x        = p.add_parameter("x", s);
Paul's avatar
Paul committed
695
696
697
698
699
        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
700
701
702
703
        return p;
    }
};

Paul's avatar
Paul committed
704
705
struct test_conv_bn
{
Paul's avatar
Paul committed
706
    migraphx::program create_program() const
Paul's avatar
Paul committed
707
    {
Paul's avatar
Paul committed
708
        migraphx::program p;
Paul's avatar
Paul committed
709

Paul's avatar
Paul committed
710
711
712
        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
713
714
        auto x        = p.add_parameter("x", xs);
        auto w        = p.add_parameter("w", ws);
Paul's avatar
Paul committed
715
716
717
718
719
720
        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
721
722
723
724
        return p;
    }
};

Paul's avatar
Paul committed
725
726
struct test_conv_bn_relu_pooling
{
Paul's avatar
Paul committed
727
    migraphx::program create_program() const
Paul's avatar
Paul committed
728
    {
Paul's avatar
Paul committed
729
        migraphx::program p;
Paul's avatar
Paul committed
730

Paul's avatar
Paul committed
731
732
733
        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
734
735
        auto x        = p.add_parameter("x", xs);
        auto w        = p.add_parameter("w", ws);
Paul's avatar
Paul committed
736
737
738
739
740
        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
741
        auto bn       = p.add_instruction(
Paul's avatar
Paul committed
742
743
744
            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
745
746
747
748
        return p;
    }
};

749
750
struct test_concat
{
Paul's avatar
Paul committed
751
    migraphx::program create_program() const
752
    {
Paul's avatar
Paul committed
753
        migraphx::program p;
wsttiger's avatar
wsttiger committed
754
        std::size_t axis = 1;
Paul's avatar
Paul committed
755
756
757
        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}};
758
759
760
        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
761
        p.add_instruction(migraphx::op::concat{axis}, l0, l1, l2);
762
763
764
765
766
767
        return p;
    }
};

struct test_concat2
{
Paul's avatar
Paul committed
768
    migraphx::program create_program() const
769
    {
Paul's avatar
Paul committed
770
        migraphx::program p;
wsttiger's avatar
wsttiger committed
771
        std::size_t axis = 0;
Paul's avatar
Paul committed
772
773
774
        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}};
775
776
777
        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
778
        p.add_instruction(migraphx::op::concat{axis}, l0, l1, l2);
779
780
781
782
        return p;
    }
};

wsttiger's avatar
wsttiger committed
783
784
struct test_concat_relu
{
Paul's avatar
Paul committed
785
    migraphx::program create_program() const
wsttiger's avatar
wsttiger committed
786
    {
Paul's avatar
Paul committed
787
        migraphx::program p;
wsttiger's avatar
wsttiger committed
788
        std::size_t axis = 0;
Paul's avatar
Paul committed
789
790
791
        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
792
793
794
        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
795
796
797
798
799
        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
800
801
802
803
804
805
        return p;
    }
};

void manual_identity()
{
Paul's avatar
Paul committed
806
    migraphx::program p;
wsttiger's avatar
wsttiger committed
807
    std::vector<float> data0 = {0, 1, 2, 3};
Paul's avatar
Paul committed
808
809
810
811
812
    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
813
814
    for(auto&& x : p.get_parameter_shapes())
    {
Paul's avatar
Paul committed
815
        m[x.first] = migraphx::gpu::to_gpu(migraphx::generate_argument(x.second));
wsttiger's avatar
wsttiger committed
816
    }
Paul's avatar
Paul committed
817
    auto result = migraphx::gpu::from_gpu(p.eval(m));
wsttiger's avatar
wsttiger committed
818
819
820
821
822
    std::cout << result << std::endl;
}

void manual_test_concat_relu()
{
Paul's avatar
Paul committed
823
    migraphx::program p;
wsttiger's avatar
wsttiger committed
824
    std::size_t axis         = 0;
wsttiger's avatar
wsttiger committed
825
826
827
    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
828
829
830
831
832
833
834
835
836
837
838
839
840
841
    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
842
843
    for(auto&& x : p.get_parameter_shapes())
    {
Paul's avatar
Paul committed
844
        m[x.first] = migraphx::gpu::to_gpu(migraphx::generate_argument(x.second));
wsttiger's avatar
wsttiger committed
845
    }
Paul's avatar
Paul committed
846
    auto result = migraphx::gpu::from_gpu(p.eval(m));
wsttiger's avatar
wsttiger committed
847
848
849
    std::cout << result << std::endl;
}

Paul's avatar
Paul committed
850
851
struct test_conv_bn_relu_pooling2
{
Paul's avatar
Paul committed
852
853
    static migraphx::instruction_ref
    add_bn(migraphx::program& p, migraphx::instruction_ref x, std::size_t channels)
Paul's avatar
Paul committed
854
    {
Paul's avatar
Paul committed
855
        migraphx::shape vars{migraphx::shape::float_type, {channels}};
Paul's avatar
Paul committed
856
857
858
859
860
        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
861
        return p.add_instruction(
Paul's avatar
Paul committed
862
            migraphx::op::batch_norm_inference{}, x, scale, bias, mean, variance);
Paul's avatar
Paul committed
863
    }
Paul's avatar
Paul committed
864
    migraphx::program create_program() const
Paul's avatar
Paul committed
865
    {
Paul's avatar
Paul committed
866
        migraphx::program p;
Paul's avatar
Paul committed
867

Paul's avatar
Paul committed
868
869
870
871
        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
872
873
        auto x1    = p.add_parameter("x1", xs1);
        auto w1    = p.add_parameter("w1", ws1);
Paul's avatar
Paul committed
874
        auto conv1 = p.add_instruction(migraphx::op::convolution{{0, 0}, {1, 1}, {1, 1}}, x1, w1);
Paul's avatar
Paul committed
875
876
877
        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
878
        auto conv2 = p.add_instruction(migraphx::op::convolution{{0, 0}, {2, 2}, {1, 1}}, x2, w2);
Paul's avatar
Paul committed
879
        auto bn2   = add_bn(p, conv2, 2048);
Paul's avatar
Paul committed
880
881
882
        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
883
884
885
886
        return p;
    }
};

Paul's avatar
Paul committed
887
888
int main()
{
889
890
    verify_program<test_concat>();
    verify_program<test_concat2>();
wsttiger's avatar
wsttiger committed
891
    verify_program<test_concat_relu>();
Paul's avatar
Paul committed
892
    verify_program<test_add>();
Paul's avatar
Paul committed
893
    verify_program<test_add_half>();
Khalique's avatar
Khalique committed
894
    verify_program<test_mul>();
895
    verify_program<test_sin>();
896
897
898
    verify_program<test_sinh>();
    verify_program<test_cosh>();
    verify_program<test_tanh>();
Khalique's avatar
Khalique committed
899
    verify_program<test_scale>();
Paul's avatar
Paul committed
900
901
    verify_program<test_triadd>();
    verify_program<test_triadd2>();
Paul's avatar
Paul committed
902
    verify_program<test_add_broadcast>();
Paul's avatar
Paul committed
903
    verify_program<test_add_broadcast2>();
Paul's avatar
Latest  
Paul committed
904
905
    verify_program<test_add_broadcast3>();
    verify_program<test_add_broadcast4>();
Paul's avatar
Paul committed
906
    verify_program<test_add_broadcast5>();
Paul's avatar
Paul committed
907
    verify_program<test_triadd_broadcast>();
Paul's avatar
Paul committed
908
    verify_program<test_softmax>();
Paul's avatar
Paul committed
909
    verify_program<test_softmax2>();
Paul's avatar
Paul committed
910
    verify_program<test_conv>();
Paul's avatar
Paul committed
911
    verify_program<test_conv2>();
Paul's avatar
Paul committed
912
    verify_program<test_conv_relu>();
Paul's avatar
Paul committed
913
    verify_program<test_conv_relu_half>();
Paul's avatar
Paul committed
914
    verify_program<test_add_relu>();
915
    verify_program<test_leaky_relu>();
Paul's avatar
Paul committed
916
    verify_program<test_conv_pooling>();
917
918
    verify_program<test_global_avg_pooling>();
    verify_program<test_global_max_pooling>();
Paul's avatar
Paul committed
919
    verify_program<test_gemm>();
Paul's avatar
Paul committed
920
    verify_program<test_gemm_half>();
921
    // verify_program<test_gemm_ld>();
922
923
924
    verify_program<test_gemm_transposeb>();
    verify_program<test_gemm_transposea>();
    verify_program<test_gemm_transposeab>();
925
926
    verify_program<test_contiguous>();
    verify_program<test_transpose>();
927
    verify_program<test_batchnorm_inference>();
Paul's avatar
Paul committed
928
    verify_program<test_batchnorm_inference_2>();
Paul's avatar
Paul committed
929
    verify_program<test_conv_bn>();
Paul's avatar
Paul committed
930
    verify_program<test_conv_bn_relu_pooling>();
Paul's avatar
Paul committed
931
    verify_program<test_conv_bn_relu_pooling2>();
932
    verify_program<test_slice>();
Paul's avatar
Paul committed
933
}