api.cpp 46.2 KB
Newer Older
Paul Fultz II's avatar
Paul Fultz II committed
1
2
3
4
5
#include <migraphx/migraphx.h>
#include <migraphx/rank.hpp>
#include <migraphx/shape.hpp>
#include <migraphx/program.hpp>
#include <migraphx/onnx.hpp>
kahmed10's avatar
kahmed10 committed
6
#include <migraphx/tf.hpp>
7
#include <migraphx/register_target.hpp>
Paul Fultz II's avatar
Paul Fultz II committed
8
#include <migraphx/generate.hpp>
Shucai Xiao's avatar
Shucai Xiao committed
9
#include <migraphx/quantization.hpp>
10
#include <migraphx/ref/target.hpp>
11
#include <migraphx/load_save.hpp>
12
13
14
15
#include <migraphx/make_op.hpp>
#include <migraphx/json.hpp>
#include <migraphx/convert_to_json.hpp>
#include <algorithm>
16
#include <cstdarg>
Paul Fultz II's avatar
Paul Fultz II committed
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

namespace migraphx {

template <class F>
migraphx_status try_(F f, bool output = true) // NOLINT
{
    try
    {
        f();
    }
    catch(const migraphx::exception& ex)
    {
        if(output)
            std::cerr << "MIGraphX Error: " << ex.what() << std::endl;
        if(ex.error > 0)
            return migraphx_status(ex.error);
        else
            return migraphx_status_unknown_error;
    }
    catch(const std::exception& ex)
    {
        if(output)
            std::cerr << "MIGraphX Error: " << ex.what() << std::endl;
        return migraphx_status_unknown_error;
    }
    catch(...)
    {
        return migraphx_status_unknown_error;
    }
    return migraphx_status_success;
}

shape::type_t to_shape_type(migraphx_shape_datatype_t t)
{
    switch(t)
    {
Paul Fultz II's avatar
Paul Fultz II committed
53
    case migraphx_shape_tuple_type: return shape::tuple_type;
Paul Fultz II's avatar
Paul Fultz II committed
54
55
56
57
58
59
60
61
62
63
64
65
#define MIGRAPHX_DETAIL_SHAPE_CASE_CONVERT(x, y) \
    case migraphx_shape_##x: return shape::x;
        MIGRAPHX_SHAPE_VISIT_TYPES(MIGRAPHX_DETAIL_SHAPE_CASE_CONVERT)
#undef MIGRAPHX_DETAIL_SHAPE_CASE_CONVERT
    }
    MIGRAPHX_THROW(migraphx_status_bad_param, "Unknown type");
}

migraphx_shape_datatype_t to_shape_type(shape::type_t t)
{
    switch(t)
    {
Paul Fultz II's avatar
Paul Fultz II committed
66
    case shape::tuple_type: return migraphx_shape_tuple_type;
Paul Fultz II's avatar
Paul Fultz II committed
67
68
69
70
71
72
73
74
#define MIGRAPHX_DETAIL_SHAPE_CASE_CONVERT(x, y) \
    case shape::x: return migraphx_shape_##x;
        MIGRAPHX_SHAPE_VISIT_TYPES(MIGRAPHX_DETAIL_SHAPE_CASE_CONVERT)
#undef MIGRAPHX_DETAIL_SHAPE_CASE_CONVERT
    }
    MIGRAPHX_THROW(migraphx_status_bad_param, "Unknown type");
}

75
target get_target(const std::string& name) { return make_target(name); }
Paul Fultz II's avatar
Paul Fultz II committed
76

77
78
79
void set_offload_copy(compile_options& options, bool value) { options.offload_copy = value; }

void set_fast_math(compile_options& options, bool value) { options.fast_math = value; }
Paul Fultz II's avatar
Paul Fultz II committed
80

81
void set_file_format(file_options& options, const char* format) { options.format = format; }
82

83
void set_default_dim_value(onnx_options& options, size_t value)
Paul Fultz II's avatar
Paul Fultz II committed
84
{
85
86
87
    options.default_dim_value = value;
}

Shucai Xiao's avatar
Shucai Xiao committed
88
89
90
91
92
void set_default_loop_iterations(onnx_options& options, int64_t value)
{
    options.max_loop_iterations = value;
}

kahmed10's avatar
kahmed10 committed
93
94
95
96
void set_nhwc(tf_options& options, bool is_nhwc) { options.is_nhwc = is_nhwc; }

void set_default_dim_value(tf_options& options, size_t value) { options.batch_size = value; }

Shucai Xiao's avatar
Shucai Xiao committed
97
void set_input_parameter_shape(onnx_options& options, const char* name, std::vector<int> dims)
98
{
99
    options.map_input_dims[std::string(name)] = std::move(dims);
Paul Fultz II's avatar
Paul Fultz II committed
100
101
}

Shucai Xiao's avatar
Shucai Xiao committed
102
void set_input_parameter_shape(tf_options& options, const char* name, std::vector<int> dims)
kahmed10's avatar
kahmed10 committed
103
104
105
106
107
108
109
110
111
{
    options.map_input_dims[std::string(name)] = std::move(dims);
}

void set_output_names(tf_options& options, std::vector<const char*> names)
{
    options.output_node_names = std::vector<std::string>(names.begin(), names.end());
}

Paul Fultz II's avatar
Paul Fultz II committed
112
113
114
115
116
117
118
119
120
template <class Value>
std::vector<const char*> get_names(const std::unordered_map<std::string, Value>& m)
{
    std::vector<const char*> result;
    std::transform(
        m.begin(), m.end(), std::back_inserter(result), [](auto&& p) { return p.first.c_str(); });
    return result;
}

Shucai Xiao's avatar
Shucai Xiao committed
121
122
123
124
125
126
127
128
129
130
131
132
void quantize_fp16_with_op_names(program& prog, std::vector<std::string>& names)
{
    if(names.empty())
    {
        names = {"all"};
    }

    migraphx::quantize_fp16(prog, names);
}

struct quantize_int8_options
{
133
134
    std::vector<parameter_map> calibration = {};
    std::vector<std::string> op_names      = {};
Shucai Xiao's avatar
Shucai Xiao committed
135
136
137
138
139
140
141
};

void add_op_name(quantize_int8_options& options, const char* name)
{
    options.op_names.push_back(name);
}

142
void add_calibration_data(quantize_int8_options& options, parameter_map& data)
Shucai Xiao's avatar
Shucai Xiao committed
143
144
145
146
147
148
149
150
151
152
153
154
155
156
{
    options.calibration.push_back(data);
}

void quantize_int8_wrap(program& prog, const target& t, quantize_int8_options& options)
{
    if(options.op_names.empty())
    {
        options.op_names = {"dot", "convolution"};
    }

    migraphx::quantize_int8(prog, t, options.calibration, options.op_names);
}

157
158
159
160
161
162
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wformat-nonliteral"
#endif

operation create_op(const char* name, const char* attributes, va_list vlist)
163
{
164
165
166
    std::string sattributes = attributes == nullptr ? "" : attributes;
    std::vector<char> buffer(sattributes.size() * 2);
    std::vsnprintf(buffer.data(), buffer.size(), sattributes.c_str(), vlist);
167
168
169
    value v = value::object{};
    if(attributes != nullptr)
    {
170
        v = from_json_string(convert_to_json(std::string(buffer.data())));
171
172
173
174
175
176
    }
    auto op = make_op(name, v);

    return op;
}

177
178
179
180
#ifdef __clang__
#pragma clang diagnostic pop
#endif

Paul Fultz II's avatar
Paul Fultz II committed
181
182
183
184
185
186
template <class T>
bool equal(const T& x, const T& y)
{
    return x == y;
}

187
std::vector<argument> run(program& p, const parameter_map& params) { return p.eval(params); }
Paul Fultz II's avatar
Paul Fultz II committed
188

189
std::vector<shape> get_output_shapes(program& p) { return p.get_output_shapes(); }
Paul Fultz II's avatar
Paul Fultz II committed
190

Shucai Xiao's avatar
Shucai Xiao committed
191
192
193
void print_program(const program& p) { std::cout << p << std::endl; }

void print_module(const module& m) { std::cout << m << std::endl; }
Paul Fultz II's avatar
Paul Fultz II committed
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289

} // namespace migraphx

