wangwei
/
MegEngine
Not watched
1
0
Fork 0
Code
Releases 31 Wiki Activity
Issues 0 Pull Requests 0 Datasets Model Cloudbrain
Browse Source

fix(dnn/fallbackls): delete the conv_bias fallback offset 

GitOrigin-RevId: c91aee2c7c
tags/v0.3.2
Megvii Engine Team 5 years ago
parent
a7e28712b5
commit
d346c87836
4 changed files with 189 additions and 93 deletions
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. +45
    -33
      dnn/src/fallback/conv_bias/im2col/algos.cpp
  2. +120
    -55
      dnn/src/fallback/conv_bias/opr_impl.cpp
  3. +15
    -0
      dnn/src/fallback/conv_bias/opr_impl.h
  4. +9
    -5
      dnn/src/fallback/conv_bias/winograd/winograd.h

+ 45
- 33
dnn/src/fallback/conv_bias/im2col/algos.cpp View File

@@ -57,11 +57,12 @@ public:
const ConvBiasImpl::NCBKernParam& param,
const WorkspaceBundle& bundle_thread, size_t bundle_id,
size_t oc_cur_index, size_t OHW, bool is_dst_8bit,
bool ohw_bigger_ohwblock) {
bool ohw_bigger_ohwblock, size_t batch_id, size_t group_id) {
if (is_dst_8bit || !ohw_bigger_ohwblock) {
return static_cast<dtype*>(bundle_thread.get(bundle_id));
} else {
dtype* dst = param.dst<dtype>() + oc_cur_index * OHW;
dtype* dst =
param.dst<dtype>(batch_id, group_id) + oc_cur_index * OHW;
return static_cast<dtype*>(dst);
}
}
@@ -105,23 +106,24 @@ static void copy_padding_kern(WorkspaceBundle bundle,

size_t IW2 = IW + 2 * PW;
size_t IH2 = IH + 2 * PH;
size_t group_id = ncb_index.ndrange_id[0];
size_t batch_id = ncb_index.ndrange_id[1];
size_t channel_id = ncb_index.ndrange_id[2];

size_t padding_group_size = IH2 * IW2 * IC;
size_t input_channel_offset = IH * IW * ncb_index.ndrange_id[2];
size_t workspace_channel_offset = IH2 * IW2 * ncb_index.ndrange_id[2];
size_t workspace_group_offset =
ncb_index.ndrange_id[0] * padding_group_size;
size_t workspace_batch_offset = param.filter_meta.group *
ncb_index.ndrange_id[1] *
padding_group_size;
size_t input_channel_offset = IH * IW * channel_id;
size_t workspace_channel_offset = IH2 * IW2 * channel_id;
size_t workspace_group_offset = group_id * padding_group_size;
size_t workspace_batch_offset =
param.filter_meta.group * batch_id * padding_group_size;
bundle.set(param.workspace_ptr);

src_ctype src_zp = static_cast<src_ctype>(0);
if (param.src_type.enumv() == DTypeEnum::Quantized8Asymm) {
src_zp = param.src_type.param<dtype::Quantized8Asymm>().zero_point;
}
src_ctype* src = const_cast<src_ctype*>(param.src<src_ctype>() +
input_channel_offset);
src_ctype* src = const_cast<src_ctype*>(
param.src<src_ctype>(batch_id, group_id) + input_channel_offset);
src_ctype* src2;
src2 = static_cast<src_ctype*>(
bundle.get(Im2colBundelIndex::BUNDLE_PADDING_INDEX)) +
@@ -153,8 +155,8 @@ static void copy_padding_kern(WorkspaceBundle bundle,
*/

#define COPY_BIAS() \
const bias_ctype* bias_ptr = \
static_cast<const bias_ctype*>(param.bias_ptr); \
const bias_ctype* bias_ptr = static_cast<const bias_ctype*>( \
param.bias<bias_ctype>(batch_id, group_id)); \
bias_ctype* bias_temp_ptr = \
PtrGetter::get_bias_temp_ptr<bias_ctype>(param, bundle_thread); \
if (param.bias_mode == megdnn::BiasMode::BIAS) { \
@@ -172,7 +174,8 @@ static void copy_padding_kern(WorkspaceBundle bundle,
#define IM2COL() \
src_ctype* im2col_dst = nullptr; \
src_ctype* no_padding_src = \
const_cast<src_ctype*>(param.src<src_ctype>()) + ohw_cur_index; \
const_cast<src_ctype*>(param.src<src_ctype>(batch_id, group_id)) + \
ohw_cur_index; \
if (!special_1x1) { \
size_t padding_group_size = IH2 * IW2 * IC * sizeof(src_ctype); \
src_ctype* src2 = PtrGetter::get_bundle_offset_byte_ptr<src_ctype>( \
@@ -181,7 +184,8 @@ static void copy_padding_kern(WorkspaceBundle bundle,
param.filter_meta.group * ncb_index.ndrange_id[1]) * \
padding_group_size); \
if (PH == 0 && PW == 0) { \
src2 = const_cast<src_ctype*>(param.src<src_ctype>()); \
src2 = const_cast<src_ctype*>( \
param.src<src_ctype>(batch_id, group_id)); \
} \
im2col_dst = static_cast<src_ctype*>(bundle_thread.get( \
Im2colBundelIndex::THREAD_BUNDLE_IM2COL_INDEX)); \
@@ -217,8 +221,8 @@ static void copy_padding_kern(WorkspaceBundle bundle,
output_block_size); \
if (!skip_copy_dst) { \
dst_ctype* dst_tmp_ptr = reinterpret_cast<dst_ctype*>(matmul_dst); \
dst_ctype* dst = \
param.dst<dst_ctype>() + oc_cur_index * OHW + ohw_cur_index; \
dst_ctype* dst = param.dst<dst_ctype>(batch_id, group_id) + \
oc_cur_index * OHW + ohw_cur_index; \
for (size_t oc = 0; oc < output_block_oc_size; oc++) { \
std::memcpy(dst, dst_tmp_ptr, \
sizeof(dst_ctype) * output_block_size); \
@@ -243,7 +247,7 @@ static void copy_padding_kern(WorkspaceBundle bundle,
bias_ctype* matmul_dst = PtrGetter::get_matmul_dst_ptr<bias_ctype>( \
param, bundle_thread, \
Im2colBundelIndex::THREAD_BUNDLE_IM2COL_INDEX, oc_cur_index, OHW, \
is_dst_8bit, is_ohw_size_bigger);
is_dst_8bit, is_ohw_size_bigger, batch_id, group_id);

#define MATMUL_COMPUTE() \
auto matmul_kern_naked = matmul_algo->get_kern_naked(matmul_param); \
@@ -272,6 +276,7 @@ public:
ConvBiasImpl::NCBKernIndex ncb_index) {
bundle.set(param.workspace_ptr);
fallback::MatrixMulImpl::KernParam matmul_param;
size_t group_id = ncb_index.ndrange_id[0];
static_cast<fallback::MatrixMulImpl::KernSizeParam&>(matmul_param) =
matmulparam;
size_t packA_group_size =
@@ -283,11 +288,11 @@ public:
matmul_algo->get_packA_type_size();
size_t a_panel_offset =
ncb_index.ndrange_id[2] * packed_per_oc_block_size;
int8_t* a_panel =
static_cast<int8_t*>(
bundle.get(Im2colBundelIndex::BUNDLE_PACKA_INDEX)) +
ncb_index.ndrange_id[0] * packA_group_size + a_panel_offset;
matmul_param.A_ptr = const_cast<src_ctype*>(param.filter<src_ctype>());
int8_t* a_panel = static_cast<int8_t*>(bundle.get(
Im2colBundelIndex::BUNDLE_PACKA_INDEX)) +
group_id * packA_group_size + a_panel_offset;
matmul_param.A_ptr =
const_cast<src_ctype*>(param.filter<src_ctype>(group_id));
matmul_algo->pack_A(matmul_param, a_panel, ncb_index.ndrange_id[2],
matmul_algo->get_inner_block_size().m);
};
@@ -309,6 +314,8 @@ public:
auto IH2 = IH + 2 * PH;
auto IW2 = IW + 2 * PW;
size_t OHW = OH * OW;
size_t group_id = ncb_index.ndrange_id[0];
size_t batch_id = ncb_index.ndrange_id[1];
size_t output_block_size = std::min(
ohw_tile_size, OHW - ncb_index.ndrange_id[2] * ohw_tile_size);
size_t output_block_oc_size = std::min(
@@ -369,11 +376,11 @@ public:
\
src_ctype* a_panel = PtrGetter::get_bundle_offset_byte_ptr<src_ctype>( \
bundle, Im2colBundelIndex::BUNDLE_PACKA_INDEX, \
ncb_index.ndrange_id[0] * packA_group_size + a_panel_offset); \
group_id * packA_group_size + a_panel_offset); \
matmul_dst = PtrGetter::get_matmul_dst_ptr<bias_ctype>( \
param, bundle_thread, \
Im2colBundelIndex::THREAD_BUNDLE_MATMUL_DST_INDEX, oc_cur_index, \
OHW, is_dst_8bit, is_ohw_size_bigger);
OHW, is_dst_8bit, is_ohw_size_bigger, batch_id, group_id);

#define MATMUL_COMPUTE() \
auto matmul_kern_naked = matmul_algo->get_kern_naked(matmul_param); \
@@ -402,6 +409,7 @@ public:
matmulparam;
size_t OC = param.filter_meta.ocpg;
size_t oc_tile_size = matmul_param.M;
size_t group_id = ncb_index.ndrange_id[0];
size_t output_block_oc_size = std::min(
oc_tile_size, OC - ncb_index.ndrange_id[2] * oc_tile_size);
size_t oc_cur_index = ncb_index.ndrange_id[2] * oc_tile_size;
@@ -411,12 +419,12 @@ public:
size_t a_panel_offset =
ncb_index.ndrange_id[2] *
matmul_algo->get_bundle(matmul_param).get_size(0);
int8_t* a_panel =
static_cast<int8_t*>(
bundle.get(Im2colBundelIndex::BUNDLE_PACKA_INDEX)) +
ncb_index.ndrange_id[0] * packA_group_size + a_panel_offset;
matmul_param.A_ptr = const_cast<src_ctype*>(param.filter<src_ctype>()) +
oc_cur_index * matmul_param.K;
int8_t* a_panel = static_cast<int8_t*>(bundle.get(
Im2colBundelIndex::BUNDLE_PACKA_INDEX)) +
group_id * packA_group_size + a_panel_offset;
matmul_param.A_ptr =
const_cast<src_ctype*>(param.filter<src_ctype>(group_id)) +
oc_cur_index * matmul_param.K;
matmul_param.M = output_block_oc_size;
matmul_algo->pack_A(matmul_param, a_panel, 0_z, 0_z);
};
@@ -437,6 +445,8 @@ public:
MEGDNN_MARK_USED_VAR(N);
auto IH2 = IH + 2 * PH;
auto IW2 = IW + 2 * PW;
size_t group_id = ncb_index.ndrange_id[0];
size_t batch_id = ncb_index.ndrange_id[1];
size_t OHW = OH * OW;
size_t output_block_size = std::min(
ohw_tile_size, OHW - ncb_index.ndrange_id[2] * ohw_tile_size);
@@ -490,11 +500,11 @@ public:
#define PREPAR_MATMUL_DATA() \
bias_ctype* matmul_dst = nullptr; \
const src_ctype* filter = \
param.filter<src_ctype>() + oc_cur_index * IC * FH * FW; \
param.filter<src_ctype>(group_id) + oc_cur_index * IC * FH * FW; \
matmul_dst = PtrGetter::get_matmul_dst_ptr<bias_ctype>( \
param, bundle_thread, \
Im2colBundelIndex::THREAD_BUNDLE_MATMUL_DST_INDEX, oc_cur_index, \
OHW, is_dst_8bit, is_ohw_size_bigger);
OHW, is_dst_8bit, is_ohw_size_bigger, batch_id, group_id);

#define MATMUL_COMPUTE() \
matmul_param.M = output_block_oc_size; \
@@ -526,6 +536,8 @@ public:
MEGDNN_MARK_USED_VAR(N);
auto IH2 = IH + 2 * PH;
auto IW2 = IW + 2 * PW;
size_t group_id = ncb_index.ndrange_id[0];
size_t batch_id = ncb_index.ndrange_id[1];
size_t OHW = OH * OW;
size_t output_block_size = std::min(
ohw_tile_size, OHW - ncb_index.ndrange_id[2] * ohw_tile_size);


+ 120
- 55
dnn/src/fallback/conv_bias/opr_impl.cpp View File

@@ -245,65 +245,10 @@ ConvBiasImpl::NCBKernParam ConvBiasImpl::make_ncb_kern_param(
void ConvBiasImpl::exec_with_ncb_kern(const NCBKernParam& param,
ConvBiasImpl::Algorithm* algo) {
auto ncb_kerns = ncb_algo_dispatch_kerns(algo, param);
size_t src_batch_stride = param.inp_bs * param.src_type.size();
size_t dst_batch_stride = param.out_bs * param.dst_type.size();
size_t bias_batch_stride = 0;
if (param.bias_mode == BiasMode::BIAS) {
bias_batch_stride = param.bias_bs * param.bias_type.size();
}
for (auto&& kernel : ncb_kerns) {
megdnn_assert(
param.filter_meta.format == Param::Format::NCHW ||
param.filter_meta.format == Param::Format::NHWC ||
param.filter_meta.format ==
Param::Format::NCHW_WINOGRAD ||
param.filter_meta.format == Param::Format::NCHW88 ||
param.filter_meta.format ==
Param::Format::NCHW88_WINOGRAD,
"invalid conv format");
ptrdiff_t istrd = 0, fstrd = 0, bstrd = 0, ostrd = 0;
if (param.filter_meta.format == Param::Format::NCHW_WINOGRAD ||
param.filter_meta.format == Param::Format::NCHW88_WINOGRAD) {
fstrd = param.filter_meta.icpg * param.filter_meta.ocpg *
(param.filter_meta.spatial[0] + param.output_block_size -
1) *
(param.filter_meta.spatial[1] + param.output_block_size -
1) *
param.filter_type.size();
} else {
fstrd = param.filter_meta.icpg * param.filter_meta.ocpg *
param.filter_meta.spatial[0] *
param.filter_meta.spatial[1] * param.filter_type.size();
}
istrd = param.filter_meta.icpg * param.src_type.size();
ostrd = param.filter_meta.ocpg * param.dst_type.size();
if (param.bias_mode != BiasMode::NO_BIAS) {
bstrd = param.filter_meta.ocpg * param.bias_type.size();
}
if (param.filter_meta.format == Param::Format::NCHW ||
param.filter_meta.format == Param::Format::NCHW_WINOGRAD ||
param.filter_meta.format == Param::Format::NCHW88_WINOGRAD) {
istrd *= param.isz[0] * param.isz[1];
ostrd *= param.osz[0] * param.osz[1];
if (param.bias_mode == BiasMode::BIAS) {
bstrd *= param.osz[0] * param.osz[1];
}
} else {
// must be NHWC. No action performed.
}
auto run = [=](size_t index, size_t thread_id) {
auto copy_param = param;
CpuNDRange ndrange_id(kernel.global_size, index);
size_t group_id = ndrange_id[0];
size_t batch_id = ndrange_id[1];
//! The kernel ptr point to batch index
incr_ptr(copy_param.src_ptr,
group_id * istrd + batch_id * src_batch_stride);
incr_ptr(copy_param.filter_ptr, group_id * fstrd);
incr_ptr(copy_param.bias_ptr,
group_id * bstrd + batch_id * bias_batch_stride);
incr_ptr(copy_param.dst_ptr,
group_id * ostrd + batch_id * dst_batch_stride);
kernel.kern(copy_param, {thread_id, ndrange_id});
};
static_cast<naive::HandleImpl*>(handle())->dispatch_kern(
@@ -381,4 +326,124 @@ const char* ConvBiasImpl::get_algorithm_set_name() const {
return "F0";
}

namespace megdnn{
namespace fallback {
//! when format is nchwxx and channel wise mode, multi group will pack
//! together, so pack_group_size is the number of packed group
template <typename T>
const T* ConvBiasImpl::NCBKernParam::src(size_t batch_id, size_t group_id,
size_t group_pack_size) const {
src_type.assert_is_compatible_ctype<T>();
size_t batch_offset = batch_id * inp_bs * src_type.size();
size_t group_offset = group_pack_size * group_id * filter_meta.icpg *
isz[0] * isz[1] * src_type.size();
return reinterpret_cast<T*>(reinterpret_cast<ptrdiff_t>(src_ptr) +
batch_offset + group_offset);
}

//! when format is nchwxx and channel wise mode, multi group will pack
//! together, so pack_group_size is the number of packed group
template <typename T>
const T* ConvBiasImpl::NCBKernParam::filter(size_t group_id,
size_t pack_group_size) const {
size_t group_offset = 0_z;
switch (filter_meta.format) {
case Param::Format::NCHW: {
group_offset = pack_group_size * group_id * filter_meta.icpg *
filter_meta.ocpg * filter_meta.spatial[0] *
filter_meta.spatial[1] * filter_type.size();
break;
}
case Param::Format::NCHW88: {
size_t group = filter_meta.group;
size_t icpg = filter_meta.icpg;
size_t ocpg = filter_meta.ocpg;
//! four format of weight layout
//! 1. {oc/8, ic/8, fh, fw, 8, 8}, 2. {g, oc/8, ic/8, fh,
//! fw, 8, 8}
//! 3. {g/8, 1, 1, fh, fw, 8, 8}, 3. {oc/8 ,fh, fw, ic, 8}
megdnn_assert((icpg % 8 == 0 && ocpg % 8 == 0) ||
(group % 8 == 0 && icpg == 1 && ocpg == 1 &&
pack_group_size > 1) ||
(group == 1 && ocpg % 8 == 0),
"The filter shepe is not right of nchw88");
group_offset = pack_group_size * group_id * filter_meta.icpg *
filter_meta.ocpg * filter_meta.spatial[0] *
filter_meta.spatial[1] * filter_type.size();

break;
}
case ConvBiasImpl::Param::Format::NCHW_WINOGRAD:
case ConvBiasImpl::Param::Format::NCHW88_WINOGRAD: {
//! four format of weight layout
//! 1. {g, alpha, alpha, ocpg/8, icpg/8, 8, 8}
//! 2. {alpha, alpha, ocpg/8, icpg/8, 8, 8}
//! 3. {g, alpha, alpha, oc, ic, 8, 8}
//! 4. {alpha, alpha, oc, ic}
group_offset = pack_group_size * group_id * filter_meta.icpg *
filter_meta.ocpg *
(filter_meta.spatial[0] + output_block_size - 1) *
(filter_meta.spatial[1] + output_block_size - 1) *
filter_type.size();
break;
}
default:
megdnn_assert("other filter format is not support yet");
}
return reinterpret_cast<T*>(reinterpret_cast<ptrdiff_t>(filter_ptr) +
group_offset);
}

//! when format is nchwxx and channel wise mode, multi group will pack
//! together, so pack_group_size is the number of packed group
template <typename T>
const T* ConvBiasImpl::NCBKernParam::bias(size_t batch_id, size_t group_id,
size_t group_pack_size) const {
bias_type.assert_is_compatible_ctype<T>();
size_t batch_offset = 0_z;
size_t group_offset = 0_z;
if (bias_mode == BiasMode::BIAS) {
batch_offset = batch_id * bias_bs * bias_type.size();
group_offset = group_pack_size * group_id * filter_meta.ocpg * osz[0] *
osz[1] * bias_type.size();
} else if (bias_mode == BiasMode::BROADCAST_CHANNEL_BIAS) {
group_offset = group_pack_size * group_id * filter_meta.ocpg *
bias_type.size();
}
return reinterpret_cast<T*>(reinterpret_cast<ptrdiff_t>(bias_ptr) +
batch_offset + group_offset);
}

//! when format is nchwxx and channel wise mode, multi group will pack
//! together, so pack_group_size is the number of packed group
template <typename T>
T* ConvBiasImpl::NCBKernParam::dst(size_t batch_id, size_t group_id,
size_t group_pack_size) const {
dst_type.assert_is_compatible_ctype<T>();
size_t batch_offset = batch_id * out_bs * dst_type.size();
size_t group_offset = group_pack_size * group_id * filter_meta.ocpg *
osz[0] * osz[1] * dst_type.size();
return reinterpret_cast<T*>(reinterpret_cast<ptrdiff_t>(dst_ptr) +
batch_offset + group_offset);
}

#define INST(T) \
template const T* ConvBiasImpl::NCBKernParam::src<T>( \
size_t batch_id, size_t group_id, size_t group_pack_size) const; \
template const T* ConvBiasImpl::NCBKernParam::bias<T>( \
size_t batch_id, size_t group_id, size_t group_pack_size) const; \
template const T* ConvBiasImpl::NCBKernParam::filter<T>( \
size_t group_id, size_t group_pack_size) const; \
template T* ConvBiasImpl::NCBKernParam::dst<T>( \
size_t batch_id, size_t group_id, size_t group_pack_size) const;

#define INST_DT(d) INST(DTypeTrait<d>::ctype)

MEGDNN_FOREACH_COMPUTING_DTYPE(INST_DT)
#undef INST
#undef INST_DT
} // namespace fallback
} // namespace megdnn


// vim: syntax=cpp.doxygen

+ 15
- 0
dnn/src/fallback/conv_bias/opr_impl.h View File

@@ -104,24 +104,39 @@ public:
return static_cast<const T*>(src_ptr);
}

template <typename T>
const T* src(size_t batch_id, size_t group_id,
size_t group_pack_size = 1_z) const;

template <typename T>
const T* filter() const {
filter_type.assert_is_compatible_ctype<T>();
return static_cast<const T*>(filter_ptr);
}

template <typename T>
const T* filter(size_t group_id, size_t pack_group_size = 1_z) const;

template <typename T>
const T* bias() const {
bias_type.assert_is_compatible_ctype<T>();
return static_cast<const T*>(bias_ptr);
}

template <typename T>
const T* bias(size_t batch_id, size_t group_id,
size_t group_pack_size = 1_z) const;

template <typename T>
T* dst() const {
dst_type.assert_is_compatible_ctype<T>();
return static_cast<T*>(dst_ptr);
}

template <typename T>
T* dst(size_t batch_id, size_t group_id,
size_t group_pack_size = 1_z) const;

template <typename T>
T* workspace() const {
return static_cast<T*>(workspace_ptr);


+ 9
- 5
dnn/src/fallback/conv_bias/winograd/winograd.h View File

@@ -210,7 +210,7 @@ public:
reinterpret_cast<input_filter_compute_type*>(
reinterpret_cast<uintptr_t>(bundle_compute.get(2)) +
compute_workspace_size_per_thread * thread_id);
const stype* filter_ptr = kern_param.filter<stype>();
const stype* filter_ptr = kern_param.filter<stype>(group_id);
size_t oc_start = oc_id, oc_end = oc_id+1;
if (kern_param.filter_meta.format == param::ConvBias::Format::NCHW88) {
oc_start = 8 * oc_id;
@@ -246,16 +246,19 @@ public:

size_t oc_block_id = ncb_index.ndrange_id[3];
size_t tile_id = ncb_index.ndrange_id[2];
size_t batch_id = ncb_index.ndrange_id[1];
size_t group_id = ncb_index.ndrange_id[0];
size_t thread_id = ncb_index.thread_id;

bundle_top.set(ncb_param.workspace_ptr);
bundle_compute.set(bundle_top.get(0));

const stype* src_ptr = ncb_param.src<stype>();
dst_type* dst_ptr = ncb_param.dst<dst_type>();
const stype* src_ptr = ncb_param.src<stype>(batch_id, group_id);
dst_type* dst_ptr = ncb_param.dst<dst_type>(batch_id, group_id);
const output_compute_type* bias_ptr =
static_cast<const output_compute_type*>(ncb_param.bias_ptr);
static_cast<const output_compute_type*>(
ncb_param.bias<output_compute_type>(batch_id,
group_id));

input_filter_compute_type* input_transform_buf =
reinterpret_cast<input_filter_compute_type*>(
@@ -271,9 +274,10 @@ public:
reinterpret_cast<uintptr_t>(bundle_compute.get(2)) +
compute_workspace_size_per_thread * thread_id);

//! NCHW88_WINOGRAD and NCHW_WINOGRAD is the same offset
const input_filter_compute_type* filter_transform_buf =
static_cast<const input_filter_compute_type*>(
ncb_param.filter_ptr);
ncb_param.filter<input_filter_compute_type>(group_id));
if (ncb_param.filter_meta.format == param::ConvBias::Format::NCHW ||
ncb_param.filter_meta.format == param::ConvBias::Format::NCHW88) {
filter_transform_buf = reinterpret_cast<input_filter_compute_type*>(


Write Preview
Loading…
Cancel
Save