Blame - src/core/NEON/kernels/scale/impl/SVE/qasymm8_signed.cpp - ml/ComputeLibrary

const auto in_hi = static_cast<int>(align_corners ? utils::rounding::round_half_away_from_zero((id.z() + sampling_offset) * hr) : std::floor((id.z() + sampling_offset) * hr));

69

const int offset_row = in_hi * in_stride_wc;

70

const auto in_ptr = reinterpret_cast<const int8_t *>(in_ptr_start + in_stride_bytes_hwc * id[3]);

71

const auto out_ptr = reinterpret_cast<int8_t *>(out.ptr());

72

73

// Compute S elements per iteration

74

int x = window_start_x;

75

svbool_t pg = svwhilelt_b8(x, window_end_x);

do

{

// Store results

svst1_s8(pg, out_ptr + x, svld1_s8(pg, in_ptr + offset + offset_row + x));

80

81

x += svcntw();

82

pg = svwhilelt_b8(x, window_end_x);

83

}

84

while(svptest_any(svptrue_b8(), pg));

},

out);

}

void qasymm8_signed_sve_scale_bilinear(const ITensor *src, ITensor *dst, const ITensor *offsets, const ITensor *dx, const ITensor *dy,

90

BorderMode border_mode, PixelValue constant_border_value, float sampling_offset,

91

bool align_corners, const Window &window)

92

