Skip to content

GitLab

Commit 94e3a2e4 authored by Shucai Xiao's avatar Shucai Xiao
Browse files

change size_t to int

parent 26bd92d8
Show whitespace changes
Inline Side-by-side
Showing with 104 additions and 104 deletions
src/targets/gpu/include/migraphx/gpu/pack_args.hpp
View file @ 94e3a2e4
......@@ -18,8 +18,8 @@ struct kernel_argument
kernel_argument(T&& x) : size(sizeof(U)), align(alignof(U)), data(&x) // NOLINT
{
}
std::size_t size;
std::size_t align;
int size;
int align;
void* data;
};
......
src/targets/gpu/include/migraphx/gpu/schedule_model.hpp
View file @ 94e3a2e4
......@@ -15,12 +15,12 @@ namespace gpu {
struct schedule_model
{
std::size_t streams = 0;
std::size_t concurrency() const;
void sched(module& p, instruction_ref ins, std::size_t n) const;
void wait(module& p, instruction_ref ins, std::size_t wait_id) const;
void record(module& p, instruction_ref ins, std::size_t wait_id) const;
std::size_t weight(const operation& op) const;
int streams = 0;
int concurrency() const;
void sched(module& p, instruction_ref ins, int n) const;
void wait(module& p, instruction_ref ins, int wait_id) const;
void record(module& p, instruction_ref ins, int wait_id) const;
int weight(const operation& op) const;
};
} // namespace gpu
......
src/targets/gpu/kernel.cpp
View file @ 94e3a2e4
......@@ -12,7 +12,7 @@ extern hipError_t hipExtModuleLaunchKernel(hipFunction_t, // NOLINT
uint32_t,
uint32_t,
uint32_t,
size_t,
int,
hipStream_t,
void**,
void**,
......@@ -54,10 +54,10 @@ kernel::kernel(const char* image, const std::string& name) : impl(std::make_shar
void launch_kernel(hipFunction_t fun,
hipStream_t stream,
std::size_t global,
std::size_t local,
int global,
int local,
void* kernargs,
std::size_t size)
int size)
{
void* config[] = {
// HIP_LAUNCH_PARAM_* are macros that do horrible things
......@@ -79,25 +79,25 @@ void launch_kernel(hipFunction_t fun,
}
void kernel::launch(hipStream_t stream,
std::size_t global,
std::size_t local,
int global,
int local,
std::vector<void*> args) const
{
assert(impl != nullptr);
void* kernargs = args.data();
std::size_t size = args.size() * sizeof(void*);
int size = args.size() * sizeof(void*);
launch_kernel(impl->fun, stream, global, local, kernargs, size);
}
void kernel::launch(hipStream_t stream,
std::size_t global,
std::size_t local,
int global,
int local,
const std::vector<kernel_argument>& args) const
{
assert(impl != nullptr);
std::vector<char> kernargs = pack_args(args);
std::size_t size = kernargs.size();
int size = kernargs.size();
launch_kernel(impl->fun, stream, global, local, kernargs.data(), size);
}
......
src/targets/gpu/kernels/include/migraphx/kernels/basic_ops.hpp
View file @ 94e3a2e4
......@@ -34,7 +34,7 @@ struct id
struct mean
{
size_t item_num = 1;
int item_num = 1;
template <class T>
constexpr auto operator()(T x) const
{
......
src/targets/gpu/kernels/include/migraphx/kernels/debug.hpp
View file @ 94e3a2e4
......@@ -26,7 +26,7 @@ struct swallow
}
};
template <size_t N>
template <int N>
struct print_buffer
{
char buffer[N + 1] = {0};
......@@ -43,7 +43,7 @@ struct print_buffer
}
}
template <size_t M>
template <int M>
constexpr void append(const char (&array)[M])
{
for(int i = 0; i < M; i++)
......
src/targets/gpu/kernels/include/migraphx/kernels/roialign.hpp
View file @ 94e3a2e4
......@@ -19,7 +19,7 @@ struct max_pool
}
template <class T>
MIGRAPHX_DEVICE_CONSTEXPR T final(T x, std::size_t)
MIGRAPHX_DEVICE_CONSTEXPR T final(T x, int)
{
return (x);
}
......@@ -36,7 +36,7 @@ struct avg_pool
}
template <class T>
MIGRAPHX_DEVICE_CONSTEXPR T final(T x, std::size_t y)
MIGRAPHX_DEVICE_CONSTEXPR T final(T x, int y)
{
return (y == 0) ? 0.0 : (x / y);
}
......@@ -44,13 +44,13 @@ struct avg_pool
template <class T, class Op>
MIGRAPHX_DEVICE_CONSTEXPR T bilinear_interpolate(const T* data,
const array<std::size_t, 2>& dims,
const array<int, 2>& dims,
array<float, 2> xy,
Op pooling)
{
array<int, 2> low{};
array<int, 2> high{};
for(std::size_t ii = 0; ii < xy.size(); ++ii)
for(int ii = 0; ii < xy.size(); ++ii)
{
if(xy[ii] < -1.0f or xy[ii] > dims[ii])
{
......@@ -65,7 +65,7 @@ MIGRAPHX_DEVICE_CONSTEXPR T bilinear_interpolate(const T* data,
xy[ii] = high[ii] = low[ii] = dims[ii] - 1;
}
}
array<std::size_t, 4> locs = {low[0] * dims[1] + low[1],
array<int, 4> locs = {low[0] * dims[1] + low[1],
low[0] * dims[1] + high[1],
high[0] * dims[1] + low[1],
high[0] * dims[1] + high[1]};
......@@ -86,15 +86,15 @@ MIGRAPHX_DEVICE_CONSTEXPR T calc_pooling(const T*& data,
const array<float, 2>& roi_starts,
const array<float, 2>& bin_size,
const array<int, 2>& idx,
const array<std::size_t, 2>& bin_grid_size,
const array<std::size_t, 2>& dims,
const array<int, 2>& bin_grid_size,
const array<int, 2>& dims,
float roi_offset,
Op op)
{
T output_val = op.init();
const int64_t count = bin_grid_size[0] * bin_grid_size[1];
dfor(bin_grid_size[0], bin_grid_size[1])([&](auto iy, auto ix) {
array<std::size_t, 2> id = {iy, ix};
array<int, 2> id = {iy, ix};
array<float, 2> locs =
roi_starts + idx * bin_size + bin_size * (id + 0.5f) / bin_grid_size + roi_offset;
......@@ -134,7 +134,7 @@ __device__ void roialign(const T& x_t, const U& rois_t, const V& ind_t, const W&
auto channel_num = x_lens[1];
// input dims of height and width, in all 2-dim arrays, the first dim
// is for height and second dim is for width
array<std::size_t, 2> in_dims = {x_lens[2], x_lens[3]};
array<int, 2> in_dims = {x_lens[2], x_lens[3]};
const auto stride = index.nglobal();
auto out_s = y_t.get_shape();
......@@ -143,7 +143,7 @@ __device__ void roialign(const T& x_t, const U& rois_t, const V& ind_t, const W&
// output dims of height and width, in all 2-dim arrays, the first dim
// is for height and second dim is for width
const auto& out_lens = out_s.lens;
array<std::size_t, 2> out_dims = {out_lens[2], out_lens[3]};
array<int, 2> out_dims = {out_lens[2], out_lens[3]};
for(index_int i = index.global; i < out_s.elements(); i += stride)
{
......@@ -163,9 +163,9 @@ __device__ void roialign(const T& x_t, const U& rois_t, const V& ind_t, const W&
array<float, 2> roi_size{};
array<float, 2> bin_size{};
array<std::size_t, 2> bin_grid_size{};
array<int, 2> bin_grid_size{};
for(std::size_t ii = 0; ii < roi_size.size(); ++ii)
for(int ii = 0; ii < roi_size.size(); ++ii)
{
roi_size[ii] = roi_ends[ii] - roi_starts[ii];
roi_size[ii] = max(roi_size[ii], 1.0f);
......
src/targets/gpu/lowering.cpp
View file @ 94e3a2e4
......@@ -88,7 +88,7 @@ struct miopen_apply
outputs_alias.begin(),
[](const auto& i) { return instruction::get_output_alias(i); });
std::size_t index = 0;
int index = 0;
for(auto ins : outputs_alias)
{
prog_output_names[ins] = mod->name() + ":#output_" + std::to_string(index++);
......
src/targets/gpu/mlir_conv.cpp
View file @ 94e3a2e4
......@@ -45,9 +45,9 @@ struct mlir_apply
struct execution_spec
{
migraphx::value::binary binary;
size_t global_size;
size_t local_size;
execution_spec(migraphx::value::binary&& binary_m, size_t global_s, size_t local_s)
int global_size;
int local_size;
execution_spec(migraphx::value::binary&& binary_m, int global_s, int local_s)
: binary(std::move(binary_m)), global_size(global_s), local_size(local_s)
{
}
......@@ -152,7 +152,7 @@ struct mlir_apply
auto bin_i = binary_map.find(mlir_options);
if(bin_i == binary_map.end())
{
size_t bin_size = 0;
int bin_size = 0;
using mlir_handle = MIGRAPHX_MANAGE_PTR(MiirHandle, miirDestroyHandle);
auto handle = mlir_handle(miirCreateHandle(mlir_options.c_str()));
......@@ -164,8 +164,8 @@ struct mlir_apply
if(miirBufferGet(handle.get(), reinterpret_cast<char*>(bin.data()), &bin_size) ==
MIIR_SUCCESS)
{
size_t global_size;
size_t block_size;
int global_size;
int block_size;
if(miirGetExecutionDims(handle.get(), &global_size, &block_size) ==
MIIR_SUCCESS)
{
......@@ -224,7 +224,7 @@ struct mlir_apply
void add_memref_descriptor(std::vector<instruction_ref>& refs, instruction_ref inst)
{
const size_t offset = 0;
const int offset = 0;
auto inst_t = inst->get_shape();
refs.push_back(inst);
refs.push_back(inst);
......
src/targets/gpu/pack_args.cpp
View file @ 94e3a2e4
......@@ -10,10 +10,10 @@ std::vector<char> pack_args(const std::vector<kernel_argument>& args)
std::vector<char> kernargs;
for(auto&& arg : args)
{
std::size_t n = arg.size;
int n = arg.size;
const auto* p = static_cast<const char*>(arg.data);
// Insert padding
std::size_t padding = (arg.align - (kernargs.size() % arg.align)) % arg.align;
int padding = (arg.align - (kernargs.size() % arg.align)) % arg.align;
kernargs.insert(kernargs.end(), padding, 0);
kernargs.insert(kernargs.end(), p, p + n);
}
......
src/targets/gpu/pooling.cpp
View file @ 94e3a2e4
......@@ -19,7 +19,7 @@ inline void reshape_if_1d(shape& input)
if(dims.size() == 3)
{
std::vector<size_t> new_dims = dims;
std::vector<int> new_dims = dims;
new_dims.insert(new_dims.begin() + 2, 1);
input = shape{input.type(), new_dims};
}
......
src/targets/gpu/quant_convolution.cpp
View file @ 94e3a2e4
......@@ -60,7 +60,7 @@ shape miopen_quant_convolution::compile(context& ctx,
cd.get(),
y_desc.get(),
&workspace_size);
workspace_shape = shape{shape::int8_type, {workspace_size}};
workspace_shape = shape{shape::int8_type, {static_cast<int>(workspace_size)}};
auto arg_vec4_x = to_gpu(generate_argument(pack_int8_shape(inputs[0])));
auto arg_vec4_w = to_gpu(generate_argument(pack_int8_shape(inputs[1])));
......@@ -89,7 +89,7 @@ shape miopen_quant_convolution::compile(context& ctx,
}
handle = ctx.get_stream().get_miopen();
algo = perf.fwd_algo;
return shape{shape::int8_type, {perf.memory}};
return shape{shape::int8_type, {static_cast<int>(perf.memory)}};
}
void miopen_quant_convolution::finalize(context& ctx,
......
src/targets/gpu/schedule_model.cpp
View file @ 94e3a2e4
......@@ -11,7 +11,7 @@ namespace gpu {
struct record_event
{
std::size_t event = 0;
int event = 0;
template <class Self, class F>
static auto reflect(Self& self, F f)
{
......@@ -34,7 +34,7 @@ struct record_event
struct wait_event
{
std::size_t event = 0;
int event = 0;
template <class Self, class F>
static auto reflect(Self& self, F f)
{
......@@ -52,7 +52,7 @@ struct wait_event
struct set_stream
{
std::size_t stream = 0;
int stream = 0;
template <class Self, class F>
static auto reflect(Self& self, F f)
{
......@@ -76,8 +76,8 @@ MIGRAPHX_REGISTER_OP(record_event)
MIGRAPHX_REGISTER_OP(wait_event)
MIGRAPHX_REGISTER_OP(set_stream)
std::size_t schedule_model::concurrency() const { return streams; }
void schedule_model::sched(module& p, instruction_ref ins, std::size_t n) const
int schedule_model::concurrency() const { return streams; }
void schedule_model::sched(module& p, instruction_ref ins, int n) const
{
auto last_stream = std::find_if(std::make_reverse_iterator(ins),
std::make_reverse_iterator(p.begin()),
......@@ -92,16 +92,16 @@ void schedule_model::sched(module& p, instruction_ref ins, std::size_t n) const
p.insert_instruction(ins, set_stream{n});
}
void schedule_model::wait(module& p, instruction_ref ins, std::size_t wait_id) const
void schedule_model::wait(module& p, instruction_ref ins, int wait_id) const
{
p.insert_instruction(ins, wait_event{wait_id});
}
void schedule_model::record(module& p, instruction_ref ins, std::size_t wait_id) const
void schedule_model::record(module& p, instruction_ref ins, int wait_id) const
{
p.insert_instruction(std::next(ins), record_event{wait_id});
}
static std::unordered_map<std::string, std::size_t> create_weight_map()
static std::unordered_map<std::string, int> create_weight_map()
{
return {{"hip::load_literal", 0},
{"hip::hip_allocate_memory", 0},
......@@ -113,13 +113,13 @@ static std::unordered_map<std::string, std::size_t> create_weight_map()
{"gpu::gemm", 4}};
}
static const std::unordered_map<std::string, std::size_t>& weight_map()
static const std::unordered_map<std::string, int>& weight_map()
{
static const std::unordered_map<std::string, std::size_t> m = create_weight_map();
static const std::unordered_map<std::string, int> m = create_weight_map();
return m;
}
std::size_t schedule_model::weight(const operation& op) const
int schedule_model::weight(const operation& op) const
{
if(weight_map().count(op.name()) == 0)
{
......
src/targets/gpu/write_literals.cpp
View file @ 94e3a2e4
......@@ -14,7 +14,7 @@ MIGRAPHX_DECLARE_ENV_VAR(MIGRAPHX_COPY_LITERALS)
void write_literals::apply(module& p) const
{
assert(ctx != nullptr);
std::size_t n = 0;
int n = 0;
for(auto ins : iterator_for(p))
{
if(ins->name() == "@literal")
......
src/targets/ref/gemm.cpp
View file @ 94e3a2e4
......@@ -20,8 +20,8 @@ static auto make_mat(tensor_view<T> x)
int dim_0 = n_dims - 2;
int dim_1 = n_dims - 1;
if(s.transposed())
return matrix<T>{x.data(), s.lens()[dim_1], s.lens()[dim_0], s.strides()[dim_1]};
return matrix<T>{x.data(), s.lens()[dim_0], s.lens()[dim_1], s.strides()[dim_0]};
return matrix<T>{x.data(), static_cast<std::size_t>(s.lens()[dim_1]), static_cast<std::size_t>(s.lens()[dim_0]), static_cast<std::size_t>(s.strides()[dim_1])};
return matrix<T>{x.data(), static_cast<std::size_t>(s.lens()[dim_0]), static_cast<std::size_t>(s.lens()[dim_1]), static_cast<std::size_t>(s.strides()[dim_0])};
}
template <class T, class F>
......
src/targets/ref/lowering.cpp
View file @ 94e3a2e4
......@@ -218,7 +218,7 @@ struct ref_convolution : auto_register_op<ref_convolution<Op>>
auto wei_lens = weights.get_shape().lens();
auto wei_n = wei_lens[0];
auto wei_c = wei_lens[1];
std::vector<std::size_t> win_size(wei_lens.begin() + 1, wei_lens.end());
std::vector<int> win_size(wei_lens.begin() + 1, wei_lens.end());
par_for(output_shape.elements(), [&](auto i) {
auto idx_o = output_shape.multi(i);
......@@ -226,7 +226,7 @@ struct ref_convolution : auto_register_op<ref_convolution<Op>>
auto n_dim = idx_o.size();
std::vector<std::ptrdiff_t> win_start;
for(std::size_t dim = 2; dim < n_dim; ++dim)
for(int dim = 2; dim < n_dim; ++dim)
{
auto d_2 = dim - 2;
win_start.push_back(std::ptrdiff_t(idx_o[dim] * op.stride[d_2]) -
......@@ -291,35 +291,35 @@ struct ref_im2col
auto input_shape = args[0].get_shape();
auto weights_shape = args[1].get_shape();
visit_all(result, args[0])([&](auto col, auto input) {
const std::size_t& height = input_shape.lens()[2];
const std::size_t& width = input_shape.lens()[3];
const std::size_t& channels = weights_shape.lens()[1];
const std::size_t& kernel_h = weights_shape.lens()[2];
const std::size_t& kernel_w = weights_shape.lens()[3];
const std::size_t& pad_h = op.padding[0];
const std::size_t& pad_w = op.padding[1];
const std::size_t& stride_h = op.stride[0];
const std::size_t& stride_w = op.stride[1];
const int& height = input_shape.lens()[2];
const int& width = input_shape.lens()[3];
const int& channels = weights_shape.lens()[1];
const int& kernel_h = weights_shape.lens()[2];
const int& kernel_w = weights_shape.lens()[3];
const int& pad_h = op.padding[0];
const int& pad_w = op.padding[1];
const int& stride_h = op.stride[0];
const int& stride_w = op.stride[1];
long kdiv2_h = long(kernel_h) / 2;
long kdiv2_w = long(kernel_w) / 2;
// calculate output sizes
const std::size_t col_height = (height - kernel_h + 2 * pad_h) / stride_h + 1;
const std::size_t col_width = (width - kernel_w + 2 * pad_w) / stride_w + 1;
const int col_height = (height - kernel_h + 2 * pad_h) / stride_h + 1;
const int col_width = (width - kernel_w + 2 * pad_w) / stride_w + 1;
// account for padding for the starting position of the input pixels
long iinput = kdiv2_h - long(pad_h);
// loop over output pixels (ioutput, joutput)
for(std::size_t ioutput = 0; ioutput < col_height; ioutput++, iinput += stride_h)
for(int ioutput = 0; ioutput < col_height; ioutput++, iinput += stride_h)
{
long jinput = kdiv2_w - long(pad_w);
for(std::size_t joutput = 0; joutput < col_width; joutput++, jinput += stride_w)
for(int joutput = 0; joutput < col_width; joutput++, jinput += stride_w)
{
// compute linear index for output
std::size_t ldx = ioutput * col_width + joutput;
std::size_t p = 0;
int ldx = ioutput * col_width + joutput;
int p = 0;
dfor(channels,
kernel_h,
kernel_w)([&](std::size_t c, std::size_t koffset, std::size_t loffset) {
kernel_w)([&](int c, int koffset, int loffset) {
auto idx = iinput + long(koffset) - kdiv2_h;
auto jdx = jinput + long(loffset) - kdiv2_w;
col(ldx, p) = ((idx >= 0) && (idx < height) && (jdx >= 0) && (jdx < width))
......@@ -350,7 +350,7 @@ struct max_pool
return (m);
}
static double final(double x, std::size_t) { return (x); }
static double final(double x, int) { return (x); }
};
struct avg_pool
......@@ -365,7 +365,7 @@ struct avg_pool
static double apply(double x, double y) { return x + y; }
static double final(double x, std::size_t y) { return (y == 0) ? 0.0 : (x / y); }
static double final(double x, int y) { return (y == 0) ? 0.0 : (x / y); }
};
template <class Op>
......@@ -395,14 +395,14 @@ struct ref_pooling : auto_register_op<ref_pooling<Op>>
using type = typename decltype(output)::value_type;
auto in_s = input.get_shape();
auto in_lens = in_s.lens();
std::vector<std::size_t> vec_len(in_lens.begin() + 2, in_lens.end());
std::vector<int> vec_len(in_lens.begin() + 2, in_lens.end());
par_for(output_shape.elements(), [&](auto i) {
auto idx_o = output_shape.multi(i);
auto n_dim = idx_o.size();
std::vector<std::size_t> win_start;
std::vector<std::size_t> win_size;
for(std::size_t dim = 2; dim < n_dim; ++dim)
std::vector<int> win_start;
std::vector<int> win_size;
for(int dim = 2; dim < n_dim; ++dim)
{
auto d_2 = dim - 2;
int start = static_cast<int>(idx_o[dim] * op.stride[d_2]) -
......@@ -494,7 +494,7 @@ struct ref_pad
visit_all(result, args[0])([&](auto output, auto input) {
shape_for_each(input.get_shape(), [&](const auto& idx) {
std::vector<std::size_t> new_idx(idx.size());
std::vector<int> new_idx(idx.size());
std::transform(
idx.begin(), idx.end(), op.pads.begin(), new_idx.begin(), [](auto i, auto j) {
return i + j;
......@@ -650,7 +650,7 @@ struct ref_softmax : auto_register_op<ref_softmax<Op>>
argument result{output_shape};
auto batch_lens = output_shape.lens();
int64_t tuned_axis = tune_axis(args[0].get_shape().lens().size(), op.axis, op.name());
std::size_t n_dims = batch_lens[tuned_axis];
int n_dims = batch_lens[tuned_axis];
batch_lens[tuned_axis] = 1;
shape batch_shape{shape::int32_type, batch_lens};
......@@ -661,27 +661,27 @@ struct ref_softmax : auto_register_op<ref_softmax<Op>>
std::vector<value_type> batch_sum(batch_shape.elements(), value_type(0));
par_for(batch_shape.elements(), [&](auto i) {
auto idx = batch_shape.multi(i);
for(std::size_t j = 0; j < n_dims; ++j)
for(int j = 0; j < n_dims; ++j)
{
idx[tuned_axis] = j;
batch_max[i] =
std::max<value_type>(batch_max[i], input(idx.begin(), idx.end()));
}
for(std::size_t j = 0; j < n_dims; ++j)
for(int j = 0; j < n_dims; ++j)
{
idx[tuned_axis] = j;
std::size_t index = output_shape.index(idx);
int index = output_shape.index(idx);
output[index] = std::exp(input[index] - batch_max[i]);
}
for(std::size_t j = 0; j < n_dims; ++j)
for(int j = 0; j < n_dims; ++j)
{
idx[tuned_axis] = j;
batch_sum[i] += output(idx.begin(), idx.end());
}
for(std::size_t j = 0; j < n_dims; ++j)
for(int j = 0; j < n_dims; ++j)
{
idx[tuned_axis] = j;
output(idx.begin(), idx.end()) =
......
src/tf/include/migraphx/tf/tf_parser.hpp
View file @ 94e3a2e4
......@@ -60,8 +60,8 @@ struct tf_parser
module* mm = prog.get_main_module();
bool is_nhwc = true;
unsigned int batch_size = 1;
std::size_t default_dim_value = 1;
std::unordered_map<std::string, std::vector<std::size_t>> map_input_dims;
int default_dim_value = 1;
std::unordered_map<std::string, std::vector<int>> map_input_dims;
std::unordered_map<std::string, op_func> ops;
......@@ -73,7 +73,7 @@ struct tf_parser
instruction_ref to_kcxy(instruction_ref ins) const;
std::vector<instruction_ref> to_nchw(const std::vector<instruction_ref>& args) const;
std::vector<instruction_ref> to_nhwc(const std::vector<instruction_ref>& args) const;
int64_t parse_axis(int64_t dim, size_t num_dims) const;
int64_t parse_axis(int64_t dim, int num_dims) const;
// tf stores certain attributes such as strides, dilations, as a 4D input.
// The first and last dims are equal to 1, and the relevant data is in dims 2 and 3.
// This helper function reorders the data to store for the respective operator member variables.
......@@ -81,7 +81,7 @@ struct tf_parser
void reorder_data(std::vector<T>& prev_data) const
{
std::vector<T> new_data(prev_data.size());
for(size_t i = 0; i < new_data.size(); i++)
for(int i = 0; i < new_data.size(); i++)
{
auto new_idx = parse_axis(i, new_data.size());
new_data.at(new_idx) = prev_data.at(i);
......@@ -91,7 +91,7 @@ struct tf_parser
void parse_undefined(module* mm, const std::string& name);
void parse_from(std::istream& is);
void parse_from(const void* data, std::size_t size);
void parse_from(const void* data, int size);
void parse_graph(const tensorflow::GraphDef& graph);
void parse_node(const std::string& name);
literal parse_tensor(const tensorflow::TensorProto& t) const;
......@@ -99,7 +99,7 @@ struct tf_parser
std::vector<std::string> find_outputs() const;
};
std::vector<int64_t> get_axes_from_mask(size_t num_axes, uint32_t mask);
std::vector<int64_t> get_axes_from_mask(int num_axes, uint32_t mask);
} // namespace tf
} // namespace MIGRAPHX_INLINE_NS
......
src/tf/parse_concat.cpp
View file @ 94e3a2e4
......@@ -18,7 +18,7 @@ struct parse_concat : op_parser<parse_concat>
std::vector<instruction_ref> args) const
{
// get index for axis within args
size_t axis_idx = info.attributes.at("N").i();
int axis_idx = info.attributes.at("N").i();
int64_t axis = args[axis_idx]->eval().at<int64_t>();
auto op = make_op("concat", {{"axis", axis}});
// return only first N arguments (assuming last index is the axis value)
......
src/tf/parse_pack.cpp
View file @ 94e3a2e4
......@@ -23,7 +23,7 @@ struct parse_pack : op_parser<parse_pack>
int64_t axis = 0;
if(contains(info.attributes, "axis"))
axis = info.attributes.at("axis").i();
size_t input_size = args.front()->get_shape().lens().size();
int input_size = args.front()->get_shape().lens().size();
if(axis > input_size)
{
MIGRAPHX_THROW("TF_PARSER: axis value of " + to_string(axis) +
......
src/tf/parse_pad.cpp
View file @ 94e3a2e4
......@@ -18,13 +18,13 @@ struct parse_pad : op_parser<parse_pad>
const tf_parser::node_info& info,
std::vector<instruction_ref> args) const
{
size_t ndims = args.front()->get_shape().lens().size();
int ndims = args.front()->get_shape().lens().size();
// in tf, the paddings are arranged as a 2d shape (ndims, 2),
// the last dim contains the left padding and right padding respectively
std::vector<std::pair<int32_t, int32_t>> pad_per_dim(ndims);
auto tf_padding = args[1]->eval().get<int32_t>().to_vector();
for(size_t i = 0; i < 2 * ndims; i += 2)
for(int i = 0; i < 2 * ndims; i += 2)
{
pad_per_dim[i / 2].first = tf_padding[i];
pad_per_dim[i / 2].second = tf_padding[i + 1];
......@@ -32,7 +32,7 @@ struct parse_pad : op_parser<parse_pad>
parser.reorder_data(pad_per_dim);
std::vector<int64_t> pads(ndims * 2);
for(size_t i = 0; i < ndims; i++)
for(int i = 0; i < ndims; i++)
{
pads[i] = pad_per_dim[i].first;
pads[i + ndims] = pad_per_dim[i].second;
......
src/tf/parse_slice.cpp
View file @ 94e3a2e4
......@@ -22,14 +22,14 @@ struct parse_slice : op_parser<parse_slice>
auto starts = args[1]->eval().get<int32_t>().to_vector();
auto size = args[2]->eval().get<int32_t>().to_vector();
auto axes = args[0]->get_shape().lens();
size_t num_axes = axes.size();
int num_axes = axes.size();
std::vector<int64_t> axes_int64(axes.begin(), axes.end());
std::vector<int64_t> starts_int64(starts.begin(), starts.end());
std::vector<int64_t> ends(num_axes);
std::vector<int64_t> op_axes(num_axes);
std::iota(op_axes.begin(), op_axes.end(), 0);
for(size_t i = 0; i < num_axes; i++)
for(int i = 0; i < num_axes; i++)
{
if(size[i] == -1)
ends[i] = axes_int64[i];
......
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment