Blame - src/core/NEON/kernels/NEDepthwiseConvolutionLayer3x3Kernel.cpp - ml/ComputeLibrary

AccessWindowStatic input_access(input->info(), -conv_pad_x, -conv_pad_y, (num_x_steps - 1) * input_num_elems_processed + 12, conv_stride_y * (expected_output.second - 1) + 2);

87

AccessWindowStatic weights_access(weights->info(), 0, 0, weights->info()->dimension(0), weights->info()->dimension(1));

88

AccessWindowStatic output_access(output->info(), 0, 0, num_x_steps * num_elems_written_per_iteration, expected_output.second);

Michalis Spyrou

7362f0d

2017-10-18 17:58:22 +0100

[diff] [blame]

89

90

update_window_and_padding(win, input_access, weights_access, output_access);

91

output_access.set_valid_region(win, ValidRegion(Coordinates(), output->info()->tensor_shape()));

92

93

INEKernel::configure(win);

94

}

95

96

template <unsigned int stridex>

class convolver_3x3

{

public:

static void convolve(const Window &window, unsigned int num_elems_written_per_iteration,

101

const ITensor *input, const ITensor *weights, ITensor *output, const PadStrideInfo &conv_info)

102

{

103

const int input_stride_x = input->info()->strides_in_bytes().x();

104

const int input_stride_y = input->info()->strides_in_bytes().y();

105

const int output_stride_y = output->info()->strides_in_bytes().y();

106

const int kernel_stride_y = weights->info()->strides_in_bytes().y();

107

const int kernel_stride_z = weights->info()->strides_in_bytes().z();

108

const int output_w = output->info()->dimension(0);

109

const int output_h = output->info()->dimension(1);

110

const int delta_input = get_input_num_elems_processed<stridex>(num_elems_written_per_iteration);

111

const unsigned int conv_stride_y = std::get<1>(conv_info.stride());

112

const unsigned int conv_pad_x = std::get<0>(conv_info.pad());

113

const unsigned int conv_pad_y = std::get<1>(conv_info.pad());

114

115

// setup output window for the iterator

116

Window window_out = window;

117

window_out.set(Window::DimX, Window::Dimension(0, output->info()->dimension(Window::DimX), output->info()->dimension(Window::DimX)));

118

window_out.set(Window::DimY, Window::Dimension(0, output->info()->dimension(Window::DimY), output->info()->dimension(Window::DimY)));

119

120

// setup input window for the iterator

121

Window window_in = window;

122

// we just want execute_window_loop to iterate over the dimensions > 2, so we set the first 2 dimensions to 0

123

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

124

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

125

126

Window window_k = calculate_max_window(*weights->info(), Steps(1u));

127

128

Iterator in(input, window_in);

129

Iterator out(output, window_out);

130

Iterator w(weights, window_k);

131

132

const uint8_t *weights_ptr = w.ptr();

133

134

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

135

{

136

const uint8_t *input_ptr = in.ptr() - conv_pad_x * input_stride_x - conv_pad_y * input_stride_y;

int ih = 0;

int oh = 0;

Anthony Barbier

2017-12-12 17:17:50 +0000

[diff] [blame]

140

const uint8_t *ptr_weights_base = weights_ptr + id.z() * kernel_stride_z;

141

const auto ptr_weights_r0 = reinterpret_cast<const float *>(ptr_weights_base);

142

const auto ptr_weights_r1 = reinterpret_cast<const float *>(ptr_weights_base + kernel_stride_y);

143

const auto ptr_weights_r2 = reinterpret_cast<const float *>(ptr_weights_base + kernel_stride_y * 2);

144

const float32x4x3_t vw_r0 = load_matrix_row(ptr_weights_r0);

145

const float32x4x3_t vw_r1 = load_matrix_row(ptr_weights_r1);

146

const float32x4x3_t vw_r2 = load_matrix_row(ptr_weights_r2);

Michalis Spyrou

7362f0d

2017-10-18 17:58:22 +0100

[diff] [blame]

147

148

for(ih = 0, oh = 0; oh < output_h; ++oh, ih += conv_stride_y)

149

{

150

auto in_top = reinterpret_cast<const float *>(input_ptr + (ih + 0) * input_stride_y);

151

auto in_mid = reinterpret_cast<const float *>(input_ptr + (ih + 1) * input_stride_y);

152

auto in_low = reinterpret_cast<const float *>(input_ptr + (ih + 2) * input_stride_y);

153

auto p_out = reinterpret_cast<float *>(out.ptr() + oh * output_stride_y);

154

155

for(int ow = 0; ow < output_w; ow += num_elems_written_per_iteration,

156

in_top += delta_input, in_mid += delta_input, in_low += delta_input, p_out += num_elems_written_per_iteration)

157

{

158

auto vres = convolve_3x3<stridex>(in_top, in_mid, in_low, vw_r0, vw_r1, vw_r2, 0);

159

store_results<stridex>(p_out, vres);

}

}

},

in, out);

}

};

Giorgio Arena

2017-11-23 11:45:24 +0000

[diff] [blame]

167

void NEDepthwiseConvolutionLayer3x3Kernel::run(const Window &window, const ThreadInfo &info)

Michalis Spyrou

7362f0d

2017-10-18 17:58:22 +0100

[diff] [blame]

168

{

169

ARM_COMPUTE_ERROR_ON_UNCONFIGURED_KERNEL(this);

170

ARM_COMPUTE_UNUSED(info);

171

172

const unsigned int conv_stride_x = _conv_info.stride().first;

173

const unsigned int num_elems_written_per_iteration = 16 >> conv_stride_x;

174

175

switch(conv_stride_x)

176

{

177

case 1:

178

convolver_3x3<1>::convolve(window, num_elems_written_per_iteration, _input, _weights, _output, _conv_info);

179

break;

180

case 2:

181

convolver_3x3<2>::convolve(window, num_elems_written_per_iteration, _input, _weights, _output, _conv_info);

182

break;

183

case 3:

184

convolver_3x3<3>::convolve(window, num_elems_written_per_iteration, _input, _weights, _output, _conv_info);

185

break;

186

default:

187

ARM_COMPUTE_ERROR("Not implemented");

188

}

189

}