"test/git@developer.sourcefind.cn:gaoqiong/migraphx.git" did not exist on "e5242676aa7f1e246a3c71f10e21f9bd85feab3d"
api.cpp 84.8 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
/*
 * The MIT License (MIT)
 *
 * Copyright (c) 2015-2022 Advanced Micro Devices, Inc. All rights reserved.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */
24
#include <migraphx/execution_environment.hpp>
Paul Fultz II's avatar
Paul Fultz II committed
25
26
#include <migraphx/migraphx.h>
#include <migraphx/rank.hpp>
27
#include <migraphx/ranges.hpp>
Paul Fultz II's avatar
Paul Fultz II committed
28
29
30
#include <migraphx/shape.hpp>
#include <migraphx/program.hpp>
#include <migraphx/onnx.hpp>
kahmed10's avatar
kahmed10 committed
31
#include <migraphx/tf.hpp>
32
#include <migraphx/instruction_ref.hpp>
33
#include <migraphx/register_target.hpp>
Paul Fultz II's avatar
Paul Fultz II committed
34
#include <migraphx/generate.hpp>
Shucai Xiao's avatar
Shucai Xiao committed
35
#include <migraphx/quantization.hpp>
36
#include <migraphx/load_save.hpp>
37
#include <migraphx/make_op.hpp>
38
#include <migraphx/register_op.hpp>
39
40
#include <migraphx/json.hpp>
#include <migraphx/convert_to_json.hpp>
41
#include <array>
42
#include <algorithm>
43
#include <cstdarg>
44

Paul Fultz II's avatar
Paul Fultz II committed
45
46
namespace migraphx {

47
#ifdef MIGRAPHX_BUILD_TESTING
48
49
static thread_local bool disable_exception_catch = false; // NOLINT

50
extern "C" MIGRAPHX_C_EXPORT void migraphx_test_private_disable_exception_catch(bool b)
51
52
53
{
    disable_exception_catch = b;
}
54
#endif
55

Paul Fultz II's avatar
Paul Fultz II committed
56
57
58
template <class F>
migraphx_status try_(F f, bool output = true) // NOLINT
{
59
#ifdef MIGRAPHX_BUILD_TESTING
60
    if(disable_exception_catch)
Paul Fultz II's avatar
Paul Fultz II committed
61
62
63
    {
        f();
    }
64
    else
Paul Fultz II's avatar
Paul Fultz II committed
65
    {
66
#endif
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
        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;
Paul Fultz II's avatar
Paul Fultz II committed
84
            return migraphx_status_unknown_error;
85
86
87
88
89
        }
        catch(...)
        {
            return migraphx_status_unknown_error;
        }
90
#ifdef MIGRAPHX_BUILD_TESTING
Paul Fultz II's avatar
Paul Fultz II committed
91
    }
92
#endif
Paul Fultz II's avatar
Paul Fultz II committed
93
94
95
96
97
98
99
    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
100
    case migraphx_shape_tuple_type: return shape::tuple_type;
Paul Fultz II's avatar
Paul Fultz II committed
101
102
103
104
105
106
107
108
109
110
111
112
#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
113
    case shape::tuple_type: return migraphx_shape_tuple_type;
Paul Fultz II's avatar
Paul Fultz II committed
114
115
116
117
118
119
120
121
#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");
}

122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
template <class T>
auto to_obj_vector(const T* x, std::size_t n)
{
    std::vector<decltype((*x)->object)> result;
    std::transform(x, x + n, std::back_inserter(result), [&](auto&& y) { return y->object; });
    return result;
}

template <class T, class U>
auto to_objptr_vector(const U* x, std::size_t n)
{
    std::vector<T> result;
    std::transform(
        x, x + n, std::back_inserter(result), [&](auto&& y) { return std::addressof(y->object); });
    return result;
}

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

141
142
143
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
144

145
146
147
148
149
void set_exhaustive_tune_flag(compile_options& options, bool value)
{
    options.exhaustive_tune = value;
}

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

152
void set_default_dim_value(onnx_options& options, size_t value)
Paul Fultz II's avatar
Paul Fultz II committed
153
{
154
155
156
    options.default_dim_value = value;
}

157
158
159
160
161
void set_default_dyn_dim_value(onnx_options& options, const shape::dynamic_dimension& dd)
{
    options.default_dyn_dim_value = dd;
}

Shucai Xiao's avatar
Shucai Xiao committed
162
163
164
165
166
void set_default_loop_iterations(onnx_options& options, int64_t value)
{
    options.max_loop_iterations = value;
}

167
168
169
170
171
void set_limit_loop_iterations(onnx_options& options, int64_t value)
{
    options.limit_max_iterations = value;
}

kahmed10's avatar
kahmed10 committed
172
173
174
175
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; }

176
177
void set_input_parameter_shape(onnx_options& options,
                               const char* name,
178
                               std::vector<std::size_t> dims)
179
{
180
    options.map_input_dims[std::string(name)] = std::move(dims);
Paul Fultz II's avatar
Paul Fultz II committed
181
182
}

183
184
185
186
187
188
189
void set_dyn_input_parameter_shape(onnx_options& options,
                                   const char* name,
                                   std::vector<shape::dynamic_dimension> dyn_dims)
{
    options.map_dyn_input_dims[std::string(name)] = std::move(dyn_dims);
}

kahmed10's avatar
kahmed10 committed
190
191
192
193
194
195
196
197
198
199
void set_input_parameter_shape(tf_options& options, const char* name, std::vector<std::size_t> dims)
{
    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());
}

200
201
202
203
204
205
206
std::vector<argument>
run_async(program& p, const parameter_map& params, void* s, std::string_view name)
{
    execution_environment exec_env{any_ptr(s, name), true};
    return p.eval(params, exec_env);
}

Paul Fultz II's avatar
Paul Fultz II committed
207
208
209
210
211
212
213
214
215
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;
}

216
217
218
219
220
221
template <class T>
std::set<T> make_set(const T* x, std::size_t n)
{
    return {x, x + n};
}

Shucai Xiao's avatar
Shucai Xiao committed
222
223
224
225
226
227
228
229
230
231
232
233
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
{
234
235
    std::vector<parameter_map> calibration = {};
    std::vector<std::string> op_names      = {};
Shucai Xiao's avatar
Shucai Xiao committed
236
237
238
239
240
241
242
};

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

243
void add_calibration_data(quantize_int8_options& options, parameter_map& data)
Shucai Xiao's avatar
Shucai Xiao committed
244
245
246
247
248
249
250
251
252
253
254
255
256
257
{
    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);
}

258
259
260
261
262
263
#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)
264
{
265
266
267
    std::string sattributes = attributes == nullptr ? "" : attributes;
    std::vector<char> buffer(sattributes.size() * 2);
    std::vsnprintf(buffer.data(), buffer.size(), sattributes.c_str(), vlist);
268
269
270
    value v = value::object{};
    if(attributes != nullptr)
    {
271
        v = from_json_string(convert_to_json(std::string(buffer.data())));
272
273
274
275
276
277
    }
    auto op = make_op(name, v);

    return op;
}

278
279
280
281
#ifdef __clang__
#pragma clang diagnostic pop
#endif

Paul Fultz II's avatar
Paul Fultz II committed
282
283
284
285
286
287
template <class T>
bool equal(const T& x, const T& y)
{
    return x == y;
}

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

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

Shucai Xiao's avatar
Shucai Xiao committed
292
293
294
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
295

296
297
298
299
300
migraphx::instruction_ref add_allocation(module& m, const migraphx::shape& s)
{
    return m.add_instruction(migraphx::make_op("allocate", {{"shape", migraphx::to_value(s)}}), {});
}

301
302
303
304
305
306
307
308
309
310
311
struct experimental_custom_op
{
    std::string name;
    experimental_custom_op() = default;

    experimental_custom_op(std::string pname) : name(std::move(pname)) {}
};

template <class CustomOp>
struct custom_operation
{
312

313
314
315
316
317
    template <class Self, class F>
    static auto reflect(Self&, F)
    {
        return pack();
    }
318
319
320
321
322
323

    value attributes() const
    {
        return {{"custom_op", true}, {"target", op.runs_on_offload_target() ? "gpu" : "cpu"}};
    }

324
325
326
327
328
329
330
331
    CustomOp op;
    std::string name() const { return op.xobject.name; }

    shape compute_shape(std::vector<shape> inputs) const
    {
        return op.compute_shape(std::move(inputs));
    }

332
333
334
335
336
337
    // TODO: Compute method with module_args
    argument
    compute(migraphx::context ctx, migraphx::shape output_shape, std::vector<argument> inputs) const
    {
        return op.compute(std::move(ctx), std::move(output_shape), std::move(inputs));
    }
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354

    std::ptrdiff_t output_alias(std::vector<shape> inputs) const
    {
        auto alias_vec = op.output_alias(std::move(inputs));
        // TODO: For now, only support one output alias
        if(alias_vec.empty())
        {
            return -1;
        }
        if(alias_vec.size() > 1)
        {
            MIGRAPHX_THROW("Currently, CustomOps in MIGraphX only supports one output_alias");
        }
        return alias_vec.front();
    }

    bool runs_on_offload_target() const { return op.runs_on_offload_target(); }
355
356
357
358
359
360
361
362
};

template <class CustomOp>
void register_custom_op(const CustomOp& op)
{
    register_op(custom_operation<CustomOp>{op});
}

kahmed10's avatar
kahmed10 committed
363
364
migraphx::context get_context(const program& p) { return p.get_context(); }

Paul Fultz II's avatar
Paul Fultz II committed
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
} // 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)
{
381
382
383
384
    if constexpr(std::is_aggregate<Target>{})
        return new Target{std::forward<Ts>(xs)...}; // NOLINT
    else
        return new Target(std::forward<Ts>(xs)...); // NOLINT
Paul Fultz II's avatar
Paul Fultz II committed
385
386
387
388
389
390
391
}

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

393
394
395
396
397
398
399
400
// TODO: Move to interface preamble
template <class C, class D>
struct manage_generic_ptr
{
    manage_generic_ptr() = default;

    manage_generic_ptr(std::nullptr_t) {}

401
402
    manage_generic_ptr(void* pdata, const char* obj_tname, C pcopier, D pdeleter)
        : data(nullptr), obj_typename(obj_tname), copier(pcopier), deleter(pdeleter)
403
404
405
406
407
    {
        copier(&data, pdata);
    }

    manage_generic_ptr(const manage_generic_ptr& rhs)
408
        : data(nullptr), obj_typename(rhs.obj_typename), copier(rhs.copier), deleter(rhs.deleter)
409
410
411
412
413
414
    {
        if(copier)
            copier(&data, rhs.data);
    }

    manage_generic_ptr(manage_generic_ptr&& other) noexcept
415
416
417
418
        : data(other.data),
          obj_typename(other.obj_typename),
          copier(other.copier),
          deleter(other.deleter)
419
    {
420
421
422
423
        other.data         = nullptr;
        other.obj_typename = "";
        other.copier       = nullptr;
        other.deleter      = nullptr;
424
425
426
427
428
    }