template <class T, class U, class Target = std::remove_pointer_t<T>>
Target* object_cast(U* x)
{
    return reinterpret_cast<Target*>(x);
}
template <class T, class U, class Target = std::remove_pointer_t<T>>
const Target* object_cast(const U* x)
{
    return reinterpret_cast<const Target*>(x);
}

template <class T, class... Ts, class Target = std::remove_pointer_t<T>>
Target* allocate(Ts&&... xs)
{
    return new Target(std::forward<Ts>(xs)...); // NOLINT
}

template <class T>
void destroy(T* x)
{
    delete x; // NOLINT
}

extern "C" struct migraphx_shape;
struct migraphx_shape
{
    template <class... Ts>
    migraphx_shape(Ts&&... xs) : object(std::forward<Ts>(xs)...)
    {
    }
    migraphx::shape object;
};

extern "C" struct migraphx_argument;
struct migraphx_argument
{
    template <class... Ts>
    migraphx_argument(Ts&&... xs) : object(std::forward<Ts>(xs)...)
    {
    }
    migraphx::argument object;
};

extern "C" struct migraphx_target;
struct migraphx_target
{
    template <class... Ts>
    migraphx_target(Ts&&... xs) : object(std::forward<Ts>(xs)...)
    {
    }
    migraphx::target object;
};

extern "C" struct migraphx_program_parameter_shapes;
struct migraphx_program_parameter_shapes
{
    template <class... Ts>
    migraphx_program_parameter_shapes(Ts&&... xs) : object(std::forward<Ts>(xs)...)
    {
    }
    std::unordered_map<std::string, migraphx::shape> object;
};

extern "C" struct migraphx_program_parameters;
struct migraphx_program_parameters
{
    template <class... Ts>
    migraphx_program_parameters(Ts&&... xs) : object(std::forward<Ts>(xs)...)
    {
    }
    std::unordered_map<std::string, migraphx::argument> object;
};

extern "C" struct migraphx_arguments;
struct migraphx_arguments
{
    template <class... Ts>
    migraphx_arguments(Ts&&... xs) : object(std::forward<Ts>(xs)...)
    {
    }
    std::vector<migraphx::argument> object;
};

extern "C" struct migraphx_shapes;
struct migraphx_shapes
{
    template <class... Ts>
    migraphx_shapes(Ts&&... xs) : object(std::forward<Ts>(xs)...)
    {
    }
    std::vector<migraphx::shape> object;
};

Shucai Xiao's avatar
Shucai Xiao committed
290
291
292
293
294
295
296
297
298
299
extern "C" struct migraphx_module;
struct migraphx_module
{
    template <class... Ts>
    migraphx_module(Ts&&... xs) : object(std::forward<Ts>(xs)...)
    {
    }
    migraphx::module object;
};

Paul Fultz II's avatar
Paul Fultz II committed
300
301
302
303
304
305
306
307
308
309
extern "C" struct migraphx_program;
struct migraphx_program
{
    template <class... Ts>
    migraphx_program(Ts&&... xs) : object(std::forward<Ts>(xs)...)
    {
    }
    migraphx::program object;
};

310
311
312
313
314
315
316
317
318
319
extern "C" struct migraphx_operation;
struct migraphx_operation
{
    template <class... Ts>
    migraphx_operation(Ts&&... xs) : object(std::forward<Ts>(xs)...)
    {
    }
    migraphx::operation object;
};

320
321
322
323
324
325
326
327
328
329
extern "C" struct migraphx_onnx_options;
struct migraphx_onnx_options
{
    template <class... Ts>
    migraphx_onnx_options(Ts&&... xs) : object(std::forward<Ts>(xs)...)
    {
    }
    migraphx::onnx_options object;
};

330
331
332
333
334
335
336
337
338
339
extern "C" struct migraphx_file_options;
struct migraphx_file_options
{
    template <class... Ts>
    migraphx_file_options(Ts&&... xs) : object(std::forward<Ts>(xs)...)
    {
    }
    migraphx::file_options object;
};

340
341
342
343
344
345
346
347
348
349
extern "C" struct migraphx_compile_options;
struct migraphx_compile_options
{
    template <class... Ts>
    migraphx_compile_options(Ts&&... xs) : object(std::forward<Ts>(xs)...)
    {
    }
    migraphx::compile_options object;
};

kahmed10's avatar
kahmed10 committed
350
351
352
353
354
355
356
357
358
359
extern "C" struct migraphx_tf_options;
struct migraphx_tf_options
{
    template <class... Ts>
    migraphx_tf_options(Ts&&... xs) : object(std::forward<Ts>(xs)...)
    {
    }
    migraphx::tf_options object;
};

Shucai Xiao's avatar
Shucai Xiao committed
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
extern "C" struct migraphx_quantize_op_names;
struct migraphx_quantize_op_names
{
    template <class... Ts>
    migraphx_quantize_op_names(Ts&&... xs) : object(std::forward<Ts>(xs)...)
    {
    }
    std::vector<std::string> object;
};

extern "C" struct migraphx_quantize_int8_options;
struct migraphx_quantize_int8_options
{
    template <class... Ts>
    migraphx_quantize_int8_options(Ts&&... xs) : object(std::forward<Ts>(xs)...)
    {
    }
    migraphx::quantize_int8_options object;
};

Paul Fultz II's avatar
Paul Fultz II committed
380
381
extern "C" migraphx_status migraphx_shape_destroy(migraphx_shape_t shape)
{
382
383
    auto api_error_result = migraphx::try_([&] { destroy((shape)); });
    return api_error_result;
Paul Fultz II's avatar
Paul Fultz II committed
384
385
}

386
387
388
389
390
391
392
extern "C" migraphx_status migraphx_shape_assign_to(migraphx_shape_t output,
                                                    const_migraphx_shape_t input)
{
    auto api_error_result = migraphx::try_([&] { *output = *input; });
    return api_error_result;
}

Paul Fultz II's avatar
Paul Fultz II committed
393
394
extern "C" migraphx_status migraphx_shape_create(migraphx_shape_t* shape,
                                                 migraphx_shape_datatype_t type,
395
396
                                                 int* lengths,
                                                 size_t lengths_size)
Paul Fultz II's avatar
Paul Fultz II committed
397
{
398
    auto api_error_result = migraphx::try_([&] {
399
        if(lengths == nullptr and lengths_size != 0)
Paul Fultz II's avatar
Paul Fultz II committed
400
            MIGRAPHX_THROW(migraphx_status_bad_param, "Bad parameter lengths: Null pointer");
Shucai Xiao's avatar
Shucai Xiao committed
401
402
        *shape = object_cast<migraphx_shape_t>(allocate<migraphx::shape>(
            (migraphx::to_shape_type(type)), (std::vector<int>(lengths, lengths + lengths_size))));
Paul Fultz II's avatar
Paul Fultz II committed
403
    });
404
    return api_error_result;
Paul Fultz II's avatar
Paul Fultz II committed
405
406
}

407
408
extern "C" migraphx_status migraphx_shape_create_with_strides(migraphx_shape_t* shape,
                                                              migraphx_shape_datatype_t type,
409
410
411
412
                                                              int* lengths,
                                                              size_t lengths_size,
                                                              int* strides,
                                                              size_t strides_size)
413
{
414
    auto api_error_result = migraphx::try_([&] {
415
416
417
418
419
420
        if(lengths == nullptr and lengths_size != 0)
            MIGRAPHX_THROW(migraphx_status_bad_param, "Bad parameter lengths: Null pointer");
        if(strides == nullptr and strides_size != 0)
            MIGRAPHX_THROW(migraphx_status_bad_param, "Bad parameter strides: Null pointer");
        *shape = object_cast<migraphx_shape_t>(
            allocate<migraphx::shape>((migraphx::to_shape_type(type)),
421
422
                                      (std::vector<int>(lengths, lengths + lengths_size)),
                                      (std::vector<int>(strides, strides + strides_size))));
423
    });
424
    return api_error_result;
425
426
}

427
428
429
extern "C" migraphx_status migraphx_shape_create_scalar(migraphx_shape_t* shape,
                                                        migraphx_shape_datatype_t type)
{
430
    auto api_error_result = migraphx::try_([&] {
431
432
433
        *shape = object_cast<migraphx_shape_t>(
            allocate<migraphx::shape>((migraphx::to_shape_type(type))));
    });
434
    return api_error_result;
435
436
}

Paul Fultz II's avatar
Paul Fultz II committed
437
extern "C" migraphx_status
Shucai Xiao's avatar
Shucai Xiao committed
438
migraphx_shape_lengths(const int** out, int* out_size, const_migraphx_shape_t shape)
Paul Fultz II's avatar
Paul Fultz II committed
439
{
440
    auto api_error_result = migraphx::try_([&] {
Paul Fultz II's avatar
Paul Fultz II committed
441
442
443
444
445
446
447
448
        if(out == nullptr or out_size == nullptr)
            MIGRAPHX_THROW(migraphx_status_bad_param, "Bad parameter out: Null pointer");
        if(shape == nullptr)
            MIGRAPHX_THROW(migraphx_status_bad_param, "Bad parameter shape: Null pointer");
        auto&& api_result = (shape->object).lens();
        *out              = api_result.data();
        *out_size         = api_result.size();
    });
449
    return api_error_result;
Paul Fultz II's avatar
Paul Fultz II committed
450
451
452
}

extern "C" migraphx_status
Shucai Xiao's avatar
Shucai Xiao committed
453
migraphx_shape_strides(const int** out, int* out_size, const_migraphx_shape_t shape)
Paul Fultz II's avatar
Paul Fultz II committed
454
{
455
    auto api_error_result = migraphx::try_([&] {
Paul Fultz II's avatar
Paul Fultz II committed
456
457
458
459
460
461
462
463
        if(out == nullptr or out_size == nullptr)
            MIGRAPHX_THROW(migraphx_status_bad_param, "Bad parameter out: Null pointer");
        if(shape == nullptr)
            MIGRAPHX_THROW(migraphx_status_bad_param, "Bad parameter shape: Null pointer");
        auto&& api_result = (shape->object).strides();
        *out              = api_result.data();
        *out_size         = api_result.size();
    });
464
    return api_error_result;
Paul Fultz II's avatar
Paul Fultz II committed
465
466
467
468
469
}

extern "C" migraphx_status migraphx_shape_type(migraphx_shape_datatype_t* out,
                                               const_migraphx_shape_t shape)
{
470
    auto api_error_result = migraphx::try_([&] {
Paul Fultz II's avatar
Paul Fultz II committed
471
472
473
474
475
476
        if(out == nullptr)
            MIGRAPHX_THROW(migraphx_status_bad_param, "Bad parameter out: Null pointer");
        if(shape == nullptr)
            MIGRAPHX_THROW(migraphx_status_bad_param, "Bad parameter shape: Null pointer");
        *out = migraphx::to_shape_type((shape->object).type());
    });
477
    return api_error_result;
Paul Fultz II's avatar
Paul Fultz II committed
478
479
480
481
}

extern "C" migraphx_status migraphx_shape_bytes(size_t* out, const_migraphx_shape_t shape)
{
482
    auto api_error_result = migraphx::try_([&] {
Paul Fultz II's avatar
Paul Fultz II committed
483
484
485
486
        if(shape == nullptr)
            MIGRAPHX_THROW(migraphx_status_bad_param, "Bad parameter shape: Null pointer");
        *out = (shape->object).bytes();
    });
487
    return api_error_result;
Paul Fultz II's avatar
Paul Fultz II committed
488
489
490
491
492
}

extern "C" migraphx_status
migraphx_shape_equal(bool* out, const_migraphx_shape_t shape, const_migraphx_shape_t x)
{
493
    auto api_error_result = migraphx::try_([&] {
Paul Fultz II's avatar
Paul Fultz II committed
494
495
496
497
498
499
        if(shape == nullptr)
            MIGRAPHX_THROW(migraphx_status_bad_param, "Bad parameter shape: Null pointer");
        if(x == nullptr)
            MIGRAPHX_THROW(migraphx_status_bad_param, "Bad parameter x: Null pointer");
        *out = migraphx::equal((shape->object), (x->object));
    });
500
    return api_error_result;
Paul Fultz II's avatar
Paul Fultz II committed
501
502
503
504
}

extern "C" migraphx_status migraphx_argument_destroy(migraphx_argument_t argument)
{
505
506
    auto api_error_result = migraphx::try_([&] { destroy((argument)); });
    return api_error_result;
Paul Fultz II's avatar
Paul Fultz II committed
507
508
}

509
510
511
512
513
514
515
extern "C" migraphx_status migraphx_argument_assign_to(migraphx_argument_t output,
                                                       const_migraphx_argument_t input)
{
    auto api_error_result = migraphx::try_([&] { *output = *input; });
    return api_error_result;
}

Paul Fultz II's avatar
Paul Fultz II committed
516
517
518
extern "C" migraphx_status
migraphx_argument_create(migraphx_argument_t* argument, const_migraphx_shape_t shape, void* buffer)
{
519
    auto api_error_result = migraphx::try_([&] {
Paul Fultz II's avatar
Paul Fultz II committed
520
521
522
523
524
        if(shape == nullptr)
            MIGRAPHX_THROW(migraphx_status_bad_param, "Bad parameter shape: Null pointer");
        *argument = object_cast<migraphx_argument_t>(
            allocate<migraphx::argument>((shape->object), (buffer)));
    });
525
    return api_error_result;
Paul Fultz II's avatar
Paul Fultz II committed
526
527
528
529
530
}

extern "C" migraphx_status migraphx_argument_shape(const_migraphx_shape_t* out,
                                                   const_migraphx_argument_t argument)
{
531
    auto api_error_result = migraphx::try_([&] {
Paul Fultz II's avatar
Paul Fultz II committed
532
533
534
535
        if(argument == nullptr)
            MIGRAPHX_THROW(migraphx_status_bad_param, "Bad parameter argument: Null pointer");
        *out = object_cast<const_migraphx_shape_t>(&((argument->object).get_shape()));
    });
536
    return api_error_result;
Paul Fultz II's avatar
Paul Fultz II committed
537
538
539
540
}

extern "C" migraphx_status migraphx_argument_buffer(char** out, const_migraphx_argument_t argument)
{
541
    auto api_error_result = migraphx::try_([&] {
Paul Fultz II's avatar
Paul Fultz II committed
542
543
544
545
        if(argument == nullptr)
            MIGRAPHX_THROW(migraphx_status_bad_param, "Bad parameter argument: Null pointer");
        *out = (argument->object).data();
    });
546
    return api_error_result;
Paul Fultz II's avatar
Paul Fultz II committed
547
548
549
550
551
}

extern "C" migraphx_status
migraphx_argument_equal(bool* out, const_migraphx_argument_t argument, const_migraphx_argument_t x)
{
552
    auto api_error_result = migraphx::try_([&] {
Paul Fultz II's avatar
Paul Fultz II committed
553
554
555
556
557
558
        if(argument == nullptr)
            MIGRAPHX_THROW(migraphx_status_bad_param, "Bad parameter argument: Null pointer");
        if(x == nullptr)
            MIGRAPHX_THROW(migraphx_status_bad_param, "Bad parameter x: Null pointer");
        *out = migraphx::equal((argument->object), (x->object));
    });
559
    return api_error_result;
Paul Fultz II's avatar
Paul Fultz II committed
560
561
562
563
564
}

extern "C" migraphx_status
migraphx_argument_generate(migraphx_argument_t* out, const_migraphx_shape_t s, size_t seed)
{
565
    auto api_error_result = migraphx::try_([&] {
Paul Fultz II's avatar
Paul Fultz II committed
566
567
568
569
        if(s == nullptr)
            MIGRAPHX_THROW(migraphx_status_bad_param, "Bad parameter s: Null pointer");
        *out = allocate<migraphx_argument_t>(migraphx::generate_argument((s->object), (seed)));
    });
570
    return api_error_result;
Paul Fultz II's avatar
Paul Fultz II committed
571
572
573
574
}

