shape.cpp 16.8 KB
Newer Older
Paul's avatar
Paul committed
1

Paul's avatar
Paul committed
2
3
#include <migraphx/shape.hpp>
#include <migraphx/stringutils.hpp>
4
#include <migraphx/serialize.hpp>
5
#include <migraphx/permutation.hpp>
6
#include <migraphx/ranges.hpp>
Paul's avatar
Paul committed
7
8
9
#include <numeric>
#include <algorithm>
#include <functional>
10
#include <unordered_map>
Paul's avatar
Paul committed
11
#include <iostream>
Paul's avatar
Paul committed
12

Paul's avatar
Paul committed
13
namespace migraphx {
Paul's avatar
Paul committed
14
inline namespace MIGRAPHX_INLINE_NS {
Paul's avatar
Paul committed
15

Paul's avatar
Paul committed
16
17
struct shape_impl
{
Paul's avatar
Paul committed
18
19
    static std::shared_ptr<shape_impl> default_shape()
    {
20
        static const std::shared_ptr<shape_impl> result = std::make_shared<shape_impl>();
Paul's avatar
Paul committed
21
22
23
        return result;
    }

Paul Fultz II's avatar
Paul Fultz II committed
24
    shape_impl() : m_type(shape::float_type) {}
Paul's avatar
Paul committed
25

Paul Fultz II's avatar
Paul Fultz II committed
26
27
28
29
    shape_impl(shape::type_t t) : m_type(t), m_lens({1}), m_strides({0}), m_standard(true)
    {
        assert(t != shape::tuple_type);
    }
Paul's avatar
Paul committed
30
31
32
    shape_impl(shape::type_t t, std::vector<std::size_t> l)
        : m_type(t), m_lens(std::move(l)), m_standard(true)
    {
Paul Fultz II's avatar
Paul Fultz II committed
33
        assert(t != shape::tuple_type);
Paul's avatar
Paul committed
34
35
36
37
38
39
        this->calculate_strides();
        assert(m_lens.size() == m_strides.size());
    }
    shape_impl(shape::type_t t, std::vector<std::size_t> l, std::vector<std::size_t> s)
        : m_type(t), m_lens(std::move(l)), m_strides(std::move(s))
    {
Paul Fultz II's avatar
Paul Fultz II committed
40
        assert(t != shape::tuple_type);
Paul's avatar
Paul committed
41
        assert(m_lens.size() == m_strides.size());
Khalique's avatar
Khalique committed
42
43
        // assert(std::any_of(m_strides.begin(), m_strides.end(), [](auto x) { return x > 0; }) and
        //        "At least one stride must be non-zero");
44
45
        m_standard = this->elements() == this->element_space() and
                     std::is_sorted(m_strides.rbegin(), m_strides.rend());
Paul's avatar
Paul committed
46
    }
Paul Fultz II's avatar
Paul Fultz II committed
47

charlie's avatar
charlie committed
48
    shape_impl(shape::type_t t, std::vector<shape::dynamic_dimension> dims)
49
        : m_type(t), m_dyn_dims(std::move(dims))
50
51
52
    {
    }

53
54
    shape_impl(const std::vector<shape>& subs) : m_type(shape::tuple_type), m_shapes(subs) {}

Paul's avatar
Paul committed
55
    shape::type_t m_type;
Paul Fultz II's avatar
Paul Fultz II committed
56
57
58
59
    std::vector<std::size_t> m_lens    = {};
    std::vector<std::size_t> m_strides = {};
    std::vector<shape> m_shapes        = {};
    bool m_standard                    = false;
60

61
    std::vector<shape::dynamic_dimension> m_dyn_dims = {};
Paul's avatar
Paul committed
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77

    void calculate_strides()
    {
        m_strides.clear();
        m_strides.resize(m_lens.size(), 0);
        if(m_strides.empty())
            return;
        m_strides.back() = 1;
        std::partial_sum(m_lens.rbegin(),
                         m_lens.rend() - 1,
                         m_strides.rbegin() + 1,
                         std::multiplies<std::size_t>());
    }

    std::size_t element_space() const
    {
78
        if(not m_dyn_dims.empty())
79
        {
80
            auto maxes = max_lens();
charlie's avatar
charlie committed
81
            return std::accumulate(maxes.begin(), maxes.end(), std::size_t{1}, std::multiplies<>());
82
83
        }

Paul's avatar
Paul committed
84
85
86
87
88
89
90
91
92
93
94
95
96
97
        assert(m_lens.size() == m_strides.size());
        if(m_lens.empty())
            return 0;
        return std::inner_product(m_lens.begin(),
                                  m_lens.end(),
                                  m_strides.begin(),
                                  std::size_t{0},
                                  std::plus<std::size_t>{},
                                  [](std::size_t l, std::size_t s) { return (l - 1) * s; }) +
               1;
    }

    std::size_t elements() const
    {
98
        if(not m_dyn_dims.empty())
99
100
101
102
        {
            MIGRAPHX_THROW("SHAPE: elements() called on dynamic shape");
        }

Paul's avatar
Paul committed
103
104
105
106
107
108
        assert(m_lens.size() == m_strides.size());
        if(m_lens.empty())
            return 0;
        return std::accumulate(
            m_lens.begin(), m_lens.end(), std::size_t{1}, std::multiplies<std::size_t>());
    }
109

110
111
112
    std::vector<std::size_t> min_lens() const
    {
        std::vector<std::size_t> ret(m_dyn_dims.size());
charlie's avatar
charlie committed
113
114
115
116
        std::transform(m_dyn_dims.cbegin(),
                       m_dyn_dims.cend(),
                       ret.begin(),
                       [](shape::dynamic_dimension x) { return x.min; });
117
118
119
120
121
122
        return ret;
    }

    std::vector<std::size_t> max_lens() const
    {
        std::vector<std::size_t> ret(m_dyn_dims.size());
charlie's avatar
charlie committed
123
124
125
126
        std::transform(m_dyn_dims.cbegin(),
                       m_dyn_dims.cend(),
                       ret.begin(),
                       [](shape::dynamic_dimension x) { return x.max; });
127
128
129
130
131
132
        return ret;
    }

    std::vector<std::size_t> opt_lens() const
    {
        std::vector<std::size_t> ret(m_dyn_dims.size());
charlie's avatar
charlie committed
133
134
135
136
        std::transform(m_dyn_dims.cbegin(),
                       m_dyn_dims.cend(),
                       ret.begin(),
                       [](shape::dynamic_dimension x) { return x.opt; });
137
138
139
        return ret;
    }

140
    std::shared_ptr<shape_impl> copy() const { return std::make_shared<shape_impl>(*this); }
Paul's avatar
Paul committed
141
};
Paul's avatar
Paul committed
142

143
144
145
146
const std::vector<shape::type_t>& shape::types()
{
    static const std::vector<shape::type_t> result = {
#define MIGRAPHX_GENERATE_TYPE_VECTOR(x, t) x,
Paul Fultz II's avatar
Paul Fultz II committed
147
        MIGRAPHX_SHAPE_VISIT_TYPES(MIGRAPHX_GENERATE_TYPE_VECTOR) tuple_type};
148
149
150
    return result;
}

151
152
153
154
std::string shape::name(shape::type_t t)
{
    switch(t)
    {
Paul Fultz II's avatar
Paul Fultz II committed
155
    case tuple_type: return "tuple_type";
156
157
158
159
160
161
162
163
164
165
166
#define MIGRAPHX_SHAPE_GENERATE_TYPE_NAME_CASE(x, t) \
    case x: return #x;
        MIGRAPHX_SHAPE_VISIT_TYPES(MIGRAPHX_SHAPE_GENERATE_TYPE_NAME_CASE)
#undef MIGRAPHX_SHAPE_GENERATE_TYPE_NAME_CASE
    }
    MIGRAPHX_THROW("Invalid type");
}
std::string shape::cpp_type(shape::type_t t)
{
    switch(t)
    {
Paul Fultz II's avatar
Paul Fultz II committed
167
    case tuple_type: MIGRAPHX_THROW("No C++ type for tuple");
168
169
170
171
172
173
174
175
#define MIGRAPHX_SHAPE_GENERATE_CPP_TYPE_CASE(x, t) \
    case x: return #t;
        MIGRAPHX_SHAPE_VISIT_TYPES(MIGRAPHX_SHAPE_GENERATE_CPP_TYPE_CASE)
#undef MIGRAPHX_SHAPE_GENERATE_CPP_TYPE_CASE
    }
    MIGRAPHX_THROW("Invalid type");
}

Paul's avatar
Paul committed
176
177
178
shape::shape() : impl(shape_impl::default_shape()) {}

shape::shape(type_t t) : impl(std::make_shared<shape_impl>(t)) {}
Paul's avatar
Paul committed
179
shape::shape(type_t t, std::vector<std::size_t> l)
Paul's avatar
Paul committed
180
    : impl(std::make_shared<shape_impl>(t, std::move(l)))
Paul's avatar
Paul committed
181
182
183
{
}
shape::shape(type_t t, std::vector<std::size_t> l, std::vector<std::size_t> s)
Paul's avatar
Paul committed
184
    : impl(std::make_shared<shape_impl>(t, std::move(l), std::move(s)))
Paul's avatar
Paul committed
185
186
187
{
}

188
189
190
191
192
shape::shape(type_t t, std::initializer_list<std::size_t> d)
    : shape::shape(t, std::vector<std::size_t>{d.begin(), d.end()})
{
}

charlie's avatar
charlie committed
193
shape::shape(type_t t, std::vector<shape::dynamic_dimension> dims)
194
195
196
    : impl(std::make_shared<shape_impl>(t, std::move(dims)))
{
}
Paul Fultz II's avatar
Paul Fultz II committed
197

198
shape::shape(const std::vector<shape>& subs) : impl(std::make_shared<shape_impl>(subs)) {}
199

200
201
shape::shape(std::shared_ptr<shape_impl> pimpl) : impl(std::move(pimpl)) {}

202
203
204
205
206
207
208
209
210
211
shape shape::from_permutation(type_t t,
                              const std::vector<std::size_t>& l,
                              const std::vector<int64_t>& perm)
{
    auto new_lens = reorder_dims(l, perm);
    shape result  = reorder_shape({t, new_lens}, invert_permutation(perm));
    assert(result.lens() == l);
    return result;
}

charlie's avatar
charlie committed
212

Paul's avatar
Paul committed
213
shape::type_t shape::type() const { return impl->m_type; }
214

Paul's avatar
Paul committed
215
const std::vector<std::size_t>& shape::lens() const { return impl->m_lens; }
216

Paul's avatar
Paul committed
217
const std::vector<std::size_t>& shape::strides() const { return impl->m_strides; }
218

Paul's avatar
Paul committed
219
std::size_t shape::elements() const { return impl->elements(); }
220

Paul's avatar
Paul committed
221
222
std::size_t shape::bytes() const
{
Paul Fultz II's avatar
Paul Fultz II committed
223
224
225
226
227
228
229
230
231
232
233
234
235
    if(this->sub_shapes().empty())
    {
        std::size_t n = 0;
        this->visit_type([&](auto as) { n = as.size(); });
        return n * this->element_space();
    }
    else
    {
        return std::accumulate(this->sub_shapes().begin(),
                               this->sub_shapes().end(),
                               std::size_t{0},
                               [&](auto x, auto y) { return x + y.bytes(); });
    }
Paul's avatar
Paul committed
236
}
237

Scott Thornton's avatar
Scott Thornton committed
238
239
240
std::size_t shape::type_size() const
{
    std::size_t n = 0;
Paul Fultz II's avatar
Paul Fultz II committed
241
242
    if(this->sub_shapes().empty())
        this->visit_type([&](auto as) { n = as.size(); });
Scott Thornton's avatar
Scott Thornton committed
243
244
    return n;
}
245

Paul's avatar
Paul committed
246
247
std::size_t shape::index(std::initializer_list<std::size_t> l) const
{
248
249
250
251
    if(this->dynamic())
    {
        MIGRAPHX_THROW("SHAPE: index() called on dynamic shape");
    }
Paul's avatar
Paul committed
252
253
254
255
    assert(l.size() <= this->lens().size());
    assert(this->lens().size() == this->strides().size());
    return std::inner_product(l.begin(), l.end(), this->strides().begin(), std::size_t{0});
}
charlie's avatar
charlie committed
256

Paul's avatar
Paul committed
257
258
std::size_t shape::index(const std::vector<std::size_t>& l) const
{
259
260
261
262
    if(this->dynamic())
    {
        MIGRAPHX_THROW("SHAPE: index() called on dynamic shape");
    }
Paul's avatar
Paul committed
263
264
265
266
    assert(l.size() <= this->lens().size());
    assert(this->lens().size() == this->strides().size());
    return std::inner_product(l.begin(), l.end(), this->strides().begin(), std::size_t{0});
}
charlie's avatar
charlie committed
267

Paul's avatar
Paul committed
268
269
std::size_t shape::index(std::size_t i) const
{
270
271
272
273
    if(this->dynamic())
    {
        MIGRAPHX_THROW("SHAPE: index() called on dynamic shape");
    }
Paul's avatar
Paul committed
274
    assert(this->lens().size() == this->strides().size());
Paul's avatar
Paul committed
275
    if(this->standard())
Paul's avatar
Paul committed
276
277
        return i;
    else
Paul's avatar
Paul committed
278
    {
Paul's avatar
Paul committed
279
        std::size_t s      = 1;
Paul's avatar
Paul committed
280
        std::size_t result = 0;
Paul's avatar
Paul committed
281
        for(std::size_t j = 0; j < this->lens().size(); j++)
Paul's avatar
Paul committed
282
        {
Paul's avatar
Paul committed
283
            const std::size_t k      = this->lens().size() - j - 1;
Paul's avatar
Paul committed
284
            const std::size_t stride = this->strides()[k];
Paul's avatar
Paul committed
285
286
            const std::size_t len    = this->lens()[k];
            const std::size_t idx    = (i % (s * len)) / s;
Paul's avatar
Paul committed
287
288
289
290
291
            result += stride * idx;
            s *= len;
        }
        return result;
    }
Paul's avatar
Paul committed
292
}
293
294
295
296
297
298

std::vector<std::size_t> shape::multi(std::size_t i) const
{
    assert(this->standard());

    std::vector<std::size_t> indices(lens().size());
299
300
301
302
303
304
305
306
307
308
    multi_copy(i, indices.data(), indices.data() + lens().size());

    return indices;
}

void shape::multi_copy(std::size_t i, std::size_t* start, const std::size_t* end) const
{
    assert(this->standard());
    (void)end;
    assert(lens().size() <= (end - start));
309
    std::transform(strides().begin(),
Shucai Xiao's avatar
Shucai Xiao committed
310
311
                   strides().end(),
                   lens().begin(),
312
                   start,
Shucai Xiao's avatar
Shucai Xiao committed
313
314
315
316
                   [&](std::size_t stride, std::size_t len) {
                       assert(len > 0 and stride > 0);
                       return (i / stride) % len;
                   });
317
318
}

Paul Fultz II's avatar
Paul Fultz II committed
319
320
bool shape::packed() const
{
321
322
323
324
    if(this->dynamic())
    {
        return false;
    }
Paul Fultz II's avatar
Paul Fultz II committed
325
326
    return this->sub_shapes().empty() and this->elements() == this->element_space();
}
Paul's avatar
Paul committed
327

Paul's avatar
Paul committed
328
329
bool shape::transposed() const
{
330
331
332
333
    if(this->dynamic())
    {
        return false;
    }
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
    if(this->broadcasted())
    {
        // TODO: Use a filter_iterator instead
        std::vector<std::size_t> s;
        s.reserve(this->strides().size());
        std::copy_if(this->strides().begin(),
                     this->strides().end(),
                     std::back_inserter(s),
                     [](std::size_t x) { return x != 0; });
        return not std::is_sorted(s.rbegin(), s.rend());
    }
    else
    {
        return not std::is_sorted(this->strides().rbegin(), this->strides().rend());
    }
Paul's avatar
Paul committed
349
}
Paul's avatar
Paul committed
350
351
352

bool shape::broadcasted() const
{
353
354
355
356
    if(this->dynamic())
    {
        return false;
    }
Paul's avatar
Paul committed
357
    assert(this->lens().size() == this->strides().size());
Paul's avatar
Paul committed
358
359
360
361
    return std::accumulate(this->strides().begin(),
                           this->strides().end(),
                           std::size_t{1},
                           std::multiplies<std::size_t>()) == 0;
Paul's avatar
Paul committed
362
363
}

Khalique's avatar
Khalique committed
364
365
bool shape::scalar() const
{
366
367
368
369
    if(this->dynamic())
    {
        return false;
    }
Khalique's avatar
Khalique committed
370
371
    assert(this->lens().size() == this->strides().size());
    // if any stride > 0, then accumulate will return false
Paul Fultz II's avatar
Paul Fultz II committed
372
373
    return this->sub_shapes().empty() and
           std::accumulate(this->strides().begin(), this->strides().end(), std::size_t(0)) == 0;
Khalique's avatar
Khalique committed
374
375
}

Paul's avatar
Paul committed
376
bool shape::standard() const { return impl->m_standard; }
Paul's avatar
Paul committed
377

378
379
380
381
382
383
384
385
shape shape::normalize_standard() const
{
    if(this->standard())
        return {this->type(), this->lens()};
    else
        return *this;
}

386
387
shape shape::with_lens(type_t t, const std::vector<std::size_t>& l) const
{
388
389
390
391
    if(this->dynamic())
    {
        MIGRAPHX_THROW("SHAPE: with_lens() called on dynamic shape");
    }
392
393
394
395
396
397
398
    assert(l.size() == this->lens().size());
    auto perm = find_permutation(*this);
    return shape::from_permutation(t, l, perm);
}

shape shape::with_lens(const std::vector<std::size_t>& l) const
{
399
400
401
402
    if(this->dynamic())
    {
        MIGRAPHX_THROW("SHAPE: with_lens() called on dynamic shape");
    }
403
404
405
    return this->with_lens(this->type(), l);
}

406
407
408
409
410
411
412
shape shape::with_type(type_t t) const
{
    auto c    = impl->copy();
    c->m_type = t;
    return {c};
}

Paul's avatar
Paul committed
413
std::size_t shape::element_space() const { return impl->element_space(); }
Paul's avatar
Paul committed
414

415
std::string shape::type_string() const { return name(this->type()); }
Paul's avatar
Paul committed
416

417
bool shape::dynamic() const { return not impl->m_dyn_dims.empty(); }
charlie's avatar
charlie committed
418
419
420

const std::vector<shape::dynamic_dimension>& shape::dyn_dims() const { return impl->m_dyn_dims; }

421
std::vector<std::size_t> shape::min_lens() const
charlie's avatar
charlie committed
422
{
charlie's avatar
charlie committed
423
    if(not this->dynamic())
charlie's avatar
charlie committed
424
    {
425
        return this->lens();
charlie's avatar
charlie committed
426
    }
charlie's avatar
charlie committed
427
428
    return impl->min_lens();
    ;
charlie's avatar
charlie committed
429
430
}

431
std::vector<std::size_t> shape::max_lens() const
charlie's avatar
charlie committed
432
{
charlie's avatar
charlie committed
433
    if(not this->dynamic())
charlie's avatar
charlie committed
434
    {
435
        return this->lens();
charlie's avatar
charlie committed
436
    }
charlie's avatar
charlie committed
437
438
    return impl->max_lens();
    ;
charlie's avatar
charlie committed
439
440
}

441
std::vector<std::size_t> shape::opt_lens() const
charlie's avatar
charlie committed
442
{
charlie's avatar
charlie committed
443
    if(not this->dynamic())
charlie's avatar
charlie committed
444
    {
445
        return this->lens();
charlie's avatar
charlie committed
446
    }
charlie's avatar
charlie committed
447
448
    return impl->opt_lens();
    ;
charlie's avatar
charlie committed
449
450
}

charlie's avatar
charlie committed
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
480
481
482
483
bool shape::dynamic_dimension::is_fixed() const
{
    return this->min == this->max;
}

bool shape::dynamic_dimension::has_optimal() const
{
    return opt != 0; 
}

template <class Self, class F>
auto shape::dynamic_dimension::reflect(Self& self, F f)
{
    return pack(f(self.min, "min"),
                f(self.max, "max"),
                f(self.opt, "opt"));
}

bool operator==(const shape::dynamic_dimension& x, const shape::dynamic_dimension& y)
{
    return (x.min == y.min and x.max == y.max and x.opt == y.opt);
}

bool operator!=(const shape::dynamic_dimension& x, const shape::dynamic_dimension& y)
{
    return !(x == y);
}
std::ostream& operator<<(std::ostream& os, const shape::dynamic_dimension& x)
{
    os << "[" << x.min << ", " << x.max << ", " << x.opt << "]";
    return os;
}

Paul's avatar
Paul committed
484
485
bool operator==(const shape& x, const shape& y)
{
486
487
488
489
490
491
492
493
    if(x.dynamic() and y.dynamic())
    {
        return x.impl == y.impl or (x.type() == y.type() and x.dyn_dims() == y.dyn_dims() and
                                    x.sub_shapes() == y.sub_shapes());
    }
    return x.impl == y.impl or
           (x.dynamic() == y.dynamic() and x.type() == y.type() and x.lens() == y.lens() and
            x.strides() == y.strides() and x.sub_shapes() == y.sub_shapes());
Paul's avatar
Paul committed
494
}
495

Paul's avatar
Paul committed
496
bool operator!=(const shape& x, const shape& y) { return !(x == y); }
Paul's avatar
Paul committed
497

Paul's avatar
Paul committed
498
499
std::ostream& operator<<(std::ostream& os, const shape& x)
{
Paul Fultz II's avatar
Paul Fultz II committed
500
501
    if(x.sub_shapes().empty())
    {
502
503
504
505
506
507
508
509
510
511
512
513
        if(x.dynamic())
        {
            os << "dynamic, ";
            os << x.type_string() << ", ";
            os << "{" << to_string_range(x.dyn_dims()) << "}";
        }
        else
        {
            os << x.type_string() << ", ";
            os << "{" << to_string_range(x.lens()) << "}, ";
            os << "{" << to_string_range(x.strides()) << "}";
        }
Paul Fultz II's avatar
Paul Fultz II committed
514
515
516
517
518
    }
    else
    {
        os << "[" << to_string_range(x.sub_shapes()) << "]";
    }
Paul's avatar
Paul committed
519
520
521
    return os;
}

522
523
shape::type_t shape::parse_type(const std::string& s)
{
524
    static const std::unordered_map<std::string, shape::type_t> m = {
525
#define MIGRAPHX_SHAPE_GENERATE_TYPE_STRING_MAP(x, t) {#x, x}, {#t, x},
Paul Fultz II's avatar
Paul Fultz II committed
526
527
528
        MIGRAPHX_SHAPE_VISIT_TYPES(MIGRAPHX_SHAPE_GENERATE_TYPE_STRING_MAP){"tuple_type",
                                                                            tuple_type},
        {"tuple", tuple_type}};
529
530
531
    return m.at(s);
}

Paul Fultz II's avatar
Paul Fultz II committed
532
533
const std::vector<shape>& shape::sub_shapes() const { return impl->m_shapes; }

534
535
536
void migraphx_to_value(value& v, const shape& s)
{
    value result;
charlie's avatar
charlie committed
537
    result["type"] = migraphx::to_value(s.type_string());
charlie's avatar
charlie committed
538
539
540
541
    result["lens"]       = migraphx::to_value(s.lens());
    result["strides"]    = migraphx::to_value(s.strides());
    result["sub_shapes"] = migraphx::to_value(s.sub_shapes());
    result["dynamic_dimensions"]       = migraphx::to_value(s.dyn_dims());
542
    v = result;
543
}
544

545
546
void migraphx_from_value(const value& v, shape& s)
{
Paul Fultz II's avatar
Paul Fultz II committed
547
548
549
550
551
552
553
    auto t = v.at("type").get_string();
    if(t == "tuple_type")
    {
        s = shape{migraphx::from_value<std::vector<migraphx::shape>>(v.at("sub_shapes"))};
    }
    else
    {
charlie's avatar
charlie committed
554
        if(v.at("dynamic_dimensions").empty())
555
556
557
558
559
        {
            s = shape{shape::parse_type(t),
                      v.at("lens").to_vector<std::size_t>(),
                      v.at("strides").to_vector<std::size_t>()};
        }
charlie's avatar
charlie committed
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
        else
        {
            auto v_dd = v.at("dynamic_dimensions");
            std::vector<shape::dynamic_dimension> dyn_dims(v.at("dynamic_dimensions").size());
            std::transform(
                v_dd.begin(),
                v_dd.end(),
                dyn_dims.begin(),
                [](migraphx::value x)
                {
                    auto x_min = x.at("min").template to<size_t>();
                    auto x_max = x.at("max").template to<size_t>();
                    auto x_opt = x.at("opt").template to<size_t>();
                    return shape::dynamic_dimension{x_min, x_max, x_opt};
                }
            );

            s = shape{
                shape::parse_type(t),
                dyn_dims
            };
        }
Paul Fultz II's avatar
Paul Fultz II committed
582
    }
583
584
}

Paul's avatar
Paul committed
585
} // namespace MIGRAPHX_INLINE_NS
Paul's avatar
Paul committed
586
} // namespace migraphx