    manage_generic_ptr& operator=(manage_generic_ptr rhs)
    {
        std::swap(data, rhs.data);
429
        std::swap(obj_typename, rhs.obj_typename);
430
431
432
433
434
435
436
437
438
439
440
        std::swap(copier, rhs.copier);
        std::swap(deleter, rhs.deleter);
        return *this;
    }

    ~manage_generic_ptr()
    {
        if(data != nullptr)
            deleter(data);
    }

441
442
443
444
    void* data               = nullptr;
    const char* obj_typename = "";
    C copier                 = nullptr;
    D deleter                = nullptr;
445
};
Paul Fultz II's avatar
Paul Fultz II committed
446

447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
extern "C" struct migraphx_optimals;
struct migraphx_optimals
{
    template <class... Ts>
    migraphx_optimals(Ts&&... xs)
        : object(std::forward<Ts>(xs)...) // NOLINT(readability-redundant-member-init)
    {
    }
    std::set<size_t> object;
};

extern "C" struct migraphx_dynamic_dimension;
struct migraphx_dynamic_dimension
{
    template <class... Ts>
    migraphx_dynamic_dimension(Ts&&... xs)
        : object(std::forward<Ts>(xs)...) // NOLINT(readability-redundant-member-init)
    {
    }
    migraphx::shape::dynamic_dimension object;
};

extern "C" struct migraphx_dynamic_dimensions;
struct migraphx_dynamic_dimensions
{
    template <class... Ts>
    migraphx_dynamic_dimensions(Ts&&... xs)
        : object(std::forward<Ts>(xs)...) // NOLINT(readability-redundant-member-init)
    {
    }
    std::vector<migraphx::shape::dynamic_dimension> object;
};

Paul Fultz II's avatar
Paul Fultz II committed
480
481
482
483
extern "C" struct migraphx_shape;
struct migraphx_shape
{
    template <class... Ts>
484
485
    migraphx_shape(Ts&&... xs)
        : object(std::forward<Ts>(xs)...) // NOLINT(readability-redundant-member-init)
Paul Fultz II's avatar
Paul Fultz II committed
486
487
488
489
490
491
492
493
494
    {
    }
    migraphx::shape object;
};

extern "C" struct migraphx_argument;
struct migraphx_argument
{
    template <class... Ts>
495
496
    migraphx_argument(Ts&&... xs)
        : object(std::forward<Ts>(xs)...) // NOLINT(readability-redundant-member-init)
Paul Fultz II's avatar
Paul Fultz II committed
497
498
499
500
501
502
503
504
505
    {
    }
    migraphx::argument object;
};

extern "C" struct migraphx_target;
struct migraphx_target
{
    template <class... Ts>
506
507
    migraphx_target(Ts&&... xs)
        : object(std::forward<Ts>(xs)...) // NOLINT(readability-redundant-member-init)
Paul Fultz II's avatar
Paul Fultz II committed
508
509
510
511
512
513
514
515
516
    {
    }
    migraphx::target object;
};

extern "C" struct migraphx_program_parameter_shapes;
struct migraphx_program_parameter_shapes
{
    template <class... Ts>
517
518
    migraphx_program_parameter_shapes(Ts&&... xs)
        : object(std::forward<Ts>(xs)...) // NOLINT(readability-redundant-member-init)
Paul Fultz II's avatar
Paul Fultz II committed
519
520
521
522
523
524
525
526
527
    {
    }
    std::unordered_map<std::string, migraphx::shape> object;
};

extern "C" struct migraphx_program_parameters;
struct migraphx_program_parameters
{
    template <class... Ts>
528
529
    migraphx_program_parameters(Ts&&... xs)
        : object(std::forward<Ts>(xs)...) // NOLINT(readability-redundant-member-init)
Paul Fultz II's avatar
Paul Fultz II committed
530
531
532
533
534
535
536
537
538
    {
    }
    std::unordered_map<std::string, migraphx::argument> object;
};

extern "C" struct migraphx_arguments;
struct migraphx_arguments
{
    template <class... Ts>
539
540
    migraphx_arguments(Ts&&... xs)
        : object(std::forward<Ts>(xs)...) // NOLINT(readability-redundant-member-init)
Paul Fultz II's avatar
Paul Fultz II committed
541
542
543
544
545
546
547
548
549
    {
    }
    std::vector<migraphx::argument> object;
};

extern "C" struct migraphx_shapes;
struct migraphx_shapes
{
    template <class... Ts>
550
551
    migraphx_shapes(Ts&&... xs)
        : object(std::forward<Ts>(xs)...) // NOLINT(readability-redundant-member-init)
Paul Fultz II's avatar
Paul Fultz II committed
552
553
554
555
556
    {
    }
    std::vector<migraphx::shape> object;
};

557
558
559
560
extern "C" struct migraphx_instruction;
struct migraphx_instruction
{
    template <class... Ts>
561
562
    migraphx_instruction(Ts&&... xs)
        : object(std::forward<Ts>(xs)...) // NOLINT(readability-redundant-member-init)
563
564
565
566
567
568
569
570
571
    {
    }
    migraphx::instruction_ref object;
};

extern "C" struct migraphx_instructions;
struct migraphx_instructions
{
    template <class... Ts>
572
573
    migraphx_instructions(Ts&&... xs)
        : object(std::forward<Ts>(xs)...) // NOLINT(readability-redundant-member-init)
574
575
576
577
578
579
580
581
582
    {
    }
    std::vector<migraphx::instruction_ref> object;
};

extern "C" struct migraphx_modules;
struct migraphx_modules
{
    template <class... Ts>
583
584
    migraphx_modules(Ts&&... xs)
        : object(std::forward<Ts>(xs)...) // NOLINT(readability-redundant-member-init)
585
586
587
588
589
    {
    }
    std::vector<migraphx::module*> object;
};

Shucai Xiao's avatar
Shucai Xiao committed
590
591
592
593
extern "C" struct migraphx_module;
struct migraphx_module
{
    template <class... Ts>
594
595
    migraphx_module(Ts&&... xs)
        : object(std::forward<Ts>(xs)...) // NOLINT(readability-redundant-member-init)
Shucai Xiao's avatar
Shucai Xiao committed
596
597
598
599
600
    {
    }
    migraphx::module object;
};

Paul Fultz II's avatar
Paul Fultz II committed
601
602
603
604
extern "C" struct migraphx_program;
struct migraphx_program
{
    template <class... Ts>
605
606
    migraphx_program(Ts&&... xs)
        : object(std::forward<Ts>(xs)...) // NOLINT(readability-redundant-member-init)
Paul Fultz II's avatar
Paul Fultz II committed
607
608
609
610
611
    {
    }
    migraphx::program object;
};

612
613
614
615
extern "C" struct migraphx_operation;
struct migraphx_operation
{
    template <class... Ts>
616
617
    migraphx_operation(Ts&&... xs)
        : object(std::forward<Ts>(xs)...) // NOLINT(readability-redundant-member-init)
618
619
620
621
622
    {
    }
    migraphx::operation object;
};

623
624
625
626
extern "C" struct migraphx_onnx_options;
struct migraphx_onnx_options
{
    template <class... Ts>
627
628
    migraphx_onnx_options(Ts&&... xs)
        : object(std::forward<Ts>(xs)...) // NOLINT(readability-redundant-member-init)
629
630
631
632
633
    {
    }
    migraphx::onnx_options object;
};

634
635
636
637
extern "C" struct migraphx_file_options;
struct migraphx_file_options
{
    template <class... Ts>
638
639
    migraphx_file_options(Ts&&... xs)
        : object(std::forward<Ts>(xs)...) // NOLINT(readability-redundant-member-init)
640
641
642
643
644
    {
    }
    migraphx::file_options object;
};

645
646
647
648
extern "C" struct migraphx_compile_options;
struct migraphx_compile_options
{
    template <class... Ts>
649
650
    migraphx_compile_options(Ts&&... xs)
        : object(std::forward<Ts>(xs)...) // NOLINT(readability-redundant-member-init)
651
652
653
654
655
    {
    }
    migraphx::compile_options object;
};

kahmed10's avatar
kahmed10 committed
656
657
658
659
extern "C" struct migraphx_tf_options;
struct migraphx_tf_options
{
    template <class... Ts>
660
661
    migraphx_tf_options(Ts&&... xs)
        : object(std::forward<Ts>(xs)...) // NOLINT(readability-redundant-member-init)
kahmed10's avatar
kahmed10 committed
662
663
664
665
666
    {
    }
    migraphx::tf_options object;
};

Shucai Xiao's avatar
Shucai Xiao committed
667
668
669
670
extern "C" struct migraphx_quantize_op_names;
struct migraphx_quantize_op_names
{
    template <class... Ts>
671
672
    migraphx_quantize_op_names(Ts&&... xs)
        : object(std::forward<Ts>(xs)...) // NOLINT(readability-redundant-member-init)
Shucai Xiao's avatar
Shucai Xiao committed
673
674
675
676
677
678
679
680
681
    {
    }
    std::vector<std::string> object;
};

extern "C" struct migraphx_quantize_int8_options;
struct migraphx_quantize_int8_options
{
    template <class... Ts>
682
683
    migraphx_quantize_int8_options(Ts&&... xs)
        : object(std::forward<Ts>(xs)...) // NOLINT(readability-redundant-member-init)
Shucai Xiao's avatar
Shucai Xiao committed
684
685
686
687
688
    {
    }
    migraphx::quantize_int8_options object;
};

kahmed10's avatar
kahmed10 committed
689
690
691
692
extern "C" struct migraphx_context;
struct migraphx_context
{
    template <class... Ts>
693
694
    migraphx_context(Ts&&... xs)
        : object(std::forward<Ts>(xs)...) // NOLINT(readability-redundant-member-init)
kahmed10's avatar
kahmed10 committed
695
696
697
698
699
    {
    }
    migraphx::context object;
};