extern "C" migraphx_status migraphx_target_destroy(migraphx_target_t target)
{
575
576
    auto api_error_result = migraphx::try_([&] { destroy((target)); });
    return api_error_result;
Paul Fultz II's avatar
Paul Fultz II committed
577
578
}

579
580
581
582
583
584
585
extern "C" migraphx_status migraphx_target_assign_to(migraphx_target_t output,
                                                     const_migraphx_target_t input)
{
    auto api_error_result = migraphx::try_([&] { *output = *input; });
    return api_error_result;
}

Paul Fultz II's avatar
Paul Fultz II committed
586
587
extern "C" migraphx_status migraphx_target_create(migraphx_target_t* target, const char* name)
{
588
    auto api_error_result = migraphx::try_([&] {
Paul Fultz II's avatar
Paul Fultz II committed
589
590
591
        *target = object_cast<migraphx_target_t>(
            allocate<migraphx::target>(migraphx::get_target((name))));
    });
592
    return api_error_result;
Paul Fultz II's avatar
Paul Fultz II committed
593
594
595
596
597
}

extern "C" migraphx_status migraphx_program_parameter_shapes_destroy(
    migraphx_program_parameter_shapes_t program_parameter_shapes)
{
598
599
    auto api_error_result = migraphx::try_([&] { destroy((program_parameter_shapes)); });
    return api_error_result;
Paul Fultz II's avatar
Paul Fultz II committed
600
601
}

602
603
604
605
606
607
608
609
extern "C" migraphx_status
migraphx_program_parameter_shapes_assign_to(migraphx_program_parameter_shapes_t output,
                                            const_migraphx_program_parameter_shapes_t input)
{
    auto api_error_result = migraphx::try_([&] { *output = *input; });
    return api_error_result;
}

Paul Fultz II's avatar
Paul Fultz II committed
610
611
612
613
extern "C" migraphx_status
migraphx_program_parameter_shapes_size(size_t* out,
                                       migraphx_program_parameter_shapes_t program_parameter_shapes)
{
614
    auto api_error_result = migraphx::try_([&] {
Paul Fultz II's avatar
Paul Fultz II committed
615
616
617
618
619
        if(program_parameter_shapes == nullptr)
            MIGRAPHX_THROW(migraphx_status_bad_param,
                           "Bad parameter program_parameter_shapes: Null pointer");
        *out = (program_parameter_shapes->object).size();
    });
620
    return api_error_result;
Paul Fultz II's avatar
Paul Fultz II committed
621
622
623
624
625
626
627
}

extern "C" migraphx_status
migraphx_program_parameter_shapes_get(const_migraphx_shape_t* out,
                                      migraphx_program_parameter_shapes_t program_parameter_shapes,
                                      const char* name)
{
628
    auto api_error_result = migraphx::try_([&] {
Paul Fultz II's avatar
Paul Fultz II committed
629
630
631
632
633
634
        if(program_parameter_shapes == nullptr)
            MIGRAPHX_THROW(migraphx_status_bad_param,
                           "Bad parameter program_parameter_shapes: Null pointer");
        *out =
            object_cast<const_migraphx_shape_t>(&((program_parameter_shapes->object).at((name))));
    });
635
    return api_error_result;
Paul Fultz II's avatar
Paul Fultz II committed
636
637
638
639
640
}

extern "C" migraphx_status migraphx_program_parameter_shapes_names(
    const char** out, migraphx_program_parameter_shapes_t program_parameter_shapes)
{
641
    auto api_error_result = migraphx::try_([&] {
Paul Fultz II's avatar
Paul Fultz II committed
642
643
644
645
646
647
648
649
        if(out == nullptr)
            MIGRAPHX_THROW(migraphx_status_bad_param, "Bad parameter out: Null pointer");
        if(program_parameter_shapes == nullptr)
            MIGRAPHX_THROW(migraphx_status_bad_param,
                           "Bad parameter program_parameter_shapes: Null pointer");
        auto&& api_result = migraphx::get_names((program_parameter_shapes->object));
        std::copy(api_result.begin(), api_result.end(), out);
    });
650
    return api_error_result;
Paul Fultz II's avatar
Paul Fultz II committed
651
652
653
654
655
}

extern "C" migraphx_status
migraphx_program_parameters_destroy(migraphx_program_parameters_t program_parameters)
{
656
657
    auto api_error_result = migraphx::try_([&] { destroy((program_parameters)); });
    return api_error_result;
Paul Fultz II's avatar
Paul Fultz II committed
658
659
}

660
661
662
663
664
665
666
667
extern "C" migraphx_status
migraphx_program_parameters_assign_to(migraphx_program_parameters_t output,
                                      const_migraphx_program_parameters_t input)
{
    auto api_error_result = migraphx::try_([&] { *output = *input; });
    return api_error_result;
}

Paul Fultz II's avatar
Paul Fultz II committed
668
669
670
extern "C" migraphx_status
migraphx_program_parameters_create(migraphx_program_parameters_t* program_parameters)
{
671
    auto api_error_result = migraphx::try_([&] {
Paul Fultz II's avatar
Paul Fultz II committed
672
673
674
        *program_parameters = object_cast<migraphx_program_parameters_t>(
            allocate<std::unordered_map<std::string, migraphx::argument>>());
    });
675
    return api_error_result;
Paul Fultz II's avatar
Paul Fultz II committed
676
677
678
679
680
681
682
}

extern "C" migraphx_status
migraphx_program_parameters_add(migraphx_program_parameters_t program_parameters,
                                const char* name,
                                const_migraphx_argument_t argument)
{
683
    auto api_error_result = migraphx::try_([&] {
Paul Fultz II's avatar
Paul Fultz II committed
684
685
686
687
688
689
690
        if(program_parameters == nullptr)
            MIGRAPHX_THROW(migraphx_status_bad_param,
                           "Bad parameter program_parameters: Null pointer");
        if(argument == nullptr)
            MIGRAPHX_THROW(migraphx_status_bad_param, "Bad parameter argument: Null pointer");
        (program_parameters->object)[(name)] = (argument->object);
    });
691
    return api_error_result;
Paul Fultz II's avatar
Paul Fultz II committed
692
693
694
695
}

extern "C" migraphx_status migraphx_arguments_destroy(migraphx_arguments_t arguments)
{
696
697
    auto api_error_result = migraphx::try_([&] { destroy((arguments)); });
    return api_error_result;
Paul Fultz II's avatar
Paul Fultz II committed
698
699
}

700
701
702
703
704
705
706
extern "C" migraphx_status migraphx_arguments_assign_to(migraphx_arguments_t output,
                                                        const_migraphx_arguments_t input)
{
    auto api_error_result = migraphx::try_([&] { *output = *input; });
    return api_error_result;
}

Paul Fultz II's avatar
Paul Fultz II committed
707
708
extern "C" migraphx_status migraphx_arguments_size(size_t* out, migraphx_arguments_t arguments)
{
709
    auto api_error_result = migraphx::try_([&] {
Paul Fultz II's avatar
Paul Fultz II committed
710
711
712
713
        if(arguments == nullptr)
            MIGRAPHX_THROW(migraphx_status_bad_param, "Bad parameter arguments: Null pointer");
        *out = (arguments->object).size();
    });
714
    return api_error_result;
Paul Fultz II's avatar
Paul Fultz II committed
715
716
717
718
719
}

extern "C" migraphx_status
migraphx_arguments_get(const_migraphx_argument_t* out, migraphx_arguments_t arguments, size_t idx)
{
720
    auto api_error_result = migraphx::try_([&] {
Paul Fultz II's avatar
Paul Fultz II committed
721
722
723
724
        if(arguments == nullptr)
            MIGRAPHX_THROW(migraphx_status_bad_param, "Bad parameter arguments: Null pointer");
        *out = object_cast<const_migraphx_argument_t>(&((arguments->object).at((idx))));
    });
725
    return api_error_result;
Paul Fultz II's avatar
Paul Fultz II committed
726
727
728
729
}

