Skip to content
This repository has been archived by the owner on Nov 17, 2023. It is now read-only.

support mkl log when dtype is fp32 or fp64 #13150

Merged
merged 6 commits into from
Dec 14, 2018
Merged

support mkl log when dtype is fp32 or fp64 #13150

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
6 commits
Select commit Hold shift + click to select a range
96f7ab3
support mkl log when dtype is fp32 or fp64
XiaotaoChen Nov 1, 2018
49b89e4
remove macro
XiaotaoChen Dec 10, 2018
2ba108f
ensure data size less than or equal MKL_INT_MAX
XiaotaoChen Dec 11, 2018
e70998e
code specification
XiaotaoChen Dec 12, 2018
9206a72
fix indent
XiaotaoChen Dec 13, 2018
faf4fef
for retrigger
XiaotaoChen Dec 14, 2018
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
41 changes: 41 additions & 0 deletions src/operator/tensor/elemwise_unary_op.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -29,11 +29,15 @@
#include <vector>
#include <utility>
#include <algorithm>
#include <climits>
#include "./cast_storage-inl.h"
#include "../mshadow_op.h"
#include "../mxnet_op.h"
#include "../elemwise_op_common.h"
#include "../../ndarray/ndarray_function.h"
#if MSHADOW_USE_MKL == 1
#include "mkl.h"
#endif

namespace mxnet {
namespace op {
Expand Down Expand Up @@ -348,6 +352,43 @@ class UnaryOp : public OpBase {
LogUnimplementedOp(attrs, ctx, inputs, req, outputs);
}
}

#if MSHADOW_USE_MKL == 1
static inline void MKLLog(MKL_INT size, const float* pIn, float* pOut) {
vsLn(size, pIn, pOut);
}

static inline void MKLLog(MKL_INT size, const double* pIn, double* pOut) {
vdLn(size, pIn, pOut);
}
#endif

template<typename xpu, typename OP>
static void LogCompute(const nnvm::NodeAttrs& attrs,
TaoLv marked this conversation as resolved.
Show resolved Hide resolved
const OpContext& ctx,
const std::vector<TBlob>& inputs,
const std::vector<OpReqType>& req,
const std::vector<TBlob>& outputs) {
if (req[0] == kNullOp) return;
// if defined MSHADOW_USE_MKL then call mkl log when req is KWriteTo, type_flag
// is mshadow::kFloat32 or mshadow::kFloat64 and data size less than or equal MKL_INT_MAX
#if MSHADOW_USE_MKL == 1
auto type_flag = inputs[0].type_flag_;
const size_t MKL_INT_MAX = (sizeof(MKL_INT) == sizeof(int)) ? INT_MAX : LLONG_MAX;
size_t input_size = inputs[0].Size();
if (req[0] == kWriteTo &&
input_size <= MKL_INT_MAX &&
(type_flag == mshadow::kFloat32 || type_flag == mshadow::kFloat64)) {
MSHADOW_SGL_DBL_TYPE_SWITCH(type_flag, DType, {
MKLLog(input_size, inputs[0].dptr<DType>(), outputs[0].dptr<DType>());
});
} else {
Compute<xpu, OP>(attrs, ctx, inputs, req, outputs);
}
#else
Compute<xpu, OP>(attrs, ctx, inputs, req, outputs);
#endif
}
};

/*! \brief Map legacy unary_bwd to backward_grad */
Expand Down
3 changes: 2 additions & 1 deletion src/operator/tensor/elemwise_unary_op_basic.cc
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -940,7 +940,7 @@ The storage type of ``exp`` output is always dense
.set_attr<nnvm::FGradient>("FGradient", ElemwiseGradUseOut{"_mul"});

// log
MXNET_OPERATOR_REGISTER_UNARY_WITH_SPARSE_DR(log, cpu, mshadow_op::log)
MXNET_OPERATOR_REGISTER_UNARY(log)
Copy link
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Sorry, I do not understand this change. Can you please explain?

Copy link
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

the defination of MXNET_OPERATOR_REGISTER_UNARY_WITH_SPARSE_DR in elemwise_unary_op.h is here:

#define MXNET_OPERATOR_REGISTER_UNARY_WITH_SPARSE_DR(__name$, __xpu$, __kernel$)        \
  MXNET_OPERATOR_REGISTER_UNARY(__name$)                                                \
  .set_attr<FCompute>("FCompute<" #__xpu$ ">", UnaryOp::Compute<__xpu$, __kernel$>)

it will set FCompute attribute to UnaryOp::Compute automatically. To call Our LogCompute, we replace it with below codes.

MXNET_OPERATOR_REGISTER_UNARY(log)
.set_attr<FCompute>("FCompute<cpu>", UnaryOp::LogCompute<cpu, mshadow_op::log>)

MXNET_ADD_SPARSE_OP_ALIAS(log)
.describe(R"code(Returns element-wise Natural logarithmic value of the input.

Expand All @@ -949,6 +949,7 @@ The natural logarithm is logarithm in base *e*, so that ``log(exp(x)) = x``
The storage type of ``log`` output is always dense

)code" ADD_FILELINE)
.set_attr<FCompute>("FCompute<cpu>", UnaryOp::LogCompute<cpu, mshadow_op::log>)
.set_attr<nnvm::FGradient>("FGradient", ElemwiseGradUseIn{"_backward_log"});

// log10
Expand Down