700
701
702
703
704
705
706
extern "C" struct migraphx_experimental_custom_op;
struct migraphx_experimental_custom_op
{
    template <class... Ts>
    migraphx_experimental_custom_op(void* p,
                                    migraphx_experimental_custom_op_copy c,
                                    migraphx_experimental_custom_op_delete d,
707
                                    const char* obj_typename,
708
                                    Ts&&... xs)
709
        : object_ptr(p, obj_typename, c, d), xobject(std::forward<Ts>(xs)...)
710
711
712
713
714
    {
    }
    manage_generic_ptr<migraphx_experimental_custom_op_copy, migraphx_experimental_custom_op_delete>
        object_ptr = nullptr;
    migraphx::experimental_custom_op xobject;
715
716
717
718
719
720
721
    migraphx_experimental_custom_op_compute compute_f = nullptr;
    migraphx::argument compute(migraphx::context ctx,
                               migraphx::shape output,
                               std::vector<migraphx::argument> inputs) const
    {
        if(compute_f == nullptr)
            throw std::runtime_error("compute function is missing.");
722
        std::remove_pointer_t<migraphx_argument_t> out;
723
724
        std::array<char, 256> exception_msg;
        exception_msg.front() = '\0';
725
726
        auto api_error_result = compute_f(&out,
                                          object_ptr.data,
727
728
                                          exception_msg.data(),
                                          exception_msg.size(),
729
730
731
732
                                          object_cast<migraphx_context_t>(&(ctx)),
                                          object_cast<migraphx_shape_t>(&(output)),
                                          object_cast<migraphx_arguments_t>(&(inputs)));
        if(api_error_result != migraphx_status_success)
733
734
735
736
737
        {
            const std::string exception_str(exception_msg.data());
            throw std::runtime_error("Error in compute of: " +
                                     std::string(object_ptr.obj_typename) + ": " + exception_str);
        }
738
739
740
        return (&out)->object;
    }

741
742
743
744
745
    migraphx_experimental_custom_op_compute_shape compute_shape_f = nullptr;
    migraphx::shape compute_shape(std::vector<migraphx::shape> inputs) const
    {
        if(compute_shape_f == nullptr)
            throw std::runtime_error("compute_shape function is missing.");
746
        std::remove_pointer_t<migraphx_shape_t> out;
747
748
749
750
751
752
753
        std::array<char, 256> exception_msg;
        exception_msg.front() = '\0';
        auto api_error_result = compute_shape_f(&out,
                                                object_ptr.data,
                                                exception_msg.data(),
                                                exception_msg.size(),
                                                object_cast<migraphx_shapes_t>(&(inputs)));
754
        if(api_error_result != migraphx_status_success)
755
756
757
758
759
        {
            const std::string exception_str(exception_msg.data());
            throw std::runtime_error("Error in compute_shape of: " +
                                     std::string(object_ptr.obj_typename) + ": " + exception_str);
        }
760
761
        return (&out)->object;
    }
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804

    migraphx_experimental_custom_op_output_alias output_alias_f = nullptr;
    std::vector<size_t> output_alias(std::vector<migraphx::shape> inputs) const
    {
        if(output_alias_f == nullptr)
            throw std::runtime_error("output_alias function is missing.");
        std::array<size_t, 1024> out;
        std::remove_pointer_t<size_t*> out_size = 1024;
        std::array<char, 256> exception_msg;
        exception_msg.front() = '\0';
        auto api_error_result = output_alias_f(out.data(),
                                               &out_size,
                                               object_ptr.data,
                                               exception_msg.data(),
                                               exception_msg.size(),
                                               object_cast<migraphx_shapes_t>(&(inputs)));
        if(api_error_result != migraphx_status_success)
        {
            const std::string exception_str(exception_msg.data());
            throw std::runtime_error("Error in output_alias of: " +
                                     std::string(object_ptr.obj_typename) + ": " + exception_str);
        }
        return {out.begin(), out.begin() + out_size}; // cppcheck-suppress returnDanglingLifetime;
    }

    migraphx_experimental_custom_op_runs_on_offload_target runs_on_offload_target_f = nullptr;
    bool runs_on_offload_target() const
    {
        if(runs_on_offload_target_f == nullptr)
            throw std::runtime_error("runs_on_offload_target function is missing.");
        std::remove_pointer_t<bool*> out;
        std::array<char, 256> exception_msg;
        exception_msg.front() = '\0';
        auto api_error_result = runs_on_offload_target_f(
            &out, object_ptr.data, exception_msg.data(), exception_msg.size());
        if(api_error_result != migraphx_status_success)
        {
            const std::string exception_str(exception_msg.data());
            throw std::runtime_error("Error in runs_on_offload_target of: " +
                                     std::string(object_ptr.obj_typename) + ": " + exception_str);
        }
        return out;
    }
805
806
};

807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
extern "C" migraphx_status migraphx_optimals_destroy(migraphx_optimals_t optimals)
{
    auto api_error_result = migraphx::try_([&] { destroy((optimals)); });
    return api_error_result;
}

extern "C" migraphx_status migraphx_optimals_assign_to(migraphx_optimals_t output,
                                                       const_migraphx_optimals_t input)
{
    auto api_error_result = migraphx::try_([&] { *output = *input; });
    return api_error_result;
}

extern "C" migraphx_status
migraphx_optimals_create(migraphx_optimals_t* optimals, const size_t* ptr, size_t size)
{
    auto api_error_result = migraphx::try_([&] {
        *optimals = object_cast<migraphx_optimals_t>(
            allocate<std::set<size_t>>(migraphx::make_set<size_t>((ptr), (size))));
    });
    return api_error_result;
}

extern "C" migraphx_status
migraphx_dynamic_dimension_destroy(migraphx_dynamic_dimension_t dynamic_dimension)
{
    auto api_error_result = migraphx::try_([&] { destroy((dynamic_dimension)); });
    return api_error_result;
}

extern "C" migraphx_status
migraphx_dynamic_dimension_assign_to(migraphx_dynamic_dimension_t output,
                                     const_migraphx_dynamic_dimension_t input)
{
    auto api_error_result = migraphx::try_([&] { *output = *input; });
    return api_error_result;
}

extern "C" migraphx_status migraphx_dynamic_dimension_create_min_max(
    migraphx_dynamic_dimension_t* dynamic_dimension, size_t min, size_t max)
{
    auto api_error_result = migraphx::try_([&] {
        *dynamic_dimension = object_cast<migraphx_dynamic_dimension_t>(
            allocate<migraphx::shape::dynamic_dimension>((min), (max)));
    });
    return api_error_result;
}

extern "C" migraphx_status
migraphx_dynamic_dimension_create_min_max_optimals(migraphx_dynamic_dimension_t* dynamic_dimension,
                                                   size_t min,
                                                   size_t max,
                                                   migraphx_optimals_t optimals)
{
    auto api_error_result = migraphx::try_([&] {
        if(optimals == nullptr)
            MIGRAPHX_THROW(migraphx_status_bad_param, "Bad parameter optimals: Null pointer");
        *dynamic_dimension = object_cast<migraphx_dynamic_dimension_t>(
            allocate<migraphx::shape::dynamic_dimension>((min), (max), (optimals->object)));
    });
    return api_error_result;
}

extern "C" migraphx_status
migraphx_dynamic_dimension_is_fixed(bool* out, const_migraphx_dynamic_dimension_t dynamic_dimension)
{
    auto api_error_result = migraphx::try_([&] {
        if(dynamic_dimension == nullptr)
            MIGRAPHX_THROW(migraphx_status_bad_param,
                           "Bad parameter dynamic_dimension: Null pointer");
        *out = (dynamic_dimension->object).is_fixed();
    });
    return api_error_result;
}

extern "C" migraphx_status
migraphx_dynamic_dimension_equal(bool* out,
                                 const_migraphx_dynamic_dimension_t dynamic_dimension,
                                 const_migraphx_dynamic_dimension_t x)
{
    auto api_error_result = migraphx::try_([&] {
        if(dynamic_dimension == nullptr)
            MIGRAPHX_THROW(migraphx_status_bad_param,
                           "Bad parameter dynamic_dimension: Null pointer");
        if(x == nullptr)
            MIGRAPHX_THROW(migraphx_status_bad_param, "Bad parameter x: Null pointer");
        *out = migraphx::equal((dynamic_dimension->object), (x->object));
    });
    return api_error_result;
}

extern "C" migraphx_status
migraphx_dynamic_dimensions_destroy(migraphx_dynamic_dimensions_t dynamic_dimensions)
{
    auto api_error_result = migraphx::try_([&] { destroy((dynamic_dimensions)); });
    return api_error_result;
}

extern "C" migraphx_status
migraphx_dynamic_dimensions_assign_to(migraphx_dynamic_dimensions_t output,
                                      const_migraphx_dynamic_dimensions_t input)
{
    auto api_error_result = migraphx::try_([&] { *output = *input; });
    return api_error_result;
}

extern "C" migraphx_status
migraphx_dynamic_dimensions_create(migraphx_dynamic_dimensions_t* dynamic_dimensions,
915
                                   const const_migraphx_dynamic_dimension_t* ptr,
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
                                   size_t size)
{
    auto api_error_result = migraphx::try_([&] {
        *dynamic_dimensions = object_cast<migraphx_dynamic_dimensions_t>(
            allocate<std::vector<migraphx::shape::dynamic_dimension>>(
                migraphx::to_obj_vector<const_migraphx_dynamic_dimension_t>((ptr), (size))));
    });
    return api_error_result;
}

extern "C" migraphx_status
migraphx_dynamic_dimensions_size(size_t* out, migraphx_dynamic_dimensions_t dynamic_dimensions)
{
    auto api_error_result = migraphx::try_([&] {
        if(dynamic_dimensions == nullptr)
            MIGRAPHX_THROW(migraphx_status_bad_param,
                           "Bad parameter dynamic_dimensions: Null pointer");
        *out = (dynamic_dimensions->object).size();
    });
    return api_error_result;
}

extern "C" migraphx_status
migraphx_dynamic_dimensions_get(const_migraphx_dynamic_dimension_t* out,
                                migraphx_dynamic_dimensions_t dynamic_dimensions,
                                size_t idx)
{
    auto api_error_result = migraphx::try_([&] {
        if(dynamic_dimensions == nullptr)
            MIGRAPHX_THROW(migraphx_status_bad_param,
                           "Bad parameter dynamic_dimensions: Null pointer");
        *out = object_cast<const_migraphx_dynamic_dimension_t>(
            &((dynamic_dimensions->object).at((idx))));
    });
    return api_error_result;
}

Paul Fultz II's avatar
Paul Fultz II committed
953
954
extern "C" migraphx_status migraphx_shape_destroy(migraphx_shape_t shape)
{
955
956
    auto api_error_result = migraphx::try_([&] { destroy((shape)); });
    return api_error_result;
Paul Fultz II's avatar
Paul Fultz II committed
957
958
}

959
960
961
962
963
964
965
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
966
967
968
969
970
extern "C" migraphx_status migraphx_shape_create(migraphx_shape_t* shape,
                                                 migraphx_shape_datatype_t type,
                                                 size_t* lengths,
                                                 size_t lengths_size)
{
971
    auto api_error_result = migraphx::try_([&] {
972
        if(lengths == nullptr and lengths_size != 0)
Paul Fultz II's avatar
Paul Fultz II committed
973
974
975
976
977
            MIGRAPHX_THROW(migraphx_status_bad_param, "Bad parameter lengths: Null pointer");
        *shape = object_cast<migraphx_shape_t>(
            allocate<migraphx::shape>((migraphx::to_shape_type(type)),
                                      (std::vector<size_t>(lengths, lengths + lengths_size))));
    });
978
    return api_error_result;
Paul Fultz II's avatar
Paul Fultz II committed
979
980
}

981
982
983
984
985
986
987
extern "C" migraphx_status migraphx_shape_create_with_strides(migraphx_shape_t* shape,
                                                              migraphx_shape_datatype_t type,
                                                              size_t* lengths,
                                                              size_t lengths_size,
                                                              size_t* strides,
                                                              size_t strides_size)
{
988
    auto api_error_result = migraphx::try_([&] {
989
990
991
992
993
994
995
996
997
        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)),
                                      (std::vector<size_t>(lengths, lengths + lengths_size)),
                                      (std::vector<size_t>(strides, strides + strides_size))));
    });