extern "C" migraphx_status migraphx_shapes_destroy(migraphx_shapes_t shapes)
{
730
731
    auto api_error_result = migraphx::try_([&] { destroy((shapes)); });
    return api_error_result;
Paul Fultz II's avatar
Paul Fultz II committed
732
733
}

734
735
736
737
738
739
740
extern "C" migraphx_status migraphx_shapes_assign_to(migraphx_shapes_t output,
                                                     const_migraphx_shapes_t input)
{
    auto api_error_result = migraphx::try_([&] { *output = *input; });
    return api_error_result;
}

Paul Fultz II's avatar
Paul Fultz II committed
741
742
extern "C" migraphx_status migraphx_shapes_size(size_t* out, migraphx_shapes_t shapes)
{
743
    auto api_error_result = migraphx::try_([&] {
Paul Fultz II's avatar
Paul Fultz II committed
744
745
746
747
        if(shapes == nullptr)
            MIGRAPHX_THROW(migraphx_status_bad_param, "Bad parameter shapes: Null pointer");
        *out = (shapes->object).size();
    });
748
    return api_error_result;
Paul Fultz II's avatar
Paul Fultz II committed
749
750
751
752
753
}

extern "C" migraphx_status
migraphx_shapes_get(const_migraphx_shape_t* out, migraphx_shapes_t shapes, size_t idx)
{
754
    auto api_error_result = migraphx::try_([&] {
Paul Fultz II's avatar
Paul Fultz II committed
755
756
757
758
        if(shapes == nullptr)
            MIGRAPHX_THROW(migraphx_status_bad_param, "Bad parameter shapes: Null pointer");
        *out = object_cast<const_migraphx_shape_t>(&((shapes->object).at((idx))));
    });
759
    return api_error_result;
Paul Fultz II's avatar
Paul Fultz II committed
760
761
}

Shucai Xiao's avatar
Shucai Xiao committed
762
763
extern "C" migraphx_status migraphx_module_print(const_migraphx_module_t module)
{
764
    auto api_error_result = migraphx::try_([&] {
Shucai Xiao's avatar
Shucai Xiao committed
765
766
767
768
        if(module == nullptr)
            MIGRAPHX_THROW(migraphx_status_bad_param, "Bad parameter module: Null pointer");
        migraphx::print_module((module->object));
    });
769
    return api_error_result;
Shucai Xiao's avatar
Shucai Xiao committed
770
771
}

Paul Fultz II's avatar
Paul Fultz II committed
772
773
extern "C" migraphx_status migraphx_program_destroy(migraphx_program_t program)
{
774
775
    auto api_error_result = migraphx::try_([&] { destroy((program)); });
    return api_error_result;
Paul Fultz II's avatar
Paul Fultz II committed
776
777
}

778
779
780
781
782
783
784
extern "C" migraphx_status migraphx_program_assign_to(migraphx_program_t output,
                                                      const_migraphx_program_t input)
{
    auto api_error_result = migraphx::try_([&] { *output = *input; });
    return api_error_result;
}

Shucai Xiao's avatar
Shucai Xiao committed
785
786
787
extern "C" migraphx_status migraphx_program_get_main_module(migraphx_module_t* out,
                                                            migraphx_program_t program)
{
788
    auto api_error_result = migraphx::try_([&] {
Shucai Xiao's avatar
Shucai Xiao committed
789
790
791
792
        if(program == nullptr)
            MIGRAPHX_THROW(migraphx_status_bad_param, "Bad parameter program: Null pointer");
        *out = object_cast<migraphx_module_t>((program->object).get_main_module());
    });
793
    return api_error_result;
Shucai Xiao's avatar
Shucai Xiao committed
794
795
}

Paul Fultz II's avatar
Paul Fultz II committed
796
797
extern "C" migraphx_status migraphx_program_compile(migraphx_program_t program,
                                                    migraphx_target_t target,
798
                                                    migraphx_compile_options_t options)
Paul Fultz II's avatar
Paul Fultz II committed
799
{
800
    auto api_error_result = migraphx::try_([&] {
Paul Fultz II's avatar
Paul Fultz II committed
801
802
803
804
        if(program == nullptr)
            MIGRAPHX_THROW(migraphx_status_bad_param, "Bad parameter program: Null pointer");
        if(target == nullptr)
            MIGRAPHX_THROW(migraphx_status_bad_param, "Bad parameter target: Null pointer");
805
806
807
        if(options == nullptr)
            MIGRAPHX_THROW(migraphx_status_bad_param, "Bad parameter options: Null pointer");
        (program->object).compile((target->object), (options->object));
Paul Fultz II's avatar
Paul Fultz II committed
808
    });
809
    return api_error_result;
Paul Fultz II's avatar
Paul Fultz II committed
810
811
812
813
814
815
}

extern "C" migraphx_status
migraphx_program_get_parameter_shapes(migraphx_program_parameter_shapes_t* out,
                                      migraphx_program_t program)
{
816
    auto api_error_result = migraphx::try_([&] {
Paul Fultz II's avatar
Paul Fultz II committed
817
818
819
820
821
        if(program == nullptr)
            MIGRAPHX_THROW(migraphx_status_bad_param, "Bad parameter program: Null pointer");
        *out =
            allocate<migraphx_program_parameter_shapes_t>((program->object).get_parameter_shapes());
    });
822
    return api_error_result;
Paul Fultz II's avatar
Paul Fultz II committed
823
824
825
826
827
}

extern "C" migraphx_status migraphx_program_get_output_shapes(migraphx_shapes_t* out,
                                                              migraphx_program_t program)
{
828
    auto api_error_result = migraphx::try_([&] {
Paul Fultz II's avatar
Paul Fultz II committed
829
830
831
832
        if(program == nullptr)
            MIGRAPHX_THROW(migraphx_status_bad_param, "Bad parameter program: Null pointer");
        *out = allocate<migraphx_shapes_t>(migraphx::get_output_shapes((program->object)));
    });
833
    return api_error_result;
Paul Fultz II's avatar
Paul Fultz II committed
834
835
836
837
}

extern "C" migraphx_status migraphx_program_print(const_migraphx_program_t program)
{
838
    auto api_error_result = migraphx::try_([&] {
Paul Fultz II's avatar
Paul Fultz II committed
839
840
        if(program == nullptr)
            MIGRAPHX_THROW(migraphx_status_bad_param, "Bad parameter program: Null pointer");
Shucai Xiao's avatar
Shucai Xiao committed
841
        migraphx::print_program((program->object));
Paul Fultz II's avatar
Paul Fultz II committed
842
    });
843
    return api_error_result;
Paul Fultz II's avatar
Paul Fultz II committed
844
845
}

846
847
extern "C" migraphx_status migraphx_program_sort(migraphx_program_t program)
{
848
    auto api_error_result = migraphx::try_([&] {
849
850
851
852
        if(program == nullptr)
            MIGRAPHX_THROW(migraphx_status_bad_param, "Bad parameter program: Null pointer");
        (program->object).sort();
    });
853
    return api_error_result;
854
855
}

Paul Fultz II's avatar
Paul Fultz II committed
856
857
858
859
extern "C" migraphx_status migraphx_program_run(migraphx_arguments_t* out,
                                                migraphx_program_t program,
                                                migraphx_program_parameters_t params)
{
860
    auto api_error_result = migraphx::try_([&] {
Paul Fultz II's avatar
Paul Fultz II committed
861
862
863
864
865
866
        if(program == nullptr)
            MIGRAPHX_THROW(migraphx_status_bad_param, "Bad parameter program: Null pointer");
        if(params == nullptr)
            MIGRAPHX_THROW(migraphx_status_bad_param, "Bad parameter params: Null pointer");
        *out = allocate<migraphx_arguments_t>(migraphx::run((program->object), (params->object)));
    });
867
    return api_error_result;
Paul Fultz II's avatar
Paul Fultz II committed
868
869
870
871
872
}

extern "C" migraphx_status
migraphx_program_equal(bool* out, const_migraphx_program_t program, const_migraphx_program_t x)
{
873
    auto api_error_result = migraphx::try_([&] {
Paul Fultz II's avatar
Paul Fultz II committed
874
875
876
877
878
879
        if(program == nullptr)
            MIGRAPHX_THROW(migraphx_status_bad_param, "Bad parameter program: Null pointer");
        if(x == nullptr)
            MIGRAPHX_THROW(migraphx_status_bad_param, "Bad parameter x: Null pointer");
        *out = migraphx::equal((program->object), (x->object));
    });
880
    return api_error_result;
Paul Fultz II's avatar
Paul Fultz II committed
881
882
}

883
884
extern "C" migraphx_status migraphx_operation_destroy(migraphx_operation_t operation)
{
885
886
    auto api_error_result = migraphx::try_([&] { destroy((operation)); });
    return api_error_result;
887
888
}

889
890
891
892
893
894
895
extern "C" migraphx_status migraphx_operation_assign_to(migraphx_operation_t output,
                                                        const_migraphx_operation_t input)
{
    auto api_error_result = migraphx::try_([&] { *output = *input; });
    return api_error_result;
}

896
897
898
899
extern "C" migraphx_status migraphx_operation_create(migraphx_operation_t* operation,
                                                     const char* name,
                                                     const char* attributes,
                                                     ...)
900
{
901
902
903
    va_list vlist;
    va_start(vlist, attributes);
    auto api_error_result = migraphx::try_([&] {
904
        *operation = object_cast<migraphx_operation_t>(
905
            allocate<migraphx::operation>(migraphx::create_op((name), (attributes), (vlist))));
906
    });
907
908
    va_end(vlist);
    return api_error_result;
909
910
911
}

extern "C" migraphx_status
Shucai Xiao's avatar
Shucai Xiao committed
912
migraphx_operation_name(char* out, int out_size, migraphx_operation_t operation)
913
{
914
    auto api_error_result = migraphx::try_([&] {
915
916
917
918
919
        if(out == nullptr)
            MIGRAPHX_THROW(migraphx_status_bad_param, "Bad parameter out: Null pointer");
        if(operation == nullptr)
            MIGRAPHX_THROW(migraphx_status_bad_param, "Bad parameter operation: Null pointer");
        auto&& api_result = (operation->object).name();
Shucai Xiao's avatar
Shucai Xiao committed
920
921
922
        auto* it          = std::copy_n(
            api_result.begin(), std::min(static_cast<int>(api_result.size()), out_size - 1), out);
        *it = '\0';
923
    });
924
    return api_error_result;
925
926
}

927
extern "C" migraphx_status
928
migraphx_load(migraphx_program_t* out, const char* name, migraphx_file_options_t options)
929
{
930
    auto api_error_result = migraphx::try_([&] {
931
932
933
        if(options == nullptr)
            MIGRAPHX_THROW(migraphx_status_bad_param, "Bad parameter options: Null pointer");
        *out = allocate<migraphx_program_t>(migraphx::load((name), (options->object)));
934
    });
935
    return api_error_result;
936
937
938
}

extern "C" migraphx_status
939
migraphx_save(migraphx_program_t p, const char* name, migraphx_file_options_t options)
940
{
941
    auto api_error_result = migraphx::try_([&] {
942
943
        if(p == nullptr)
            MIGRAPHX_THROW(migraphx_status_bad_param, "Bad parameter p: Null pointer");
944
945
946
        if(options == nullptr)
            MIGRAPHX_THROW(migraphx_status_bad_param, "Bad parameter options: Null pointer");
        migraphx::save((p->object), (name), (options->object));
947
    });
948
    return api_error_result;
949
950
}

951
952
extern "C" migraphx_status migraphx_onnx_options_destroy(migraphx_onnx_options_t onnx_options)
{
953
954
    auto api_error_result = migraphx::try_([&] { destroy((onnx_options)); });
    return api_error_result;
955
956
}

957
958
959
960
961
962
963
extern "C" migraphx_status migraphx_onnx_options_assign_to(migraphx_onnx_options_t output,
                                                           const_migraphx_onnx_options_t input)
{
    auto api_error_result = migraphx::try_([&] { *output = *input; });
    return api_error_result;
}

964
965
extern "C" migraphx_status migraphx_onnx_options_create(migraphx_onnx_options_t* onnx_options)
{
966
    auto api_error_result = migraphx::try_([&] {
967
968
        *onnx_options = object_cast<migraphx_onnx_options_t>(allocate<migraphx::onnx_options>());
    });
969
    return api_error_result;
970
971
}

972
extern "C" migraphx_status migraphx_onnx_options_set_input_parameter_shape(
973
    migraphx_onnx_options_t onnx_options, const char* name, int* dims, size_t dims_size)
974
{
975
    auto api_error_result = migraphx::try_([&] {
976
977
        if(onnx_options == nullptr)
            MIGRAPHX_THROW(migraphx_status_bad_param, "Bad parameter onnx_options: Null pointer");
978
979
980
        if(dims == nullptr and dims_size != 0)
            MIGRAPHX_THROW(migraphx_status_bad_param, "Bad parameter dims: Null pointer");
        migraphx::set_input_parameter_shape(
Shucai Xiao's avatar
Shucai Xiao committed
981
            (onnx_options->object), (name), (std::vector<int>(dims, dims + dims_size)));
982
    });
983
    return api_error_result;
984
985
986
987
988
}

extern "C" migraphx_status
migraphx_onnx_options_set_default_dim_value(migraphx_onnx_options_t onnx_options, size_t value)
{
989
    auto api_error_result = migraphx::try_([&] {
990
991
992
993
        if(onnx_options == nullptr)
            MIGRAPHX_THROW(migraphx_status_bad_param, "Bad parameter onnx_options: Null pointer");
        migraphx::set_default_dim_value((onnx_options->object), (value));
    });
994
    return api_error_result;
995
996
}

997
998
999
1000
extern "C" migraphx_status
migraphx_onnx_options_set_default_loop_iterations(migraphx_onnx_options_t onnx_options,
                                                  int64_t value)
{
1001
    auto api_error_result = migraphx::try_([&] {
1002
1003
1004
1005
        if(onnx_options == nullptr)
            MIGRAPHX_THROW(migraphx_status_bad_param, "Bad parameter onnx_options: Null pointer");
        migraphx::set_default_loop_iterations((onnx_options->object), (value));
    });
1006
    return api_error_result;
1007
1008
}

1009
1010
extern "C" migraphx_status migraphx_file_options_destroy(migraphx_file_options_t file_options)
{
1011
1012
    auto api_error_result = migraphx::try_([&] { destroy((file_options)); });
    return api_error_result;
1013
1014
}

1015
1016
1017
1018
1019
1020
1021
extern "C" migraphx_status migraphx_file_options_assign_to(migraphx_file_options_t output,
                                                           const_migraphx_file_options_t input)
{
    auto api_error_result = migraphx::try_([&] { *output = *input; });
    return api_error_result;
}

1022
1023
extern "C" migraphx_status migraphx_file_options_create(migraphx_file_options_t* file_options)
{
1024
    auto api_error_result = migraphx::try_([&] {
1025
1026
        *file_options = object_cast<migraphx_file_options_t>(allocate<migraphx::file_options>());
    });
1027
    return api_error_result;
1028
1029
1030
1031
1032
}

extern "C" migraphx_status
migraphx_file_options_set_file_format(migraphx_file_options_t file_options, const char* format)
{
1033
    auto api_error_result = migraphx::try_([&] {
1034
1035
1036
1037
        if(file_options == nullptr)
            MIGRAPHX_THROW(migraphx_status_bad_param, "Bad parameter file_options: Null pointer");
        migraphx::set_file_format((file_options->object), (format));
    });
1038
    return api_error_result;
1039
1040
}

