1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173
|
#ifndef CAFFE2_OPERATORS_INT8_CONV_TRANSPOSE_OP_H_
#define CAFFE2_OPERATORS_INT8_CONV_TRANSPOSE_OP_H_
#include <qnnpack.h>
#include "caffe2/core/context.h"
#include "caffe2/core/operator.h"
#include "caffe2/core/tensor_int8.h"
#include "caffe2/operators/conv_op_shared.h"
#include "caffe2/operators/conv_transpose_unpool_op_base.h"
#include "caffe2/operators/quantized/int8_utils.h"
namespace caffe2 {
namespace int8 {
class Int8ConvTransposeOp final : public ConvTransposeUnpoolBase<CPUContext> {
public:
USE_CONV_TRANSPOSE_UNPOOL_BASE_FUNCTIONS(CPUContext);
template <class... Args>
explicit Int8ConvTransposeOp(Args&&... args)
: ConvTransposeUnpoolBase(std::forward<Args>(args)...) {
OPERATOR_NEEDS_FEATURE(
this->order_ == StorageOrder::NHWC,
"Int8ConvTransposeOp only supports NHWC order");
createSharedBuffer<CPUContext>(ws_);
}
~Int8ConvTransposeOp() {
if (this->qnnpackObject_ != nullptr) {
qnnp_delete_operator(this->qnnpackObject_);
this->qnnpackObject_ = nullptr;
}
}
bool RunOnDeviceWithOrderNHWC() override {
CAFFE_ENFORCE_EQ(Inputs().size(), 3);
const auto& X = Inputs()[0]->template Get<Int8TensorCPU>();
const auto& W = Inputs()[1]->template Get<Int8TensorCPU>();
const auto& B = Inputs()[2]->template Get<Int8TensorCPU>();
auto* Y = Outputs()[0]->template GetMutable<Int8TensorCPU>();
const int32_t Y_offset =
this->template GetSingleArgument<int>("Y_zero_point", 0);
double Y_scale = this->template GetSingleArgument<float>("Y_scale", 1);
Y->scale = Y_scale;
Y->zero_point = Y_offset;
const auto IC = X.t.size(3);
TORCH_CHECK_EQ(IC, W.t.size(0));
const auto KH = W.t.size(1);
const auto KW = W.t.size(2);
const auto OC = W.t.size(3);
auto sizes = ConvTransposeUnpoolBase<CPUContext>::GetOutputSize(X.t, OC);
ReinitializeTensor(&(Y->t), sizes, at::dtype<uint8_t>().device(CPU));
TORCH_CHECK_EQ(OC, Y->t.size(3));
runWithSharedBuffer<CPUContext>(ws_, [&](Tensor* buffer) {
initQNNPACK();
#if !defined(FBCODE_CAFFE2) && defined(USE_INTERNAL_PTHREADPOOL_IMPL)
pthreadpool_t threadpool =
reinterpret_cast<pthreadpool_t>(ws_->GetThreadPool());
#endif
if (this->qnnpackObject_ == nullptr) {
const qnnp_status createStatus = qnnp_create_deconvolution2d_nhwc_q8(
pad_t(),
pad_r(),
pad_b(),
pad_l(),
adj_h(),
adj_w(),
KH,
KW,
stride_h(),
stride_w(),
1 /* dilation height */,
1 /* dilation width */,
1 /* groups */,
IC,
OC,
X.zero_point,
X.scale,
W.zero_point,
W.scale,
#ifndef _MSC_VER
W.t.template data<uint8_t>(),
B.t.template data<int32_t>(),
#else
W.t.data<uint8_t>(),
B.t.data<int32_t>(),
#endif
Y->zero_point,
Y->scale,
std::numeric_limits<uint8_t>::min(),
std::numeric_limits<uint8_t>::max(),
0 /* flags */,
&this->qnnpackObject_);
CAFFE_ENFORCE(
createStatus == qnnp_status_success,
"failed to create QNNPACK convolution object");
CAFFE_ENFORCE(this->qnnpackObject_ != nullptr);
}
uint8_t* inputPtr = X.t.template mutable_data<uint8_t>();
if (IC < 8) {
buffer->Resize(std::vector<int64_t>{X.t.numel() + 8});
inputPtr = buffer->template mutable_data<uint8_t>() + 8;
memcpy(inputPtr, X.t.template data<uint8_t>(), X.t.numel());
}
if (lastBatchSize_ != static_cast<size_t>(X.t.size(0)) ||
lastInputHeight_ != static_cast<size_t>(X.t.size(1)) ||
lastInputWidth_ != static_cast<size_t>(X.t.size(2)) ||
lastInputPointer_ != inputPtr ||
lastOutputPointer_ != Y->t.template mutable_data<uint8_t>()) {
const qnnp_status setupStatus = qnnp_setup_deconvolution2d_nhwc_q8(
this->qnnpackObject_,
X.t.size(0),
X.t.size(1),
X.t.size(2),
inputPtr,
X.t.size(3) /* input pixel stride */,
Y->t.template mutable_data<uint8_t>(),
Y->t.size(3) /* output pixel stride */,
nullptr /* threadpool */);
CAFFE_ENFORCE(
setupStatus == qnnp_status_success,
"failed to setup QNNPACK convolution object");
lastBatchSize_ = static_cast<size_t>(X.t.size(0));
lastInputHeight_ = static_cast<size_t>(X.t.size(1));
lastInputWidth_ = static_cast<size_t>(X.t.size(2));
lastInputPointer_ = inputPtr;
lastOutputPointer_ = Y->t.template mutable_data<uint8_t>();
}
#if defined(FBCODE_CAFFE2) || !defined(USE_INTERNAL_PTHREADPOOL_IMPL)
const qnnp_status runStatus =
qnnp_run_operator(this->qnnpackObject_, nullptr /* thread pool */);
#else
const qnnp_status runStatus =
qnnp_run_operator(this->qnnpackObject_, threadpool);
#endif
CAFFE_ENFORCE(
runStatus == qnnp_status_success,
"failed to run QNNPACK convolution");
});
return true;
}
private:
// QNNPACK convolution object
qnnp_operator_t qnnpackObject_{nullptr};
// batch size in the previous call to RunOnDeviceWithOrderNHWC
size_t lastBatchSize_{0};
// input height in the previous call to RunOnDeviceWithOrderNHWC
size_t lastInputHeight_{0};
// input width in the previous call to RunOnDeviceWithOrderNHWC
size_t lastInputWidth_{0};
// input pointer in the previous call to RunOnDeviceWithOrderNHWC
const void* lastInputPointer_{nullptr};
// output pointer in the previous call to RunOnDeviceWithOrderNHWC
void* lastOutputPointer_{nullptr};
};
} // namespace int8
} // namespace caffe2
#endif // CAFFE2_OPERATORS_INT8_CONV_TRANSPOSE_OP_H_
|