998
    return api_error_result;
999
1000
}

1001
1002
1003
extern "C" migraphx_status migraphx_shape_create_scalar(migraphx_shape_t* shape,
                                                        migraphx_shape_datatype_t type)
{
1004
    auto api_error_result = migraphx::try_([&] {
1005
1006
1007
        *shape = object_cast<migraphx_shape_t>(
            allocate<migraphx::shape>((migraphx::to_shape_type(type))));
    });
1008
    return api_error_result;
1009
1010
}

1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
extern "C" migraphx_status migraphx_shape_create_dynamic(migraphx_shape_t* shape,
                                                         migraphx_shape_datatype_t type,
                                                         migraphx_dynamic_dimensions_t dims)
{
    auto api_error_result = migraphx::try_([&] {
        if(dims == nullptr)
            MIGRAPHX_THROW(migraphx_status_bad_param, "Bad parameter dims: Null pointer");
        *shape = object_cast<migraphx_shape_t>(
            allocate<migraphx::shape>((migraphx::to_shape_type(type)), (dims->object)));
    });
    return api_error_result;
}

Paul Fultz II's avatar
Paul Fultz II committed
1024
1025
1026
extern "C" migraphx_status
migraphx_shape_lengths(const size_t** out, size_t* out_size, const_migraphx_shape_t shape)
{
1027
    auto api_error_result = migraphx::try_([&] {
Paul Fultz II's avatar
Paul Fultz II committed
1028
1029
1030
1031
1032
1033
1034
1035
        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();
    });
1036
    return api_error_result;
Paul Fultz II's avatar
Paul Fultz II committed
1037
1038
1039
1040
1041
}

extern "C" migraphx_status
migraphx_shape_strides(const size_t** out, size_t* out_size, const_migraphx_shape_t shape)
{
1042
    auto api_error_result = migraphx::try_([&] {
Paul Fultz II's avatar
Paul Fultz II committed
1043
1044
1045
1046
1047
1048
1049
1050
        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();
    });
1051
    return api_error_result;
Paul Fultz II's avatar
Paul Fultz II committed
1052
1053
}

1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
extern "C" migraphx_status migraphx_shape_dyn_dims(migraphx_dynamic_dimensions_t* out,
                                                   const_migraphx_shape_t shape)
{
    auto api_error_result = migraphx::try_([&] {
        if(shape == nullptr)
            MIGRAPHX_THROW(migraphx_status_bad_param, "Bad parameter shape: Null pointer");
        *out = allocate<migraphx_dynamic_dimensions_t>((shape->object).dyn_dims());
    });
    return api_error_result;
}

Paul Fultz II's avatar
Paul Fultz II committed
1065
1066
1067
extern "C" migraphx_status migraphx_shape_type(migraphx_shape_datatype_t* out,
                                               const_migraphx_shape_t shape)
{
1068
    auto api_error_result = migraphx::try_([&] {
Paul Fultz II's avatar
Paul Fultz II committed
1069
1070
1071
1072
1073
1074
        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());
    });
1075
    return api_error_result;
Paul Fultz II's avatar
Paul Fultz II committed
1076
1077
}

1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
extern "C" migraphx_status migraphx_shape_elements(size_t* out, const_migraphx_shape_t shape)
{
    auto api_error_result = migraphx::try_([&] {
        if(shape == nullptr)
            MIGRAPHX_THROW(migraphx_status_bad_param, "Bad parameter shape: Null pointer");
        *out = (shape->object).elements();
    });
    return api_error_result;
}

Paul Fultz II's avatar
Paul Fultz II committed
1088
1089
extern "C" migraphx_status migraphx_shape_bytes(size_t* out, const_migraphx_shape_t shape)
{
1090
    auto api_error_result = migraphx::try_([&] {
Paul Fultz II's avatar
Paul Fultz II committed
1091
1092
1093
1094
        if(shape == nullptr)
            MIGRAPHX_THROW(migraphx_status_bad_param, "Bad parameter shape: Null pointer");
        *out = (shape->object).bytes();
    });
1095
    return api_error_result;
Paul Fultz II's avatar
Paul Fultz II committed
1096
1097
}

1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
extern "C" migraphx_status migraphx_shape_ndim(size_t* out, const_migraphx_shape_t shape)
{
    auto api_error_result = migraphx::try_([&] {
        if(shape == nullptr)
            MIGRAPHX_THROW(migraphx_status_bad_param, "Bad parameter shape: Null pointer");
        *out = (shape->object).ndim();
    });
    return api_error_result;
}

Paul Fultz II's avatar
Paul Fultz II committed
1108
1109
1110
extern "C" migraphx_status
migraphx_shape_equal(bool* out, const_migraphx_shape_t shape, const_migraphx_shape_t x)
{
1111
    auto api_error_result = migraphx::try_([&] {
Paul Fultz II's avatar
Paul Fultz II committed
1112
1113
1114
1115
1116
1117
        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));
    });
1118
    return api_error_result;
Paul Fultz II's avatar
Paul Fultz II committed
1119
1120
}

1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
extern "C" migraphx_status migraphx_shape_standard(bool* out, const_migraphx_shape_t shape)
{
    auto api_error_result = migraphx::try_([&] {
        if(shape == nullptr)
            MIGRAPHX_THROW(migraphx_status_bad_param, "Bad parameter shape: Null pointer");
        *out = (shape->object).standard();
    });
    return api_error_result;
}

1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
extern "C" migraphx_status migraphx_shape_dynamic(bool* out, const_migraphx_shape_t shape)
{
    auto api_error_result = migraphx::try_([&] {
        if(shape == nullptr)
            MIGRAPHX_THROW(migraphx_status_bad_param, "Bad parameter shape: Null pointer");
        *out = (shape->object).dynamic();
    });
    return api_error_result;
}

1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
extern "C" migraphx_status migraphx_shape_index(size_t* out, const_migraphx_shape_t shape, size_t i)
{
    auto api_error_result = migraphx::try_([&] {
        if(shape == nullptr)
            MIGRAPHX_THROW(migraphx_status_bad_param, "Bad parameter shape: Null pointer");
        *out = (shape->object).index((i));
    });
    return api_error_result;
}

Paul Fultz II's avatar
Paul Fultz II committed
1151
1152
extern "C" migraphx_status migraphx_argument_destroy(migraphx_argument_t argument)
{
1153
1154
    auto api_error_result = migraphx::try_([&] { destroy((argument)); });
    return api_error_result;
Paul Fultz II's avatar
Paul Fultz II committed
1155
1156
}

1157
1158
1159
1160
1161
1162
1163
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
1164
1165
1166
extern "C" migraphx_status
migraphx_argument_create(migraphx_argument_t* argument, const_migraphx_shape_t shape, void* buffer)
{
1167
    auto api_error_result = migraphx::try_([&] {
Paul Fultz II's avatar
Paul Fultz II committed
1168
1169
1170
1171
1172
        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)));
    });
1173
    return api_error_result;
Paul Fultz II's avatar
Paul Fultz II committed
1174
1175
}

1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
extern "C" migraphx_status migraphx_argument_create_empty(migraphx_argument_t* argument,
                                                          const_migraphx_shape_t shape)
{
    auto api_error_result = migraphx::try_([&] {
        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)));
    });
    return api_error_result;
}

Paul Fultz II's avatar
Paul Fultz II committed
1187
1188
1189
extern "C" migraphx_status migraphx_argument_shape(const_migraphx_shape_t* out,
                                                   const_migraphx_argument_t argument)
{
1190
    auto api_error_result = migraphx::try_([&] {
Paul Fultz II's avatar
Paul Fultz II committed
1191
1192
1193
1194
        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()));
    });
1195
    return api_error_result;
Paul Fultz II's avatar
Paul Fultz II committed
1196
1197
1198
1199
}

extern "C" migraphx_status migraphx_argument_buffer(char** out, const_migraphx_argument_t argument)
{
1200
    auto api_error_result = migraphx::try_([&] {
Paul Fultz II's avatar
Paul Fultz II committed
1201
1202
1203
1204
        if(argument == nullptr)
            MIGRAPHX_THROW(migraphx_status_bad_param, "Bad parameter argument: Null pointer");
        *out = (argument->object).data();
    });
1205
    return api_error_result;
Paul Fultz II's avatar
Paul Fultz II committed
1206
1207
1208
1209
1210
}

extern "C" migraphx_status
migraphx_argument_equal(bool* out, const_migraphx_argument_t argument, const_migraphx_argument_t x)
{
1211
    auto api_error_result = migraphx::try_([&] {
Paul Fultz II's avatar
Paul Fultz II committed
1212
1213
1214
1215
1216
1217
        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));
    });
1218
    return api_error_result;
Paul Fultz II's avatar
Paul Fultz II committed
1219
1220
1221
1222
1223
}

extern "C" migraphx_status
migraphx_argument_generate(migraphx_argument_t* out, const_migraphx_shape_t s, size_t seed)
{
1224
    auto api_error_result = migraphx::try_([&] {
Paul Fultz II's avatar
Paul Fultz II committed
1225
1226
1227
1228
        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)));
    });
1229
    return api_error_result;
Paul Fultz II's avatar
Paul Fultz II committed
1230
1231
1232
1233
}

extern "C" migraphx_status migraphx_target_destroy(migraphx_target_t target)
{
1234
1235
    auto api_error_result = migraphx::try_([&] { destroy((target)); });
    return api_error_result;
Paul Fultz II's avatar
Paul Fultz II committed
1236
1237
}

1238
1239
1240
1241
1242
1243
1244
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
1245
1246
extern "C" migraphx_status migraphx_target_create(migraphx_target_t* target, const char* name)
{
1247
    auto api_error_result = migraphx::try_([&] {
Paul Fultz II's avatar
Paul Fultz II committed
1248
1249
1250
        *target = object_cast<migraphx_target_t>(
            allocate<migraphx::target>(migraphx::get_target((name))));
    });
1251
    return api_error_result;
Paul Fultz II's avatar
Paul Fultz II committed
1252
1253
1254
1255
1256
}

extern "C" migraphx_status migraphx_program_parameter_shapes_destroy(
    migraphx_program_parameter_shapes_t program_parameter_shapes)
{
1257
1258
    auto api_error_result = migraphx::try_([&] { destroy((program_parameter_shapes)); });
    return api_error_result;
Paul Fultz II's avatar
Paul Fultz II committed
1259
1260
}

1261
1262
1263
1264
1265
1266
1267
1268
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
1269
1270
1271
1272
extern "C" migraphx_status
migraphx_program_parameter_shapes_size(size_t* out,
                                       migraphx_program_parameter_shapes_t program_parameter_shapes)
{
1273
    auto api_error_result = migraphx::try_([&] {
Paul Fultz II's avatar
Paul Fultz II committed
1274
1275
1276
1277
1278
        if(program_parameter_shapes == nullptr)
            MIGRAPHX_THROW(migraphx_status_bad_param,
                           "Bad parameter program_parameter_shapes: Null pointer");
        *out = (program_parameter_shapes->object).size();
    });
1279
    return api_error_result;
Paul Fultz II's avatar
Paul Fultz II committed
1280
1281
1282
1283
1284
1285
1286
}

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)
{
1287
    auto api_error_result = migraphx::try_([&] {
Paul Fultz II's avatar
Paul Fultz II committed
1288
1289
1290
1291
1292
1293
        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))));
    });