Shucai Xiao's avatar
Shucai Xiao committed
1041
extern "C" migraphx_status
1042
1043
migraphx_compile_options_destroy(migraphx_compile_options_t compile_options)
{
1044
1045
    auto api_error_result = migraphx::try_([&] { destroy((compile_options)); });
    return api_error_result;
1046
1047
}

1048
1049
1050
1051
1052
1053
1054
1055
extern "C" migraphx_status
migraphx_compile_options_assign_to(migraphx_compile_options_t output,
                                   const_migraphx_compile_options_t input)
{
    auto api_error_result = migraphx::try_([&] { *output = *input; });
    return api_error_result;
}

1056
1057
extern "C" migraphx_status
migraphx_compile_options_create(migraphx_compile_options_t* compile_options)
Shucai Xiao's avatar
Shucai Xiao committed
1058
{
1059
    auto api_error_result = migraphx::try_([&] {
1060
1061
1062
        *compile_options =
            object_cast<migraphx_compile_options_t>(allocate<migraphx::compile_options>());
    });
1063
    return api_error_result;
1064
1065
1066
1067
1068
}

extern "C" migraphx_status
migraphx_compile_options_set_offload_copy(migraphx_compile_options_t compile_options, bool value)
{
1069
    auto api_error_result = migraphx::try_([&] {
1070
1071
1072
1073
1074
        if(compile_options == nullptr)
            MIGRAPHX_THROW(migraphx_status_bad_param,
                           "Bad parameter compile_options: Null pointer");
        migraphx::set_offload_copy((compile_options->object), (value));
    });
1075
    return api_error_result;
1076
1077
1078
1079
1080
}

extern "C" migraphx_status
migraphx_compile_options_set_fast_math(migraphx_compile_options_t compile_options, bool value)
{
1081
    auto api_error_result = migraphx::try_([&] {
1082
1083
1084
1085
        if(compile_options == nullptr)
            MIGRAPHX_THROW(migraphx_status_bad_param,
                           "Bad parameter compile_options: Null pointer");
        migraphx::set_fast_math((compile_options->object), (value));
Shucai Xiao's avatar
Shucai Xiao committed
1086
    });
1087
    return api_error_result;
Shucai Xiao's avatar
Shucai Xiao committed
1088
1089
}

Paul Fultz II's avatar
Paul Fultz II committed
1090
extern "C" migraphx_status
1091
migraphx_parse_onnx(migraphx_program_t* out, const char* name, migraphx_onnx_options_t options)
Paul Fultz II's avatar
Paul Fultz II committed
1092
{
1093
    auto api_error_result = migraphx::try_([&] {
1094
1095
1096
        if(options == nullptr)
            MIGRAPHX_THROW(migraphx_status_bad_param, "Bad parameter options: Null pointer");
        *out = allocate<migraphx_program_t>(migraphx::parse_onnx((name), (options->object)));
Paul Fultz II's avatar
Paul Fultz II committed
1097
    });
1098
    return api_error_result;
Paul Fultz II's avatar
Paul Fultz II committed
1099
1100
1101
1102
1103
}

extern "C" migraphx_status migraphx_parse_onnx_buffer(migraphx_program_t* out,
                                                      const void* data,
                                                      size_t size,
1104
                                                      migraphx_onnx_options_t options)
Paul Fultz II's avatar
Paul Fultz II committed
1105
{
1106
    auto api_error_result = migraphx::try_([&] {
1107
1108
1109
1110
        if(options == nullptr)
            MIGRAPHX_THROW(migraphx_status_bad_param, "Bad parameter options: Null pointer");
        *out = allocate<migraphx_program_t>(
            migraphx::parse_onnx_buffer((data), (size), (options->object)));
Paul Fultz II's avatar
Paul Fultz II committed
1111
    });
1112
    return api_error_result;
Paul Fultz II's avatar
Paul Fultz II committed
1113
}
Shucai Xiao's avatar
Shucai Xiao committed
1114

kahmed10's avatar
kahmed10 committed
1115
1116
extern "C" migraphx_status migraphx_tf_options_destroy(migraphx_tf_options_t tf_options)
{
1117
1118
    auto api_error_result = migraphx::try_([&] { destroy((tf_options)); });
    return api_error_result;
kahmed10's avatar
kahmed10 committed
1119
1120
}

1121
1122
1123
1124
1125
1126
1127
extern "C" migraphx_status migraphx_tf_options_assign_to(migraphx_tf_options_t output,
                                                         const_migraphx_tf_options_t input)
{
    auto api_error_result = migraphx::try_([&] { *output = *input; });
    return api_error_result;
}

kahmed10's avatar
kahmed10 committed
1128
1129
extern "C" migraphx_status migraphx_tf_options_create(migraphx_tf_options_t* tf_options)
{
1130
    auto api_error_result = migraphx::try_([&] {
kahmed10's avatar
kahmed10 committed
1131
1132
        *tf_options = object_cast<migraphx_tf_options_t>(allocate<migraphx::tf_options>());
    });
1133
    return api_error_result;
kahmed10's avatar
kahmed10 committed
1134
1135
1136
1137
1138
}

extern "C" migraphx_status migraphx_tf_options_set_nhwc(migraphx_tf_options_t tf_options,
                                                        bool is_nhwc)
{
1139
    auto api_error_result = migraphx::try_([&] {
kahmed10's avatar
kahmed10 committed
1140
1141
1142
1143
        if(tf_options == nullptr)
            MIGRAPHX_THROW(migraphx_status_bad_param, "Bad parameter tf_options: Null pointer");
        migraphx::set_nhwc((tf_options->object), (is_nhwc));
    });
1144
    return api_error_result;
kahmed10's avatar
kahmed10 committed
1145
1146
1147
}

extern "C" migraphx_status migraphx_tf_options_set_input_parameter_shape(
Shucai Xiao's avatar
Shucai Xiao committed
1148
    migraphx_tf_options_t tf_options, const char* name, int* dims, int dims_size)
kahmed10's avatar
kahmed10 committed
1149
{
1150
    auto api_error_result = migraphx::try_([&] {
kahmed10's avatar
kahmed10 committed
1151
1152
1153
1154
1155
        if(tf_options == nullptr)
            MIGRAPHX_THROW(migraphx_status_bad_param, "Bad parameter tf_options: Null pointer");
        if(dims == nullptr and dims_size != 0)
            MIGRAPHX_THROW(migraphx_status_bad_param, "Bad parameter dims: Null pointer");
        migraphx::set_input_parameter_shape(
Shucai Xiao's avatar
Shucai Xiao committed
1156
            (tf_options->object), (name), (std::vector<int>(dims, dims + dims_size)));
kahmed10's avatar
kahmed10 committed
1157
    });
1158
    return api_error_result;
kahmed10's avatar
kahmed10 committed
1159
1160
1161
1162
1163
}

extern "C" migraphx_status
migraphx_tf_options_set_default_dim_value(migraphx_tf_options_t tf_options, size_t value)
{
1164
    auto api_error_result = migraphx::try_([&] {
kahmed10's avatar
kahmed10 committed
1165
1166
1167
1168
        if(tf_options == nullptr)
            MIGRAPHX_THROW(migraphx_status_bad_param, "Bad parameter tf_options: Null pointer");
        migraphx::set_default_dim_value((tf_options->object), (value));
    });
1169
    return api_error_result;
kahmed10's avatar
kahmed10 committed
1170
1171
1172
1173
}

extern "C" migraphx_status migraphx_tf_options_set_output_names(migraphx_tf_options_t tf_options,
                                                                const char** names,
Shucai Xiao's avatar
Shucai Xiao committed
1174
                                                                int names_size)
kahmed10's avatar
kahmed10 committed
1175
{
1176
    auto api_error_result = migraphx::try_([&] {
kahmed10's avatar
kahmed10 committed
1177
1178
1179
1180
1181
1182
1183
        if(tf_options == nullptr)
            MIGRAPHX_THROW(migraphx_status_bad_param, "Bad parameter tf_options: Null pointer");
        if(names == nullptr and names_size != 0)
            MIGRAPHX_THROW(migraphx_status_bad_param, "Bad parameter names: Null pointer");
        migraphx::set_output_names((tf_options->object),
                                   (std::vector<const char*>(names, names + names_size)));
    });
1184
    return api_error_result;
kahmed10's avatar
kahmed10 committed
1185
1186
1187
1188
1189
}