{

93

// Get data layout and width/height indices

94

const DataLayout data_layout = src->info()->data_layout();

95

const int idx_width = get_data_layout_dimension_index(data_layout, DataLayoutDimension::WIDTH);

96

const int idx_height = get_data_layout_dimension_index(data_layout, DataLayoutDimension::HEIGHT);

97

98

// Compute the ratio between source height and destination height

99

const auto hr = scale_utils::calculate_resize_ratio(src->info()->dimension(idx_height), dst->info()->dimension(idx_height), align_corners);

100

Window win_off;

101

win_off.set(Window::DimX, Window::Dimension(0, 0, 0));

102

win_off.set(Window::DimY, Window::Dimension(0, 0, 0));

103

104

// Don't increment in X and Y direction for the input tensor

105

// A pointer to the start of this plane is needed as base for the precomputed offsets

106

Window win_in(window);

107

win_in.set(idx_width, Window::Dimension(0, 0, 0));

108

win_in.set(idx_height, Window::Dimension(0, 0, 0));

109

110

for(size_t d = Window::DimZ; d < offsets->info()->num_dimensions(); ++d)

111

{

112

win_off.set(d, Window::Dimension(0, 0, 0));

113

}

114

115

Iterator in(src, win_in);

116

Iterator out(dst, window);

117

118

const int32_t in_dim_w = src->info()->dimension(idx_width);

119

const int32_t in_dim_h = src->info()->dimension(idx_height);

120

const int32_t stride_w = src->info()->strides_in_bytes()[idx_width];

121

const int32_t stride_h = src->info()->strides_in_bytes()[idx_height];

122

123

const UniformQuantizationInfo iq_info = src->info()->quantization_info().uniform();

124

const UniformQuantizationInfo oq_info = dst->info()->quantization_info().uniform();

125

126

if(border_mode == BorderMode::CONSTANT)

127

{

128

const int8_t const_border_value = static_cast<int8_t>(constant_border_value.get<int8_t>());

129

execute_window_loop(window, [&](const Coordinates & id)

130

{

131

const int32_t index_h = std::floor((id[idx_height] + sampling_offset) * hr - sampling_offset);

132

const int32_t index_w = *(reinterpret_cast<const int32_t *>(offsets->ptr_to_element(Coordinates(id[idx_width], id[idx_height]))));

133

const auto dx_val = *(reinterpret_cast<const float *>(dx->ptr_to_element(Coordinates(id[idx_width], id[idx_height]))));

134

const auto dy_val = *(reinterpret_cast<const float *>(dy->ptr_to_element(Coordinates(id[idx_width], id[idx_height]))));

135

const auto pixel_row_ptr = reinterpret_cast<const int8_t *>(in.ptr());

136

137

const auto a00 = (0 <= index_w && index_w < in_dim_w && 0 <= index_h && index_h < in_dim_h) ?

138

(*(pixel_row_ptr + index_w * stride_w + index_h * stride_h)) :

139

const_border_value;

140

const auto a01 = (-1 <= index_w && index_w < in_dim_w - 1 && 0 <= index_h && index_h < in_dim_h) ?

141

(*(pixel_row_ptr + (index_w + 1) * stride_w + index_h * stride_h)) :

142

const_border_value;

143

const auto a10 = (0 <= index_w && index_w < in_dim_w && -1 <= index_h && index_h < in_dim_h - 1) ?

144

(*(pixel_row_ptr + index_w * stride_w + (index_h + 1) * stride_h)) :

145

const_border_value;

146

const auto a11 = (-1 <= index_w && index_w < in_dim_w - 1 && -1 <= index_h && index_h < in_dim_h - 1) ?

147

(*(pixel_row_ptr + (index_w + 1) * stride_w + (index_h + 1) * stride_h)) :

148

const_border_value;

149

150

const float inp00 = Qasymm8QuantizationHelper<int8_t>::dequantize(a00, iq_info);

151

const float inp01 = Qasymm8QuantizationHelper<int8_t>::dequantize(a01, iq_info);

152

const float inp10 = Qasymm8QuantizationHelper<int8_t>::dequantize(a10, iq_info);

153

const float inp11 = Qasymm8QuantizationHelper<int8_t>::dequantize(a11, iq_info);

154

*reinterpret_cast<int8_t *>(out.ptr()) = Qasymm8QuantizationHelper<int8_t>::quantize(scale_helpers::delta_bilinear(inp00, inp01, inp10, inp11, dx_val, dy_val), oq_info);

},

in, out);

}

else if(border_mode == BorderMode::REPLICATE)

159

{

160

execute_window_loop(window, [&](const Coordinates & id)

161

{

162

const int index_h = std::floor((id[idx_height] + sampling_offset) * hr - sampling_offset);

163

const int32_t index_w = *(reinterpret_cast<const int32_t *>(offsets->ptr_to_element(Coordinates(id[idx_width], id[idx_height]))));

164

const auto dx_val = *(reinterpret_cast<const float *>(dx->ptr_to_element(Coordinates(id[idx_width], id[idx_height]))));

165

const auto dy_val = *(reinterpret_cast<const float *>(dy->ptr_to_element(Coordinates(id[idx_width], id[idx_height]))));

166

const auto pixel_row_ptr = reinterpret_cast<const int8_t *>(in.ptr());

167

168

auto clamped_w = utility::clamp<int>(index_w, 0, in_dim_w - 1);

169

auto clamped_w1 = utility::clamp<int>(index_w + 1, 0, in_dim_w - 1);

170

auto clamped_h = utility::clamp<int>(index_h, 0, in_dim_h - 1);

171

auto clamped_h1 = utility::clamp<int>(index_h + 1, 0, in_dim_h - 1);

172

173

const auto a00 = *(pixel_row_ptr + clamped_w * stride_w + clamped_h * stride_h);

174

const auto a01 = *(pixel_row_ptr + clamped_w1 * stride_w + clamped_h * stride_h);

175

const auto a10 = *(pixel_row_ptr + clamped_w * stride_w + clamped_h1 * stride_h);

176

const auto a11 = *(pixel_row_ptr + clamped_w1 * stride_w + clamped_h1 * stride_h);

177

178

const float inp00 = Qasymm8QuantizationHelper<int8_t>::dequantize(a00, iq_info);

179

const float inp01 = Qasymm8QuantizationHelper<int8_t>::dequantize(a01, iq_info);

180

const float inp10 = Qasymm8QuantizationHelper<int8_t>::dequantize(a10, iq_info);

181

const float inp11 = Qasymm8QuantizationHelper<int8_t>::dequantize(a11, iq_info);

182

*reinterpret_cast<int8_t *>(out.ptr()) = Qasymm8QuantizationHelper<int8_t>::quantize(scale_helpers::delta_bilinear(inp00, inp01, inp10, inp11, dx_val, dy_val), oq_info);

},

in, out);

}

else

{

ARM_COMPUTE_ERROR("Not implemented");