1294
    return api_error_result;
Paul Fultz II's avatar
Paul Fultz II committed
1295
1296
1297
1298
1299
}

extern "C" migraphx_status migraphx_program_parameter_shapes_names(
    const char** out, migraphx_program_parameter_shapes_t program_parameter_shapes)
{
1300
    auto api_error_result = migraphx::try_([&] {
Paul Fultz II's avatar
Paul Fultz II committed
1301
1302
1303
1304
1305
1306
1307
1308
        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);
    });
1309
    return api_error_result;
Paul Fultz II's avatar
Paul Fultz II committed
1310
1311
1312
1313
1314
}

extern "C" migraphx_status
migraphx_program_parameters_destroy(migraphx_program_parameters_t program_parameters)
{
1315
1316
    auto api_error_result = migraphx::try_([&] { destroy((program_parameters)); });
    return api_error_result;
Paul Fultz II's avatar
Paul Fultz II committed
1317
1318
}

1319
1320
1321
1322
1323
1324
1325
1326
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
1327
1328
1329
extern "C" migraphx_status
migraphx_program_parameters_create(migraphx_program_parameters_t* program_parameters)
{
1330
    auto api_error_result = migraphx::try_([&] {
Paul Fultz II's avatar
Paul Fultz II committed
1331
1332
1333
        *program_parameters = object_cast<migraphx_program_parameters_t>(
            allocate<std::unordered_map<std::string, migraphx::argument>>());
    });
1334
    return api_error_result;
Paul Fultz II's avatar
Paul Fultz II committed
1335
1336
1337
1338
1339
1340
1341
}

extern "C" migraphx_status
migraphx_program_parameters_add(migraphx_program_parameters_t program_parameters,
                                const char* name,
                                const_migraphx_argument_t argument)
{
1342
    auto api_error_result = migraphx::try_([&] {
Paul Fultz II's avatar
Paul Fultz II committed
1343
1344
1345
1346
1347
1348
1349
        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);
    });
1350
    return api_error_result;
Paul Fultz II's avatar
Paul Fultz II committed
1351
1352
1353
1354
}

extern "C" migraphx_status migraphx_arguments_destroy(migraphx_arguments_t arguments)
{
1355
1356
    auto api_error_result = migraphx::try_([&] { destroy((arguments)); });
    return api_error_result;
Paul Fultz II's avatar
Paul Fultz II committed
1357
1358
}

1359
1360
1361
1362
1363
1364
1365
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
1366
1367
extern "C" migraphx_status migraphx_arguments_size(size_t* out, migraphx_arguments_t arguments)
{
1368
    auto api_error_result = migraphx::try_([&] {
Paul Fultz II's avatar
Paul Fultz II committed
1369
1370
1371
1372
        if(arguments == nullptr)
            MIGRAPHX_THROW(migraphx_status_bad_param, "Bad parameter arguments: Null pointer");
        *out = (arguments->object).size();
    });
1373
    return api_error_result;
Paul Fultz II's avatar
Paul Fultz II committed
1374
1375
1376
1377
1378
}

extern "C" migraphx_status
migraphx_arguments_get(const_migraphx_argument_t* out, migraphx_arguments_t arguments, size_t idx)
{
1379
    auto api_error_result = migraphx::try_([&] {
Paul Fultz II's avatar
Paul Fultz II committed
1380
1381
1382
1383
        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))));
    });
1384
    return api_error_result;
Paul Fultz II's avatar
Paul Fultz II committed
1385
1386
1387
1388
}

extern "C" migraphx_status migraphx_shapes_destroy(migraphx_shapes_t shapes)
{
1389
1390
    auto api_error_result = migraphx::try_([&] { destroy((shapes)); });
    return api_error_result;
Paul Fultz II's avatar
Paul Fultz II committed
1391
1392
}

1393
1394
1395
1396
1397
1398
1399
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
1400
1401
extern "C" migraphx_status migraphx_shapes_size(size_t* out, migraphx_shapes_t shapes)
{
1402
    auto api_error_result = migraphx::try_([&] {
Paul Fultz II's avatar
Paul Fultz II committed
1403
1404
1405
1406
        if(shapes == nullptr)
            MIGRAPHX_THROW(migraphx_status_bad_param, "Bad parameter shapes: Null pointer");
        *out = (shapes->object).size();
    });
1407
    return api_error_result;
Paul Fultz II's avatar
Paul Fultz II committed
1408
1409
1410
1411
1412
}

extern "C" migraphx_status
migraphx_shapes_get(const_migraphx_shape_t* out, migraphx_shapes_t shapes, size_t idx)
{
1413
    auto api_error_result = migraphx::try_([&] {
Paul Fultz II's avatar
Paul Fultz II committed
1414
1415
1416
1417
        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))));
    });
1418
    return api_error_result;
Paul Fultz II's avatar
Paul Fultz II committed
1419
1420
}

1421
1422
1423
1424
1425
1426
1427
1428
1429
1430
1431
1432
1433
1434
1435
1436
1437
1438
1439
1440
1441
1442
1443
1444
1445
1446
1447
extern "C" migraphx_status migraphx_instruction_destroy(migraphx_instruction_t instruction)
{
    auto api_error_result = migraphx::try_([&] { destroy((instruction)); });
    return api_error_result;
}

extern "C" migraphx_status migraphx_instruction_assign_to(migraphx_instruction_t output,
                                                          const_migraphx_instruction_t input)
{
    auto api_error_result = migraphx::try_([&] { *output = *input; });
    return api_error_result;
}

extern "C" migraphx_status migraphx_instructions_destroy(migraphx_instructions_t instructions)
{
    auto api_error_result = migraphx::try_([&] { destroy((instructions)); });
    return api_error_result;
}

extern "C" migraphx_status migraphx_instructions_assign_to(migraphx_instructions_t output,
                                                           const_migraphx_instructions_t input)
{
    auto api_error_result = migraphx::try_([&] { *output = *input; });
    return api_error_result;
}

extern "C" migraphx_status migraphx_instructions_create(migraphx_instructions_t* instructions,
1448
                                                        const const_migraphx_instruction_t* ptr,
1449
1450
1451
1452
1453
1454
1455
1456
1457
1458
1459
1460
1461
1462
1463
1464
1465
1466
1467
1468
1469
1470
1471
1472
1473
1474
1475
1476
1477
1478
1479
1480
1481
1482
1483
1484
1485
1486
1487
1488
1489
1490
1491
                                                        size_t size)
{
    auto api_error_result = migraphx::try_([&] {
        *instructions =
            object_cast<migraphx_instructions_t>(allocate<std::vector<migraphx::instruction_ref>>(
                migraphx::to_obj_vector<const_migraphx_instruction_t>((ptr), (size))));
    });
    return api_error_result;
}

extern "C" migraphx_status migraphx_modules_destroy(migraphx_modules_t modules)
{
    auto api_error_result = migraphx::try_([&] { destroy((modules)); });
    return api_error_result;
}

extern "C" migraphx_status migraphx_modules_assign_to(migraphx_modules_t output,
                                                      const_migraphx_modules_t input)
{
    auto api_error_result = migraphx::try_([&] { *output = *input; });
    return api_error_result;
}

extern "C" migraphx_status
migraphx_modules_create(migraphx_modules_t* modules, migraphx_module_t* ptr, size_t size)
{
    auto api_error_result = migraphx::try_([&] {
        *modules = object_cast<migraphx_modules_t>(allocate<std::vector<migraphx::module*>>(
            migraphx::to_objptr_vector<migraphx::module*>((ptr), (size))));
    });
    return api_error_result;
}

extern "C" migraphx_status migraphx_module_create(migraphx_module_t* module, char* name)
{
    auto api_error_result = migraphx::try_([&] {
        if(name == nullptr)
            MIGRAPHX_THROW(migraphx_status_bad_param, "Bad parameter name: Null pointer");
        *module = object_cast<migraphx_module_t>(allocate<migraphx::module>((std::string(name))));
    });
    return api_error_result;
}

Shucai Xiao's avatar
Shucai Xiao committed
1492
1493
extern "C" migraphx_status migraphx_module_print(const_migraphx_module_t module)
{
1494
    auto api_error_result = migraphx::try_([&] {
Shucai Xiao's avatar
Shucai Xiao committed
1495
1496
1497
1498
        if(module == nullptr)
            MIGRAPHX_THROW(migraphx_status_bad_param, "Bad parameter module: Null pointer");
        migraphx::print_module((module->object));
    });
1499
    return api_error_result;
Shucai Xiao's avatar
Shucai Xiao committed
1500
1501
}

1502
1503
1504
1505
1506
1507
1508
1509
1510
1511
1512
1513
1514
1515
1516
1517
1518
1519
1520
1521
1522
1523
1524
1525
1526
1527
1528
1529
1530
1531
1532
1533
1534
1535
1536
1537
1538
1539
1540
1541
extern "C" migraphx_status migraphx_module_add_instruction(migraphx_instruction_t* out,
                                                           migraphx_module_t module,
                                                           migraphx_operation_t op,
                                                           migraphx_instructions_t args)
{
    auto api_error_result = migraphx::try_([&] {
        if(module == nullptr)
            MIGRAPHX_THROW(migraphx_status_bad_param, "Bad parameter module: Null pointer");
        if(op == nullptr)
            MIGRAPHX_THROW(migraphx_status_bad_param, "Bad parameter op: Null pointer");
        if(args == nullptr)
            MIGRAPHX_THROW(migraphx_status_bad_param, "Bad parameter args: Null pointer");
        *out = allocate<migraphx_instruction_t>(
            (module->object).add_instruction((op->object), (args->object)));
    });
    return api_error_result;
}

extern "C" migraphx_status
migraphx_module_add_instruction_with_mod_args(migraphx_instruction_t* out,
                                              migraphx_module_t module,
                                              migraphx_operation_t op,
                                              migraphx_instructions_t args,
                                              migraphx_modules_t module_refs)
{
    auto api_error_result = migraphx::try_([&] {
        if(module == nullptr)
            MIGRAPHX_THROW(migraphx_status_bad_param, "Bad parameter module: Null pointer");
        if(op == nullptr)
            MIGRAPHX_THROW(migraphx_status_bad_param, "Bad parameter op: Null pointer");
        if(args == nullptr)
            MIGRAPHX_THROW(migraphx_status_bad_param, "Bad parameter args: Null pointer");
        if(module_refs == nullptr)
            MIGRAPHX_THROW(migraphx_status_bad_param, "Bad parameter module_refs: Null pointer");
        *out = allocate<migraphx_instruction_t>(
            (module->object).add_instruction((op->object), (args->object), (module_refs->object)));
    });
    return api_error_result;
}