extern "C" migraphx_status
migraphx_parse_tf(migraphx_program_t* out, const char* name, migraphx_tf_options_t options)
{
1190
    auto api_error_result = migraphx::try_([&] {
kahmed10's avatar
kahmed10 committed
1191
1192
1193
1194
        if(options == nullptr)
            MIGRAPHX_THROW(migraphx_status_bad_param, "Bad parameter options: Null pointer");
        *out = allocate<migraphx_program_t>(migraphx::parse_tf((name), (options->object)));
    });
1195
    return api_error_result;
kahmed10's avatar
kahmed10 committed
1196
1197
}

Shucai Xiao's avatar
Shucai Xiao committed
1198
1199
1200
extern "C" migraphx_status
migraphx_quantize_op_names_destroy(migraphx_quantize_op_names_t quantize_op_names)
{
1201
1202
    auto api_error_result = migraphx::try_([&] { destroy((quantize_op_names)); });
    return api_error_result;
Shucai Xiao's avatar
Shucai Xiao committed
1203
1204
}

1205
1206
1207
1208
1209
1210
1211
1212
extern "C" migraphx_status
migraphx_quantize_op_names_assign_to(migraphx_quantize_op_names_t output,
                                     const_migraphx_quantize_op_names_t input)
{
    auto api_error_result = migraphx::try_([&] { *output = *input; });
    return api_error_result;
}

Shucai Xiao's avatar
Shucai Xiao committed
1213
1214
1215
extern "C" migraphx_status
migraphx_quantize_op_names_create(migraphx_quantize_op_names_t* quantize_op_names)
{
1216
    auto api_error_result = migraphx::try_([&] {
Shucai Xiao's avatar
Shucai Xiao committed
1217
1218
1219
        *quantize_op_names =
            object_cast<migraphx_quantize_op_names_t>(allocate<std::vector<std::string>>());
    });
1220
    return api_error_result;
Shucai Xiao's avatar
Shucai Xiao committed
1221
1222
1223
1224
1225
}

extern "C" migraphx_status
migraphx_quantize_op_names_add(migraphx_quantize_op_names_t quantize_op_names, const char* name)
{
1226
    auto api_error_result = migraphx::try_([&] {
Shucai Xiao's avatar
Shucai Xiao committed
1227
1228
1229
1230
1231
        if(quantize_op_names == nullptr)
            MIGRAPHX_THROW(migraphx_status_bad_param,
                           "Bad parameter quantize_op_names: Null pointer");
        (quantize_op_names->object).push_back((name));
    });
1232
    return api_error_result;
Shucai Xiao's avatar
Shucai Xiao committed
1233
1234
1235
1236
1237
}

extern "C" migraphx_status migraphx_quantize_fp16_with_op_names(migraphx_program_t prog,
                                                                migraphx_quantize_op_names_t name)
{
1238
    auto api_error_result = migraphx::try_([&] {
Shucai Xiao's avatar
Shucai Xiao committed
1239
1240
1241
1242
1243
1244
        if(prog == nullptr)
            MIGRAPHX_THROW(migraphx_status_bad_param, "Bad parameter prog: Null pointer");
        if(name == nullptr)
            MIGRAPHX_THROW(migraphx_status_bad_param, "Bad parameter name: Null pointer");
        migraphx::quantize_fp16_with_op_names((prog->object), (name->object));
    });
1245
    return api_error_result;
Shucai Xiao's avatar
Shucai Xiao committed
1246
1247
1248
1249
}

extern "C" migraphx_status migraphx_quantize_fp16(migraphx_program_t prog)
{
1250
    auto api_error_result = migraphx::try_([&] {
Shucai Xiao's avatar
Shucai Xiao committed
1251
1252
1253
1254
        if(prog == nullptr)
            MIGRAPHX_THROW(migraphx_status_bad_param, "Bad parameter prog: Null pointer");
        migraphx::quantize_fp16((prog->object));
    });
1255
    return api_error_result;
Shucai Xiao's avatar
Shucai Xiao committed
1256
1257
1258
1259
1260
}

extern "C" migraphx_status
migraphx_quantize_int8_options_destroy(migraphx_quantize_int8_options_t quantize_int8_options)
{
1261
1262
    auto api_error_result = migraphx::try_([&] { destroy((quantize_int8_options)); });
    return api_error_result;
Shucai Xiao's avatar
Shucai Xiao committed
1263
1264
}

1265
1266
1267
1268
1269
1270
1271
1272
extern "C" migraphx_status
migraphx_quantize_int8_options_assign_to(migraphx_quantize_int8_options_t output,
                                         const_migraphx_quantize_int8_options_t input)
{
    auto api_error_result = migraphx::try_([&] { *output = *input; });
    return api_error_result;
}

Shucai Xiao's avatar
Shucai Xiao committed
1273
1274
1275
extern "C" migraphx_status
migraphx_quantize_int8_options_create(migraphx_quantize_int8_options_t* quantize_int8_options)
{
1276
    auto api_error_result = migraphx::try_([&] {
Shucai Xiao's avatar
Shucai Xiao committed
1277
1278
1279
        *quantize_int8_options = object_cast<migraphx_quantize_int8_options_t>(
            allocate<migraphx::quantize_int8_options>());
    });
1280
    return api_error_result;
Shucai Xiao's avatar
Shucai Xiao committed
1281
1282
1283
1284
1285
1286
}

extern "C" migraphx_status
migraphx_quantize_int8_options_add_op_name(migraphx_quantize_int8_options_t quantize_int8_options,
                                           const char* name)
{
1287
    auto api_error_result = migraphx::try_([&] {
Shucai Xiao's avatar
Shucai Xiao committed
1288
1289
1290
1291
1292
        if(quantize_int8_options == nullptr)
            MIGRAPHX_THROW(migraphx_status_bad_param,
                           "Bad parameter quantize_int8_options: Null pointer");
        migraphx::add_op_name((quantize_int8_options->object), (name));
    });
1293
    return api_error_result;
Shucai Xiao's avatar
Shucai Xiao committed
1294
1295
1296
1297
1298
}

extern "C" migraphx_status migraphx_quantize_int8_options_add_calibration_data(
    migraphx_quantize_int8_options_t quantize_int8_options, migraphx_program_parameters_t data)
{
1299
    auto api_error_result = migraphx::try_([&] {
Shucai Xiao's avatar
Shucai Xiao committed
1300
1301
1302
1303
1304
1305
1306
        if(quantize_int8_options == nullptr)
            MIGRAPHX_THROW(migraphx_status_bad_param,
                           "Bad parameter quantize_int8_options: Null pointer");
        if(data == nullptr)
            MIGRAPHX_THROW(migraphx_status_bad_param, "Bad parameter data: Null pointer");
        migraphx::add_calibration_data((quantize_int8_options->object), (data->object));
    });
1307
    return api_error_result;
Shucai Xiao's avatar
Shucai Xiao committed
1308
1309
1310
1311
1312
1313
}

extern "C" migraphx_status migraphx_quantize_int8(migraphx_program_t prog,
                                                  migraphx_target_t target,
                                                  migraphx_quantize_int8_options_t options)
{
1314
    auto api_error_result = migraphx::try_([&] {
Shucai Xiao's avatar
Shucai Xiao committed
1315
1316
1317
1318
1319
1320
1321
1322
        if(prog == nullptr)
            MIGRAPHX_THROW(migraphx_status_bad_param, "Bad parameter prog: Null pointer");
        if(target == nullptr)
            MIGRAPHX_THROW(migraphx_status_bad_param, "Bad parameter target: Null pointer");
        if(options == nullptr)
            MIGRAPHX_THROW(migraphx_status_bad_param, "Bad parameter options: Null pointer");
        migraphx::quantize_int8_wrap((prog->object), (target->object), (options->object));
    });
1323
    return api_error_result;
Shucai Xiao's avatar
Shucai Xiao committed
1324
}