You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@mxnet.apache.org by GitBox <gi...@apache.org> on 2018/05/11 21:43:21 UTC
[GitHub] szha closed pull request #10888: Fix thread local.
szha closed pull request #10888: Fix thread local.
URL: https://github.com/apache/incubator-mxnet/pull/10888
This is a PR merged from a forked repository.
As GitHub hides the original diff on merge, it is displayed below for
the sake of provenance:
As this is a foreign pull request (from a fork), the diff is supplied
below (as it won't show otherwise due to GitHub magic):
diff --git a/src/c_api/c_api_profile.cc b/src/c_api/c_api_profile.cc
index c946e3b6bd5..c5841775794 100644
--- a/src/c_api/c_api_profile.cc
+++ b/src/c_api/c_api_profile.cc
@@ -112,7 +112,11 @@ class ProfilingThreadData {
#endif // PROFILE_API_INCLUDE_AS_EVENT
};
+#if DMLC_CXX11_THREAD_LOCAL
static thread_local ProfilingThreadData thread_profiling_data;
+#else
+static MX_THREAD_LOCAL ProfilingThreadData thread_profiling_data;
+#endif
extern void on_enter_api(const char *function) {
if (profiler::Profiler::Get()->IsProfiling(profiler::Profiler::kAPI)) {
diff --git a/src/operator/nn/deconvolution.cu b/src/operator/nn/deconvolution.cu
index 1cabe732b6d..cdfb606900b 100644
--- a/src/operator/nn/deconvolution.cu
+++ b/src/operator/nn/deconvolution.cu
@@ -40,9 +40,15 @@ static CuDNNDeconvolutionOp<DType> &GetCuDNNDeconvOp(const DeconvolutionParam& p
const std::vector<TShape>& in_shape,
const std::vector<TShape>& out_shape,
const RunContext& rctx) {
+#if DMLC_CXX11_THREAD_LOCAL
static thread_local std::unordered_map<DeconvSignature,
std::shared_ptr<CuDNNDeconvolutionOp<DType> >,
OpHash> ops;
+#else
+ static MX_THREAD_LOCAL std::unordered_map<DeconvSignature,
+ std::shared_ptr<CuDNNDeconvolutionOp<DType> >,
+ OpHash> ops;
+#endif
DeconvSignature key(param);
size_t ndim = 0;
for (auto &s : in_shape)
diff --git a/src/operator/nn/dropout-inl.h b/src/operator/nn/dropout-inl.h
index 1af4798d1ce..8e4aac61354 100644
--- a/src/operator/nn/dropout-inl.h
+++ b/src/operator/nn/dropout-inl.h
@@ -375,7 +375,7 @@ void DropoutCompute(const nnvm::NodeAttrs& attrs,
const std::vector<TBlob>& outputs) {
const DropoutParam& param = nnvm::get<DropoutParam>(attrs.parsed);
MSHADOW_REAL_TYPE_SWITCH(inputs[0].type_flag_, DType, {
- static thread_local DropoutOp<xpu, DType> op;
+ DropoutOp<xpu, DType> op;
op.Init(param);
op.Forward(ctx, inputs, req, outputs);
});
@@ -397,7 +397,7 @@ void DropoutGradCompute(const nnvm::NodeAttrs& attrs,
out_data[dropout::kMask] = inputs[1];
MSHADOW_REAL_TYPE_SWITCH(inputs[0].type_flag_, DType, {
- static thread_local DropoutOp<xpu, DType> op;
+ DropoutOp<xpu, DType> op;
op.Init(param);
op.Backward(ctx, out_grads, out_data, req, outputs);
});
diff --git a/src/operator/nn/mkldnn/mkldnn_act.cc b/src/operator/nn/mkldnn/mkldnn_act.cc
index a057527d473..50e742d48fe 100644
--- a/src/operator/nn/mkldnn/mkldnn_act.cc
+++ b/src/operator/nn/mkldnn/mkldnn_act.cc
@@ -134,7 +134,11 @@ class MKLDNNActForward {
static MKLDNNActForward &GetActForward(const ActivationParam& param,
const OpContext &ctx, const NDArray &in_data,
const mkldnn::memory &in_mem) {
+#if DMLC_CXX11_THREAD_LOCAL
static thread_local std::unordered_map<MKLDNNActSignature, MKLDNNActForward, OpHash> fwds;
+#else
+ static MX_THREAD_LOCAL std::unordered_map<MKLDNNActSignature, MKLDNNActForward, OpHash> fwds;
+#endif
MKLDNNActSignature key(param);
key.AddSign(ctx.is_train);
key.AddSign(param.act_type);
diff --git a/src/operator/nn/mkldnn/mkldnn_base-inl.h b/src/operator/nn/mkldnn/mkldnn_base-inl.h
index 687b6efc69c..bd2faf5775a 100644
--- a/src/operator/nn/mkldnn/mkldnn_base-inl.h
+++ b/src/operator/nn/mkldnn/mkldnn_base-inl.h
@@ -232,7 +232,11 @@ class TmpMemMgr {
public:
static TmpMemMgr *Get() {
+#if DMLC_CXX11_THREAD_LOCAL
static thread_local TmpMemMgr mgr;
+#else
+ static MX_THREAD_LOCAL TmpMemMgr mgr;
+#endif
return &mgr;
}
diff --git a/src/operator/nn/mkldnn/mkldnn_base.cc b/src/operator/nn/mkldnn/mkldnn_base.cc
index 2528d097d7f..6406560e818 100644
--- a/src/operator/nn/mkldnn/mkldnn_base.cc
+++ b/src/operator/nn/mkldnn/mkldnn_base.cc
@@ -26,7 +26,11 @@
namespace mxnet {
MKLDNNStream *MKLDNNStream::Get() {
+#if DMLC_CXX11_THREAD_LOCAL
static thread_local MKLDNNStream stream;
+#else
+ static MX_THREAD_LOCAL MKLDNNStream stream;
+#endif
return &stream;
}
diff --git a/src/operator/nn/mkldnn/mkldnn_batch_norm-inl.h b/src/operator/nn/mkldnn/mkldnn_batch_norm-inl.h
index d1c80a63eee..9046836e8e7 100644
--- a/src/operator/nn/mkldnn/mkldnn_batch_norm-inl.h
+++ b/src/operator/nn/mkldnn/mkldnn_batch_norm-inl.h
@@ -184,7 +184,11 @@ template<typename DType>
static MKLDNNBNForward &GetBNForward(const BatchNormParam& param,
const OpContext &ctx, const NDArray &in_data,
unsigned flags) {
+#if DMLC_CXX11_THREAD_LOCAL
static thread_local std::unordered_map<MKLDNNBNSignature, MKLDNNBNForward, OpHash> fwds;
+#else
+ static MX_THREAD_LOCAL std::unordered_map<MKLDNNBNSignature, MKLDNNBNForward, OpHash> fwds;
+#endif
MKLDNNBNSignature key(param);
key.AddSign(ctx.is_train);
key.AddSign(in_data);
diff --git a/src/operator/nn/mkldnn/mkldnn_concat.cc b/src/operator/nn/mkldnn/mkldnn_concat.cc
index 240673de4ab..dbc0e94c630 100644
--- a/src/operator/nn/mkldnn/mkldnn_concat.cc
+++ b/src/operator/nn/mkldnn/mkldnn_concat.cc
@@ -75,7 +75,11 @@ class MKLDNNConcatFwd {
static MKLDNNConcatFwd &GetConcatForward(
int concat_dim, const std::vector<NDArray> &in_data,
const std::vector<mkldnn::memory::primitive_desc> &data_md) {
+#if DMLC_CXX11_THREAD_LOCAL
static thread_local std::unordered_map<OpSignature, MKLDNNConcatFwd, OpHash> fwds;
+#else
+ static MX_THREAD_LOCAL std::unordered_map<OpSignature, MKLDNNConcatFwd, OpHash> fwds;
+#endif
OpSignature key;
key.AddSign(concat_dim);
key.AddSign(in_data);
diff --git a/src/operator/nn/mkldnn/mkldnn_convolution.cc b/src/operator/nn/mkldnn/mkldnn_convolution.cc
index 1e09d208b98..f851a6d2535 100644
--- a/src/operator/nn/mkldnn/mkldnn_convolution.cc
+++ b/src/operator/nn/mkldnn/mkldnn_convolution.cc
@@ -229,7 +229,11 @@ static inline MKLDNNConvForward &GetConvFwd(
const nnvm::NodeAttrs& attrs, bool is_train,
const NDArray &data, const NDArray &weights,
const NDArray *bias, const NDArray &output) {
+#if DMLC_CXX11_THREAD_LOCAL
static thread_local std::unordered_map<MKLDNNConvSignature, MKLDNNConvForward, OpHash> fwds;
+#else
+ static MX_THREAD_LOCAL std::unordered_map<MKLDNNConvSignature, MKLDNNConvForward, OpHash> fwds;
+#endif
const ConvolutionParam& param = nnvm::get<ConvolutionParam>(attrs.parsed);
MKLDNNConvSignature key(param);
key.AddSign(is_train);
diff --git a/src/operator/nn/mkldnn/mkldnn_deconvolution.cc b/src/operator/nn/mkldnn/mkldnn_deconvolution.cc
index aedecdddb76..7f3676a70dd 100644
--- a/src/operator/nn/mkldnn/mkldnn_deconvolution.cc
+++ b/src/operator/nn/mkldnn/mkldnn_deconvolution.cc
@@ -260,8 +260,13 @@ static inline MKLDNNDeconvForward &GetDeconvFwd(
const nnvm::NodeAttrs& attrs, const NDArray &data,
const NDArray &weights, const NDArray *bias,
const NDArray &output) {
+#if DMLC_CXX11_THREAD_LOCAL
static thread_local
std::unordered_map<DeconvSignature, MKLDNNDeconvForward, OpHash> fwds;
+#else
+ static MX_THREAD_LOCAL
+ std::unordered_map<DeconvSignature, MKLDNNDeconvForward, OpHash> fwds;
+#endif
const DeconvolutionParam& param = nnvm::get<DeconvolutionParam>(attrs.parsed);
DeconvSignature key(param);
// Here we can sign the conv op with NDArray because conv primitive will
diff --git a/src/operator/nn/mkldnn/mkldnn_lrn-inl.h b/src/operator/nn/mkldnn/mkldnn_lrn-inl.h
index b0b715a9da0..adb72a2a9c4 100644
--- a/src/operator/nn/mkldnn/mkldnn_lrn-inl.h
+++ b/src/operator/nn/mkldnn/mkldnn_lrn-inl.h
@@ -149,9 +149,15 @@ void MKLDNNLRNFwd::Execute() {
static MKLDNNLRNFwd &GetLRNFwd(const LRNParam& param,
const OpContext &ctx,
const NDArray &in_data) {
+#if DMLC_CXX11_THREAD_LOCAL
static thread_local std::unordered_map<MKLDNNLRNSignature,
MKLDNNLRNFwd,
OpHash> lrn_fwds;
+#else
+ static MX_THREAD_LOCAL std::unordered_map<MKLDNNLRNSignature,
+ MKLDNNLRNFwd,
+ OpHash> lrn_fwds;
+#endif
auto alg_ = algorithm::lrn_across_channels;
auto kind_ = prop_kind::forward_training;
if (ctx.is_train) {
diff --git a/src/operator/nn/mkldnn/mkldnn_pooling.cc b/src/operator/nn/mkldnn/mkldnn_pooling.cc
index 1aeb7d48dc3..259af2b9402 100644
--- a/src/operator/nn/mkldnn/mkldnn_pooling.cc
+++ b/src/operator/nn/mkldnn/mkldnn_pooling.cc
@@ -186,9 +186,15 @@ MKLDNNPoolingFwd &GetPoolingFwd(const PoolingParam ¶m,
const bool is_train,
const NDArray &data,
const NDArray &output) {
+#if DMLC_CXX11_THREAD_LOCAL
static thread_local std::unordered_map<MKLDNNPoolingSignature,
MKLDNNPoolingFwd,
OpHash> pooling_fwds;
+#else
+ static MX_THREAD_LOCAL std::unordered_map<MKLDNNPoolingSignature,
+ MKLDNNPoolingFwd,
+ OpHash> pooling_fwds;
+#endif
bool with_workspace = is_train && MKLDNNRequireWorkspace(param);
MKLDNNPoolingSignature key(param);
diff --git a/src/operator/nn/pooling-inl.h b/src/operator/nn/pooling-inl.h
index a390dd0f053..5993bf5149d 100644
--- a/src/operator/nn/pooling-inl.h
+++ b/src/operator/nn/pooling-inl.h
@@ -183,18 +183,6 @@ class PoolingOp {
PoolingParam param_;
}; // class PoolingOp
-template<typename xpu, typename DType>
-PoolingOp<xpu, DType> &GetPoolingOp(const PoolingParam ¶m) {
- static thread_local PoolingOp<xpu, DType> op;
- // check if filter size assigned correctly
- if (param.global_pool == false) {
- CHECK_GT(param.kernel.ndim(), 0U)
- << "You need to set the kernel size if global pooling is not used";
- }
- op.Init(param);
- return op;
-}
-
template<typename xpu>
void PoolingCompute(const nnvm::NodeAttrs& attrs,
const OpContext& ctx,
@@ -204,11 +192,18 @@ void PoolingCompute(const nnvm::NodeAttrs& attrs,
const PoolingParam& param = nnvm::get<PoolingParam>(attrs.parsed);
CHECK_EQ(inputs.size(), 1U);
CHECK_EQ(outputs.size(), GetNumOutputs(param));
+ if (!param.global_pool) {
+ // check if filter size assigned correctly
+ CHECK_GT(param.kernel.ndim(), 0U)
+ << "You need to set the kernel size if global pooling is not used";
+ }
MSHADOW_REAL_TYPE_SWITCH(inputs[0].type_flag_, DType, {
if (pool_enum::kMaxPooling == param.pool_type
|| pool_enum::kAvgPooling == param.pool_type
|| pool_enum::kSumPooling == param.pool_type) {
- GetPoolingOp<xpu, DType>(param).Forward(ctx, inputs[0], req[0], outputs[0]);
+ PoolingOp<xpu, DType> op;
+ op.Init(param);
+ op.Forward(ctx, inputs[0], req[0], outputs[0]);
} else {
LOG(FATAL) << "unknown pooling type";
}
@@ -225,6 +220,11 @@ void PoolingGradCompute(const nnvm::NodeAttrs& attrs,
CHECK_EQ(inputs.size(), GetNumBackInputs(param));
CHECK_EQ(outputs.size(), 1U);
CHECK_EQ(req.size(), 1U);
+ if (!param.global_pool) {
+ // check if filter size assigned correctly
+ CHECK_GT(param.kernel.ndim(), 0U)
+ << "You need to set the kernel size if global pooling is not used";
+ }
off_t ograd_idx, in_data_idx, out_data_idx;
// When MKLDNN is enabled, the input data may contains arrays for workspace.
if (GetNumBackInputs(param) == 5) {
@@ -240,9 +240,10 @@ void PoolingGradCompute(const nnvm::NodeAttrs& attrs,
if (pool_enum::kMaxPooling == param.pool_type
|| pool_enum::kAvgPooling == param.pool_type
|| pool_enum::kSumPooling == param.pool_type) {
- GetPoolingOp<xpu, DType>(param).Backward(ctx, inputs[ograd_idx],
- inputs[in_data_idx], inputs[out_data_idx],
- req[0], outputs[0]);
+ PoolingOp<xpu, DType> op;
+ op.Init(param);
+ op.Backward(ctx, inputs[ograd_idx], inputs[in_data_idx],
+ inputs[out_data_idx], req[0], outputs[0]);
} else {
LOG(FATAL) << "unknown pooling type";
}
diff --git a/src/operator/nn/pooling.cu b/src/operator/nn/pooling.cu
index 17e6eb43a7a..2187fd87ca8 100644
--- a/src/operator/nn/pooling.cu
+++ b/src/operator/nn/pooling.cu
@@ -75,7 +75,9 @@ void PoolingCompute<gpu>(const nnvm::NodeAttrs& attrs,
if (pool_enum::kMaxPooling == param.pool_type
|| pool_enum::kAvgPooling == param.pool_type
|| pool_enum::kSumPooling == param.pool_type) {
- GetPoolingOp<gpu, DType>(param).Forward(ctx, inputs[0], req[0], outputs[0]);
+ PoolingOp<gpu, DType> op;
+ op.Init(param);
+ op.Forward(ctx, inputs[0], req[0], outputs[0]);
} else {
LOG(FATAL) << "unknown pooling type";
}
@@ -126,9 +128,10 @@ void PoolingGradCompute<gpu>(const nnvm::NodeAttrs& attrs,
if (pool_enum::kMaxPooling == param.pool_type
|| pool_enum::kAvgPooling == param.pool_type
|| pool_enum::kSumPooling == param.pool_type) {
- GetPoolingOp<gpu, DType>(param).Backward(ctx, inputs[ograd_idx],
- inputs[in_data_idx], inputs[out_data_idx],
- req[0], outputs[0]);
+ PoolingOp<gpu, DType> op;
+ op.Init(param);
+ op.Backward(ctx, inputs[ograd_idx], inputs[in_data_idx],
+ inputs[out_data_idx], req[0], outputs[0]);
} else {
LOG(FATAL) << "unknown pooling type";
}
----------------------------------------------------------------
This is an automated message from the Apache Git Service.
To respond to the message, please log on GitHub and use the
URL above to go to the specific comment.
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
With regards,
Apache Git Services