1542
1543
1544
1545
1546
1547
1548
1549
1550
1551
1552
1553
1554
1555
1556
1557
extern "C" migraphx_status migraphx_module_add_literal(migraphx_instruction_t* out,
                                                       migraphx_module_t module,
                                                       const_migraphx_shape_t shape,
                                                       const char* buffer)
{
    auto api_error_result = migraphx::try_([&] {
        if(module == nullptr)
            MIGRAPHX_THROW(migraphx_status_bad_param, "Bad parameter module: Null pointer");
        if(shape == nullptr)
            MIGRAPHX_THROW(migraphx_status_bad_param, "Bad parameter shape: Null pointer");
        *out = allocate<migraphx_instruction_t>(
            (module->object).add_literal((shape->object), (buffer)));
    });
    return api_error_result;
}

1558
1559
1560
1561
1562
1563
1564
1565
1566
1567
1568
1569
1570
1571
1572
1573
1574
1575
1576
1577
1578
1579
1580
1581
1582
1583
1584
1585
1586
1587
extern "C" migraphx_status migraphx_module_add_parameter(migraphx_instruction_t* out,
                                                         migraphx_module_t module,
                                                         const char* name,
                                                         const_migraphx_shape_t shape)
{
    auto api_error_result = migraphx::try_([&] {
        if(module == nullptr)
            MIGRAPHX_THROW(migraphx_status_bad_param, "Bad parameter module: Null pointer");
        if(shape == nullptr)
            MIGRAPHX_THROW(migraphx_status_bad_param, "Bad parameter shape: Null pointer");
        *out = allocate<migraphx_instruction_t>(
            (module->object).add_parameter((name), (shape->object)));
    });
    return api_error_result;
}

extern "C" migraphx_status migraphx_module_add_return(migraphx_instruction_t* out,
                                                      migraphx_module_t module,
                                                      migraphx_instructions_t args)
{
    auto api_error_result = migraphx::try_([&] {
        if(module == nullptr)
            MIGRAPHX_THROW(migraphx_status_bad_param, "Bad parameter module: Null pointer");
        if(args == nullptr)
            MIGRAPHX_THROW(migraphx_status_bad_param, "Bad parameter args: Null pointer");
        *out = allocate<migraphx_instruction_t>((module->object).add_return((args->object)));
    });
    return api_error_result;
}

1588
1589
1590
1591
1592
1593
1594
1595
1596
1597
1598
1599
1600
1601
1602
extern "C" migraphx_status migraphx_module_add_allocation(migraphx_instruction_t* out,
                                                          migraphx_module_t module,
                                                          const_migraphx_shape_t s)
{
    auto api_error_result = migraphx::try_([&] {
        if(module == nullptr)
            MIGRAPHX_THROW(migraphx_status_bad_param, "Bad parameter module: Null pointer");
        if(s == nullptr)
            MIGRAPHX_THROW(migraphx_status_bad_param, "Bad parameter s: Null pointer");
        *out = allocate<migraphx_instruction_t>(
            migraphx::add_allocation((module->object), (s->object)));
    });
    return api_error_result;
}

Paul Fultz II's avatar
Paul Fultz II committed
1603
1604
extern "C" migraphx_status migraphx_program_destroy(migraphx_program_t program)
{
1605
1606
    auto api_error_result = migraphx::try_([&] { destroy((program)); });
    return api_error_result;
Paul Fultz II's avatar
Paul Fultz II committed
1607
1608
}

1609
1610
1611
1612
1613
1614
1615
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;
}

1616
1617
1618
1619
1620
1621
1622
extern "C" migraphx_status migraphx_program_create(migraphx_program_t* program)
{
    auto api_error_result = migraphx::try_(
        [&] { *program = object_cast<migraphx_program_t>(allocate<migraphx::program>()); });
    return api_error_result;
}

Shucai Xiao's avatar
Shucai Xiao committed
1623
1624
1625
extern "C" migraphx_status migraphx_program_get_main_module(migraphx_module_t* out,
                                                            migraphx_program_t program)
{
1626
    auto api_error_result = migraphx::try_([&] {
Shucai Xiao's avatar
Shucai Xiao committed
1627
1628
1629
1630
        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());
    });
1631
    return api_error_result;
Shucai Xiao's avatar
Shucai Xiao committed
1632
1633
}

1634
1635
1636
1637
1638
1639
1640
1641
1642
1643
1644
extern "C" migraphx_status
migraphx_program_create_module(migraphx_module_t* out, migraphx_program_t program, const char* name)
{
    auto api_error_result = migraphx::try_([&] {
        if(program == nullptr)
            MIGRAPHX_THROW(migraphx_status_bad_param, "Bad parameter program: Null pointer");
        *out = object_cast<migraphx_module_t>((program->object).create_module((name)));
    });
    return api_error_result;
}

Paul Fultz II's avatar
Paul Fultz II committed
1645
1646
extern "C" migraphx_status migraphx_program_compile(migraphx_program_t program,
                                                    migraphx_target_t target,
1647
                                                    migraphx_compile_options_t options)
Paul Fultz II's avatar
Paul Fultz II committed
1648
{
1649
    auto api_error_result = migraphx::try_([&] {
Paul Fultz II's avatar
Paul Fultz II committed
1650
1651
1652
1653
        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");
1654
1655
1656
        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
1657
    });
1658
    return api_error_result;
Paul Fultz II's avatar
Paul Fultz II committed
1659
1660
1661
1662
1663
1664
}

extern "C" migraphx_status
migraphx_program_get_parameter_shapes(migraphx_program_parameter_shapes_t* out,
                                      migraphx_program_t program)
{
1665
    auto api_error_result = migraphx::try_([&] {
Paul Fultz II's avatar
Paul Fultz II committed
1666
1667
1668
1669
1670
        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());
    });
1671
    return api_error_result;
Paul Fultz II's avatar
Paul Fultz II committed
1672
1673
1674
1675
1676
}

extern "C" migraphx_status migraphx_program_get_output_shapes(migraphx_shapes_t* out,
                                                              migraphx_program_t program)
{
1677
    auto api_error_result = migraphx::try_([&] {
Paul Fultz II's avatar
Paul Fultz II committed
1678
1679
1680
1681
        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)));
    });
1682
    return api_error_result;
Paul Fultz II's avatar
Paul Fultz II committed
1683
1684
1685
1686
}

extern "C" migraphx_status migraphx_program_print(const_migraphx_program_t program)
{
1687
    auto api_error_result = migraphx::try_([&] {
Paul Fultz II's avatar
Paul Fultz II committed
1688
1689
        if(program == nullptr)
            MIGRAPHX_THROW(migraphx_status_bad_param, "Bad parameter program: Null pointer");
Shucai Xiao's avatar
Shucai Xiao committed
1690
        migraphx::print_program((program->object));
Paul Fultz II's avatar
Paul Fultz II committed
1691
    });
1692
    return api_error_result;
Paul Fultz II's avatar
Paul Fultz II committed
1693
1694
}

1695
1696
extern "C" migraphx_status migraphx_program_sort(migraphx_program_t program)
{
1697
    auto api_error_result = migraphx::try_([&] {
1698
1699
1700
1701
        if(program == nullptr)
            MIGRAPHX_THROW(migraphx_status_bad_param, "Bad parameter program: Null pointer");
        (program->object).sort();
    });
1702
    return api_error_result;
1703
1704
}

Paul Fultz II's avatar
Paul Fultz II committed
1705
1706
1707
1708
extern "C" migraphx_status migraphx_program_run(migraphx_arguments_t* out,
                                                migraphx_program_t program,
                                                migraphx_program_parameters_t params)
{
1709
    auto api_error_result = migraphx::try_([&] {
Paul Fultz II's avatar
Paul Fultz II committed
1710
1711
1712
1713
1714
1715
        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)));
    });
1716
    return api_error_result;
Paul Fultz II's avatar
Paul Fultz II committed
1717
1718
}

1719
1720
1721
1722
1723
1724
1725
1726
1727
1728
1729
1730
1731
1732
1733
1734
1735
extern "C" migraphx_status migraphx_program_run_async(migraphx_arguments_t* out,
                                                      migraphx_program_t program,
                                                      migraphx_program_parameters_t params,
                                                      void* s,
                                                      const char* name)
{
    auto api_error_result = migraphx::try_([&] {
        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_async((program->object), (params->object), (s), (name)));
    });
    return api_error_result;
}

Paul Fultz II's avatar
Paul Fultz II committed
1736
1737
1738
extern "C" migraphx_status
migraphx_program_equal(bool* out, const_migraphx_program_t program, const_migraphx_program_t x)
{
1739
    auto api_error_result = migraphx::try_([&] {
Paul Fultz II's avatar
Paul Fultz II committed
1740
1741
1742
1743
1744
1745
        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));
    });
1746
    return api_error_result;
Paul Fultz II's avatar
Paul Fultz II committed
1747
1748
}

1749
1750
extern "C" migraphx_status
migraphx_program_experimental_get_context(migraphx_context_t* out, const_migraphx_program_t program)
kahmed10's avatar
kahmed10 committed
1751
1752
1753
1754
1755
1756
1757
1758
1759
{
    auto api_error_result = migraphx::try_([&] {
        if(program == nullptr)
            MIGRAPHX_THROW(migraphx_status_bad_param, "Bad parameter program: Null pointer");
        *out = allocate<migraphx_context_t>(migraphx::get_context((program->object)));
    });
    return api_error_result;
}

1760
1761
extern "C" migraphx_status migraphx_operation_destroy(migraphx_operation_t operation)
{
1762
1763
    auto api_error_result = migraphx::try_([&] { destroy((operation)); });
    return api_error_result;
1764
1765
}

1766
1767
1768
1769
1770
1771
1772
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;
}

1773
1774
1775
1776
extern "C" migraphx_status migraphx_operation_create(migraphx_operation_t* operation,
                                                     const char* name,
                                                     const char* attributes,
                                                     ...)
1777
{
1778
1779
1780
    va_list vlist;
    va_start(vlist, attributes);
    auto api_error_result = migraphx::try_([&] {
1781
        *operation = object_cast<migraphx_operation_t>(
1782
            allocate<migraphx::operation>(migraphx::create_op((name), (attributes), (vlist))));
1783
    });
1784
1785
    va_end(vlist);
    return api_error_result;
1786
1787
1788
1789
1790
}

extern "C" migraphx_status
migraphx_operation_name(char* out, size_t out_size, migraphx_operation_t operation)
{
1791
    auto api_error_result = migraphx::try_([&] {
1792
1793
1794
1795
1796
1797
1798
1799
        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();
        auto* it = std::copy_n(api_result.begin(), std::min(api_result.size(), out_size - 1), out);
        *it      = '\0';
    });
1800
    return api_error_result;
1801
1802
}

1803
extern "C" migraphx_status
1804
migraphx_load(migraphx_program_t* out, const char* name, migraphx_file_options_t options)
1805
{
1806
    auto api_error_result = migraphx::try_([&] {
1807
1808
1809
        if(options == nullptr)
            MIGRAPHX_THROW(migraphx_status_bad_param, "Bad parameter options: Null pointer");
        *out = allocate<migraphx_program_t>(migraphx::load((name), (options->object)));
1810
    });
1811
    return api_error_result;
1812
1813
1814
}

extern "C" migraphx_status
1815
migraphx_save(migraphx_program_t p, const char* name, migraphx_file_options_t options)
1816
{
1817
    auto api_error_result = migraphx::try_([&] {
1818
1819
        if(p == nullptr)
            MIGRAPHX_THROW(migraphx_status_bad_param, "Bad parameter p: Null pointer");
1820
1821
1822
        if(options == nullptr)
            MIGRAPHX_THROW(migraphx_status_bad_param, "Bad parameter options: Null pointer");
        migraphx::save((p->object), (name), (options->object));
1823
    });
1824
    return api_error_result;
1825
1826
}

1827
1828
extern "C" migraphx_status migraphx_onnx_options_destroy(migraphx_onnx_options_t onnx_options)
{
1829
1830
    auto api_error_result = migraphx::try_([&] { destroy((onnx_options)); });
    return api_error_result;
1831
1832
}

1833
1834
1835
1836
1837
1838
1839
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;
}

1840
1841
extern "C" migraphx_status migraphx_onnx_options_create(migraphx_onnx_options_t* onnx_options)
{
1842
    auto api_error_result = migraphx::try_([&] {
1843
1844
        *onnx_options = object_cast<migraphx_onnx_options_t>(allocate<migraphx::onnx_options>());
    });
1845
    return api_error_result;
1846
1847
}

1848
1849
extern "C" migraphx_status migraphx_onnx_options_set_input_parameter_shape(
    migraphx_onnx_options_t onnx_options, const char* name, size_t* dims, size_t dims_size)
1850
{
1851
    auto api_error_result = migraphx::try_([&] {
1852
1853
        if(onnx_options == nullptr)
            MIGRAPHX_THROW(migraphx_status_bad_param, "Bad parameter onnx_options: Null pointer");
1854
1855
1856
1857
        if(dims == nullptr and dims_size != 0)
            MIGRAPHX_THROW(migraphx_status_bad_param, "Bad parameter dims: Null pointer");
        migraphx::set_input_parameter_shape(
            (onnx_options->object), (name), (std::vector<size_t>(dims, dims + dims_size)));
1858
    });
1859
    return api_error_result;
1860
1861
}

1862
1863
1864
1865
1866
1867
1868
1869
1870
1871
1872
1873
1874
extern "C" migraphx_status migraphx_onnx_options_set_dyn_input_parameter_shape(
    migraphx_onnx_options_t onnx_options, const char* name, migraphx_dynamic_dimensions_t dims)
{
    auto api_error_result = migraphx::try_([&] {
        if(onnx_options == nullptr)
            MIGRAPHX_THROW(migraphx_status_bad_param, "Bad parameter onnx_options: Null pointer");
        if(dims == nullptr)
            MIGRAPHX_THROW(migraphx_status_bad_param, "Bad parameter dims: Null pointer");
        migraphx::set_dyn_input_parameter_shape((onnx_options->object), (name), (dims->object));
    });
    return api_error_result;
}

1875
1876
1877
extern "C" migraphx_status
migraphx_onnx_options_set_default_dim_value(migraphx_onnx_options_t onnx_options, size_t value)
{
1878
    auto api_error_result = migraphx::try_([&] {
1879
1880
1881
1882
        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));
    });
1883
    return api_error_result;
1884
1885
}

1886
1887
1888
1889
1890
1891
1892
1893
1894
1895
1896
1897
1898
1899
extern "C" migraphx_status
migraphx_onnx_options_set_default_dyn_dim_value(migraphx_onnx_options_t onnx_options,
                                                const_migraphx_dynamic_dimension_t dd)
{
    auto api_error_result = migraphx::try_([&] {
        if(onnx_options == nullptr)
            MIGRAPHX_THROW(migraphx_status_bad_param, "Bad parameter onnx_options: Null pointer");
        if(dd == nullptr)
            MIGRAPHX_THROW(migraphx_status_bad_param, "Bad parameter dd: Null pointer");
        migraphx::set_default_dyn_dim_value((onnx_options->object), (dd->object));
    });
    return api_error_result;
}

1900
1901
1902
1903
extern "C" migraphx_status
migraphx_onnx_options_set_default_loop_iterations(migraphx_onnx_options_t onnx_options,
                                                  int64_t value)
{
1904
    auto api_error_result = migraphx::try_([&] {
1905
1906
1907
1908
        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));
    });
1909
    return api_error_result;
1910
1911
}

1912
1913
1914
1915
1916
1917
1918
1919
1920
1921
1922
extern "C" migraphx_status
migraphx_onnx_options_set_limit_loop_iterations(migraphx_onnx_options_t onnx_options, int64_t value)
{
    auto api_error_result = migraphx::try_([&] {
        if(onnx_options == nullptr)
            MIGRAPHX_THROW(migraphx_status_bad_param, "Bad parameter onnx_options: Null pointer");
        migraphx::set_limit_loop_iterations((onnx_options->object), (value));
    });
    return api_error_result;
}

1923
1924
extern "C" migraphx_status migraphx_file_options_destroy(migraphx_file_options_t file_options)
{
1925
1926
    auto api_error_result = migraphx::try_([&] { destroy((file_options)); });
    return api_error_result;
1927
1928
}

1929
1930
1931
1932
1933
1934
1935
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;
}

1936
1937
extern "C" migraphx_status migraphx_file_options_create(migraphx_file_options_t* file_options)
{
1938
    auto api_error_result = migraphx::try_([&] {
1939
1940
        *file_options = object_cast<migraphx_file_options_t>(allocate<migraphx::file_options>());
    });
1941
    return api_error_result;
1942
1943
1944
1945
1946
}

extern "C" migraphx_status
migraphx_file_options_set_file_format(migraphx_file_options_t file_options, const char* format)
{
1947
    auto api_error_result = migraphx::try_([&] {
1948
1949
1950
1951
        if(file_options == nullptr)
            MIGRAPHX_THROW(migraphx_status_bad_param, "Bad parameter file_options: Null pointer");
        migraphx::set_file_format((file_options->object), (format));
    });
1952
    return api_error_result;
1953
1954
}

Shucai Xiao's avatar
Shucai Xiao committed
1955
extern "C" migraphx_status
1956
1957
migraphx_compile_options_destroy(migraphx_compile_options_t compile_options)
{
1958
1959
    auto api_error_result = migraphx::try_([&] { destroy((compile_options)); });
    return api_error_result;
1960
1961
}

1962
1963
1964
1965
1966
1967
1968
1969
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;
}

1970
1971
extern "C" migraphx_status
migraphx_compile_options_create(migraphx_compile_options_t* compile_options)
Shucai Xiao's avatar
Shucai Xiao committed
1972
{
1973
    auto api_error_result = migraphx::try_([&] {
1974
1975
1976
        *compile_options =
            object_cast<migraphx_compile_options_t>(allocate<migraphx::compile_options>());
    });
1977
    return api_error_result;
1978
1979
1980
1981
1982
}

extern "C" migraphx_status
migraphx_compile_options_set_offload_copy(migraphx_compile_options_t compile_options, bool value)
{
1983
    auto api_error_result = migraphx::try_([&] {
1984
1985
1986
1987
1988
        if(compile_options == nullptr)
            MIGRAPHX_THROW(migraphx_status_bad_param,
                           "Bad parameter compile_options: Null pointer");
        migraphx::set_offload_copy((compile_options->object), (value));
    });
1989
    return api_error_result;
1990
1991
1992
1993
1994
}

extern "C" migraphx_status
migraphx_compile_options_set_fast_math(migraphx_compile_options_t compile_options, bool value)
{
1995
    auto api_error_result = migraphx::try_([&] {
1996
1997
1998
1999
        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
2000
    });
2001
    return api_error_result;
2002
2003
2004
2005
2006
2007
2008
2009
2010
2011
2012
2013
2014
}

extern "C" migraphx_status
migraphx_compile_options_set_exhaustive_tune_flag(migraphx_compile_options_t compile_options,
                                                  bool value)
{
    auto api_error_result = migraphx::try_([&] {
        if(compile_options == nullptr)
            MIGRAPHX_THROW(migraphx_status_bad_param,
                           "Bad parameter compile_options: Null pointer");
        migraphx::set_exhaustive_tune_flag((compile_options->object), (value));
    });
    return api_error_result;
Shucai Xiao's avatar
Shucai Xiao committed
2015
2016
}

Paul Fultz II's avatar
Paul Fultz II committed
2017
extern "C" migraphx_status
2018
migraphx_parse_onnx(migraphx_program_t* out, const char* name, migraphx_onnx_options_t options)
Paul Fultz II's avatar
Paul Fultz II committed
2019
{
2020
    auto api_error_result = migraphx::try_([&] {
2021
2022
2023
        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
2024
    });
2025
    return api_error_result;
Paul Fultz II's avatar
Paul Fultz II committed
2026
2027
2028
2029
2030
}

extern "C" migraphx_status migraphx_parse_onnx_buffer(migraphx_program_t* out,
                                                      const void* data,
                                                      size_t size,
2031
                                                      migraphx_onnx_options_t options)
Paul Fultz II's avatar
Paul Fultz II committed
2032
{
2033
    auto api_error_result = migraphx::try_([&] {
2034
2035
2036
2037
        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
2038
    });
2039
    return api_error_result;
Paul Fultz II's avatar
Paul Fultz II committed
2040
}
Shucai Xiao's avatar
Shucai Xiao committed
2041

kahmed10's avatar
kahmed10 committed
2042
2043
extern "C" migraphx_status migraphx_tf_options_destroy(migraphx_tf_options_t tf_options)
{
2044
2045
    auto api_error_result = migraphx::try_([&] { destroy((tf_options)); });
    return api_error_result;
kahmed10's avatar
kahmed10 committed
2046
2047
}

2048
2049
2050
2051
2052
2053
2054
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
2055
2056
extern "C" migraphx_status migraphx_tf_options_create(migraphx_tf_options_t* tf_options)
{
2057
    auto api_error_result = migraphx::try_([&] {
kahmed10's avatar
kahmed10 committed
2058
2059
        *tf_options = object_cast<migraphx_tf_options_t>(allocate<migraphx::tf_options>());
    });
2060
    return api_error_result;
kahmed10's avatar
kahmed10 committed
2061
2062
2063
2064
2065
}

extern "C" migraphx_status migraphx_tf_options_set_nhwc(migraphx_tf_options_t tf_options,
                                                        bool is_nhwc)
{
2066
    auto api_error_result = migraphx::try_([&] {
kahmed10's avatar
kahmed10 committed
2067
2068
2069
2070
        if(tf_options == nullptr)
            MIGRAPHX_THROW(migraphx_status_bad_param, "Bad parameter tf_options: Null pointer");
        migraphx::set_nhwc((tf_options->object), (is_nhwc));
    });
2071
    return api_error_result;
kahmed10's avatar
kahmed10 committed
2072
2073
2074
2075
2076
}

extern "C" migraphx_status migraphx_tf_options_set_input_parameter_shape(
    migraphx_tf_options_t tf_options, const char* name, size_t* dims, size_t dims_size)
{
2077
    auto api_error_result = migraphx::try_([&] {
kahmed10's avatar
kahmed10 committed
2078
2079
2080
2081
2082
2083
2084
        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(
            (tf_options->object), (name), (std::vector<size_t>(dims, dims + dims_size)));
    });
2085
    return api_error_result;
kahmed10's avatar
kahmed10 committed
2086
2087
2088
2089
2090
}

extern "C" migraphx_status
migraphx_tf_options_set_default_dim_value(migraphx_tf_options_t tf_options, size_t value)
{
2091
    auto api_error_result = migraphx::try_([&] {
kahmed10's avatar
kahmed10 committed
2092
2093
2094
2095
        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));
    });
2096
    return api_error_result;
kahmed10's avatar
kahmed10 committed
2097
2098
2099
2100
2101
2102
}

extern "C" migraphx_status migraphx_tf_options_set_output_names(migraphx_tf_options_t tf_options,
                                                                const char** names,
                                                                size_t names_size)
{
2103
    auto api_error_result = migraphx::try_([&] {
kahmed10's avatar
kahmed10 committed
2104
2105
2106
2107
2108
2109
2110
        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)));
    });
2111
    return api_error_result;
kahmed10's avatar
kahmed10 committed
2112
2113
2114
2115
2116
}

extern "C" migraphx_status
migraphx_parse_tf(migraphx_program_t* out, const char* name, migraphx_tf_options_t options)
{
2117
    auto api_error_result = migraphx::try_([&] {
kahmed10's avatar
kahmed10 committed
2118
2119
2120
2121
        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)));
    });
2122
    return api_error_result;
kahmed10's avatar
kahmed10 committed
2123
2124
}

Shucai Xiao's avatar
Shucai Xiao committed
2125
2126
2127
extern "C" migraphx_status
migraphx_quantize_op_names_destroy(migraphx_quantize_op_names_t quantize_op_names)
{
2128
2129
    auto api_error_result = migraphx::try_([&] { destroy((quantize_op_names)); });
    return api_error_result;
Shucai Xiao's avatar
Shucai Xiao committed
2130
2131
}

2132
2133
2134
2135
2136
2137
2138
2139
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
2140
2141
2142
extern "C" migraphx_status
migraphx_quantize_op_names_create(migraphx_quantize_op_names_t* quantize_op_names)
{
2143
    auto api_error_result = migraphx::try_([&] {
Shucai Xiao's avatar
Shucai Xiao committed
2144
2145
2146
        *quantize_op_names =
            object_cast<migraphx_quantize_op_names_t>(allocate<std::vector<std::string>>());
    });
2147
    return api_error_result;
Shucai Xiao's avatar
Shucai Xiao committed
2148
2149
2150
2151
2152
}

extern "C" migraphx_status
migraphx_quantize_op_names_add(migraphx_quantize_op_names_t quantize_op_names, const char* name)
{
2153
    auto api_error_result = migraphx::try_([&] {
Shucai Xiao's avatar
Shucai Xiao committed
2154
2155
2156
2157
2158
        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));
    });
2159
    return api_error_result;
Shucai Xiao's avatar
Shucai Xiao committed
2160
2161
2162
2163
2164
}

extern "C" migraphx_status migraphx_quantize_fp16_with_op_names(migraphx_program_t prog,
                                                                migraphx_quantize_op_names_t name)
{
2165
    auto api_error_result = migraphx::try_([&] {
Shucai Xiao's avatar
Shucai Xiao committed
2166
2167
2168
2169
2170
2171
        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));
    });
2172
    return api_error_result;
Shucai Xiao's avatar
Shucai Xiao committed
2173
2174
2175
2176
}

extern "C" migraphx_status migraphx_quantize_fp16(migraphx_program_t prog)
{
2177
    auto api_error_result = migraphx::try_([&] {
Shucai Xiao's avatar
Shucai Xiao committed
2178
2179
2180
2181
        if(prog == nullptr)
            MIGRAPHX_THROW(migraphx_status_bad_param, "Bad parameter prog: Null pointer");
        migraphx::quantize_fp16((prog->object));
    });
2182
    return api_error_result;
Shucai Xiao's avatar
Shucai Xiao committed
2183
2184
2185
2186
2187
}

extern "C" migraphx_status
migraphx_quantize_int8_options_destroy(migraphx_quantize_int8_options_t quantize_int8_options)
{
2188
2189
    auto api_error_result = migraphx::try_([&] { destroy((quantize_int8_options)); });
    return api_error_result;
Shucai Xiao's avatar
Shucai Xiao committed
2190
2191
}

2192
2193
2194
2195
2196
2197
2198
2199
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
2200
2201
2202
extern "C" migraphx_status
migraphx_quantize_int8_options_create(migraphx_quantize_int8_options_t* quantize_int8_options)
{
2203
    auto api_error_result = migraphx::try_([&] {
Shucai Xiao's avatar
Shucai Xiao committed
2204
2205
2206
        *quantize_int8_options = object_cast<migraphx_quantize_int8_options_t>(
            allocate<migraphx::quantize_int8_options>());
    });
2207
    return api_error_result;
Shucai Xiao's avatar
Shucai Xiao committed
2208
2209
2210
2211
2212
2213
}

extern "C" migraphx_status
migraphx_quantize_int8_options_add_op_name(migraphx_quantize_int8_options_t quantize_int8_options,
                                           const char* name)
{
2214
    auto api_error_result = migraphx::try_([&] {
Shucai Xiao's avatar
Shucai Xiao committed
2215
2216
2217
2218
2219
        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));
    });
2220
    return api_error_result;
Shucai Xiao's avatar
Shucai Xiao committed
2221
2222
2223
2224
2225
}

extern "C" migraphx_status migraphx_quantize_int8_options_add_calibration_data(
    migraphx_quantize_int8_options_t quantize_int8_options, migraphx_program_parameters_t data)
{
2226
    auto api_error_result = migraphx::try_([&] {
Shucai Xiao's avatar
Shucai Xiao committed
2227
2228
2229
2230
2231
2232
2233
        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));
    });
2234
    return api_error_result;
Shucai Xiao's avatar
Shucai Xiao committed
2235
2236
2237
2238
2239
2240
}

extern "C" migraphx_status migraphx_quantize_int8(migraphx_program_t prog,
                                                  migraphx_target_t target,
                                                  migraphx_quantize_int8_options_t options)
{
2241
    auto api_error_result = migraphx::try_([&] {
Shucai Xiao's avatar
Shucai Xiao committed
2242
2243
2244
2245
2246
2247
2248
2249
        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));
    });
2250
    return api_error_result;
Shucai Xiao's avatar
Shucai Xiao committed
2251
}
kahmed10's avatar
kahmed10 committed
2252
2253
2254
2255
2256
2257
2258
2259
2260
2261

extern "C" migraphx_status migraphx_context_finish(const_migraphx_context_t context)
{
    auto api_error_result = migraphx::try_([&] {
        if(context == nullptr)
            MIGRAPHX_THROW(migraphx_status_bad_param, "Bad parameter context: Null pointer");
        (context->object).finish();
    });
    return api_error_result;
}
2262

2263
2264
2265
2266
2267
2268
2269
2270
2271
2272
extern "C" migraphx_status migraphx_context_get_queue(void** out, migraphx_context_t context)
{
    auto api_error_result = migraphx::try_([&] {
        if(context == nullptr)
            MIGRAPHX_THROW(migraphx_status_bad_param, "Bad parameter context: Null pointer");
        *out = (context->object).get_queue().unsafe_get();
    });
    return api_error_result;
}

2273
2274
2275
2276
2277
2278
2279
2280
2281
2282
2283
2284
2285
2286
2287
2288
2289
2290
2291
2292
extern "C" migraphx_status
migraphx_experimental_custom_op_destroy(migraphx_experimental_custom_op_t experimental_custom_op)
{
    auto api_error_result = migraphx::try_([&] { destroy((experimental_custom_op)); });
    return api_error_result;
}

extern "C" migraphx_status
migraphx_experimental_custom_op_assign_to(migraphx_experimental_custom_op_t output,
                                          const_migraphx_experimental_custom_op_t input)
{
    auto api_error_result = migraphx::try_([&] { *output = *input; });
    return api_error_result;
}

extern "C" migraphx_status
migraphx_experimental_custom_op_create(migraphx_experimental_custom_op_t* experimental_custom_op,
                                       void* obj,
                                       migraphx_experimental_custom_op_copy c,
                                       migraphx_experimental_custom_op_delete d,
2293
                                       const char* obj_typename,
2294
2295
2296
2297
                                       const char* name)
{
    auto api_error_result = migraphx::try_([&] {
        *experimental_custom_op =
2298
            allocate<migraphx_experimental_custom_op_t>((obj), (c), (d), (obj_typename), (name));
2299
2300
2301
2302
    });
    return api_error_result;
}

2303
2304
2305
2306
2307
2308
2309
2310
extern "C" migraphx_status
migraphx_experimental_custom_op_set_compute(migraphx_experimental_custom_op_t obj,
                                            migraphx_experimental_custom_op_compute input)
{
    auto api_error_result = migraphx::try_([&] { (obj)->compute_f = (input); });
    return api_error_result;
}

2311
2312
2313
2314
2315
2316
2317
extern "C" migraphx_status migraphx_experimental_custom_op_set_compute_shape(
    migraphx_experimental_custom_op_t obj, migraphx_experimental_custom_op_compute_shape input)
{
    auto api_error_result = migraphx::try_([&] { (obj)->compute_shape_f = (input); });
    return api_error_result;
}

2318
2319
2320
2321
2322
2323
2324
2325
2326
2327
2328
2329
2330
2331
2332
2333
extern "C" migraphx_status
migraphx_experimental_custom_op_set_output_alias(migraphx_experimental_custom_op_t obj,
                                                 migraphx_experimental_custom_op_output_alias input)
{
    auto api_error_result = migraphx::try_([&] { (obj)->output_alias_f = (input); });
    return api_error_result;
}

extern "C" migraphx_status migraphx_experimental_custom_op_set_runs_on_offload_target(
    migraphx_experimental_custom_op_t obj,
    migraphx_experimental_custom_op_runs_on_offload_target input)
{
    auto api_error_result = migraphx::try_([&] { (obj)->runs_on_offload_target_f = (input); });
    return api_error_result;
}

2334
2335
2336
2337
2338
2339
2340
2341
2342
2343
2344
extern "C" migraphx_status
migraphx_experimental_custom_op_register(migraphx_experimental_custom_op_t experimental_custom_op)
{
    auto api_error_result = migraphx::try_([&] {
        if(experimental_custom_op == nullptr)
            MIGRAPHX_THROW(migraphx_status_bad_param,
                           "Bad parameter experimental_custom_op: Null pointer");
        migraphx::register_custom_op((*experimental_custom_op));
    });
    return api_error_result;
}