Skip to content

Commit eecd2b3

Browse files
shicongdcslin
shicong
authored and
dcslin
committed
rm mkldnn
1 parent b69b73f commit eecd2b3

15 files changed

Lines changed: 1 addition & 1110 deletions

‎CMakeLists.txt‎

Lines changed: 0 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -66,7 +66,6 @@ OPTION(USE_OPENCL "Use OpenCL" OFF)
6666
OPTION(ENABLE_DIST "Enable distributed training" OFF)
6767
OPTION(DISABLE_WARNINGS "Disable warnings under windows" ON)
6868
OPTION(USE_MODULES "Compile dependent libs as submodules together with singa" OFF)
69-
OPTION(USE_MKLDNN "Use mkl-dnn libs" OFF)
7069
OPTION(USE_DIST "Use nccl distributed module" OFF)
7170

7271
# TODO: remove all USE_CBLAS in codes

‎cmake/Dependencies.cmake‎

Lines changed: 0 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -142,13 +142,6 @@ IF(USE_JAVA)
142142
FIND_PACKAGE(SWIG 3.0 REQUIRED)
143143
ENDIF()
144144

145-
IF(USE_MKLDNN)
146-
FIND_PATH(MKLDNN_INCLUDE_DIR NAME "mkldnn.hpp" PATHS "$ENV{CMAKE_INCLUDE_PATH}")
147-
FIND_LIBRARY(MKLDNN_LIBRARIES NAME "mkldnn" PATHS "$ENV{CMAKE_LIBRARY_PATH}")
148-
MESSAGE(STATUS "Found MKLDNN at ${MKLDNN_INCLUDE_DIR}")
149-
INCLUDE_DIRECTORIES(${MKLDNN_INCLUDE_DIR})
150-
LIST(APPEND SINGA_LINKER_LIBS ${MKLDNN_LIBRARIES})
151-
ENDIF()
152145

153146
IF(USE_DIST)
154147
FIND_PATH(MPI_INCLUDE_DIR NAME "mpi.h" PATHS "/home/ubuntu/mpich-3.3/build/include/")

‎include/singa/core/common.h‎

Lines changed: 0 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -39,9 +39,6 @@
3939
#include "singa/utils/opencl_utils.h"
4040
#endif // USE_OPENCL
4141

42-
#ifdef USE_MKLDNN
43-
#include <mkldnn.hpp>
44-
#endif // USE_MKLDNN
4542

4643
using std::atomic;
4744

@@ -115,9 +112,6 @@ typedef struct _Context {
115112
long vcl_ctx_id;
116113
#endif
117114

118-
#ifdef USE_MKLDNN
119-
mkldnn::engine *engine;
120-
#endif // USE_MKLDNN
121115

122116
} Context;
123117

‎include/singa/core/device.h‎

Lines changed: 0 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -40,9 +40,6 @@
4040
#include "singa/utils/opencl_utils.h"
4141
#endif // USE_OPENCL
4242

43-
#ifdef USE_MKLDNN
44-
#include "singa/utils/mkldnn_utils.h"
45-
#endif // USE_MKLDNN
4643

4744
using std::vector;
4845
using std::string;

‎src/api/model_operation.i‎

Lines changed: 0 additions & 30 deletions
Original file line numberDiff line numberDiff line change
@@ -68,30 +68,6 @@ class BatchNormHandle{
6868
size_t batchsize;
6969
};
7070

71-
#if USE_MKLDNN
72-
73-
74-
Tensor CpuBatchNormForwardInference(const BatchNormHandle &bnh,
75-
const Tensor &x,
76-
const Tensor &bnScale,
77-
const Tensor &bnBias,
78-
Tensor &running_mean,
79-
Tensor &running_var);
80-
81-
const std::vector<Tensor> CpuBatchNormForwardTraining(const BatchNormHandle &bnh,
82-
const Tensor &x,
83-
const Tensor &bnScale,
84-
const Tensor &bnBias,
85-
Tensor &running_mean,
86-
Tensor &running_var);
87-
88-
const std::vector<Tensor> CpuBatchNormBackwardx(const BatchNormHandle &bnh,
89-
const Tensor &y, const Tensor &dy,
90-
const Tensor &x,
91-
const Tensor &bnScale, const Tensor &bnBias,
92-
const Tensor &mean, const Tensor &var);
93-
94-
#endif //USE_MKLDNN
9571

9672

9773
class PoolingHandle {
@@ -112,12 +88,6 @@ class PoolingHandle {
11288
bool is_max_pooling;
11389
};
11490

115-
#if USE_MKLDNN
116-
117-
Tensor CpuPoolingForward(const PoolingHandle &ph, const Tensor &x);
118-
Tensor CpuPoolingBackward(const PoolingHandle &ph, const Tensor &dy,
119-
const Tensor& x, const Tensor& y);
120-
#endif //USE_MKLDNN
12191

12292
#if USE_CUDNN
12393
class CudnnConvHandle: public ConvHandle {

‎src/core/device/cpp_cpu.cc‎

Lines changed: 0 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -24,16 +24,10 @@ std::shared_ptr<Device> defaultDevice=std::make_shared<CppCPU>();
2424

2525
CppCPU::CppCPU() : Device(-1, 1) {
2626
lang_ = kCpp;
27-
#ifdef USE_MKLDNN
28-
ctx_.engine = new mkldnn::engine(mkldnn::engine::cpu, 0);
29-
#endif //USE_MKLDNN
3027
//host_ = nullptr;
3128
}
3229

3330
CppCPU::~CppCPU() {
34-
#ifdef USE_MKLDNN
35-
delete(ctx_.engine);
36-
#endif //USE_MKLDNN
3731

3832
};
3933

‎src/model/operation/batchnorm.cc‎

Lines changed: 0 additions & 186 deletions
Original file line numberDiff line numberDiff line change
@@ -41,198 +41,12 @@ BatchNormHandle::BatchNormHandle(const float momentum, const Tensor& input) {
4141
}
4242

4343

44-
#ifdef USE_MKLDNN
45-
if (input.device()->lang() == kCpp) {
46-
dtype = GetMKLDNNDataType(input.data_type());
47-
epsilon = 1e-5f;
48-
data_memory_format = is_2d ? mkldnn::memory::format::nc : mkldnn::memory::format::nchw;
49-
if (is_2d) {
50-
x_dims = {(int)batchsize, (int)channels};
51-
y_dims = {(int)batchsize, (int)channels};
52-
} else {
53-
x_dims = {(int)batchsize, (int)channels, (int)height, (int)width};
54-
y_dims = {(int)batchsize, (int)channels, (int)height, (int)width};
55-
}
56-
57-
auto eng = *input.device()->context(0)->engine;
58-
x_md = new mkldnn::memory::desc(x_dims, dtype, data_memory_format);
59-
dx_md = new mkldnn::memory::desc(x_dims, dtype, data_memory_format);
60-
bn_fwd_d = new mkldnn::batch_normalization_forward::desc(mkldnn::forward_training, *x_md, epsilon,
61-
mkldnn::use_scale_shift);
62-
bn_fwd_pd = new mkldnn::batch_normalization_forward::primitive_desc(*bn_fwd_d, eng);
63-
}
64-
#endif // USE_MKLDNN
65-
6644
};
6745

6846

6947
BatchNormHandle::~BatchNormHandle() {
70-
#ifdef USE_MKLDNN
71-
if (x_md != nullptr) {
72-
delete (x_md);
73-
delete (dx_md);
74-
delete (bn_fwd_d);
75-
delete (bn_fwd_pd);
76-
}
77-
#endif // USE_MKLDNN
78-
}
79-
80-
#ifdef USE_MKLDNN
81-
82-
Tensor CpuBatchNormForwardInference(const BatchNormHandle &bnh, const Tensor& x, const Tensor& bnScale, const Tensor& bnBias,
83-
Tensor& running_mean, Tensor& running_var) {
84-
85-
CHECK_EQ(x.device()->lang(), kCpp);
86-
Tensor y;
87-
y.ResetLike(x);
88-
89-
90-
Tensor w = get_bn_weight_from(bnScale, bnBias);
91-
92-
y.device()->Exec([&y, &x, &running_mean, &running_var, &w, &bnh](Context * ctx) {
93-
try {
94-
auto eng = *ctx->engine;
95-
using namespace mkldnn;
96-
auto x_mem = memory({{{bnh.x_dims}, bnh.dtype, bnh.data_memory_format}, eng}, x.block()->mutable_data());
97-
auto y_mem = memory({{{bnh.y_dims}, bnh.dtype, bnh.data_memory_format}, eng}, y.block()->mutable_data());
98-
99-
// indicates using scale&bias and running mean&var
100-
auto flags = use_scale_shift | use_global_stats;
101-
auto bn_fwd_d = batch_normalization_forward::desc(forward_inference, *bnh.x_md, bnh.epsilon, flags);
102-
auto bn_fwd_pd = batch_normalization_forward::primitive_desc(bn_fwd_d, eng);
103-
104-
auto m_mem = memory(bn_fwd_pd.mean_primitive_desc(), running_mean.block()->mutable_data());
105-
auto v_mem = memory(bn_fwd_pd.variance_primitive_desc(), running_var.block()->mutable_data());
106-
auto w_mem = memory(bn_fwd_pd.weights_primitive_desc(), w.block()->mutable_data());
107-
108-
// inputs require explicitly be indicated by casting according to
109-
// https://intel.github.io/mkl-dnn/structmkldnn_1_1batch__normalization__forward.html
110-
auto bn = batch_normalization_forward(bn_fwd_pd, x_mem, (const primitive::at)m_mem, (const primitive::at)v_mem, w_mem, y_mem);
111-
112-
stream(stream::kind::eager).submit({bn}).wait();
113-
} catch (mkldnn::error &e) {
114-
InitLogging("");
115-
LOG(FATAL) << "MKLDNN Batch Norm " << "Status: " << e.status << " Message: " << e.message;
116-
}
117-
118-
}, {y.block(), x.block(), w.block()}, {y.block()});
119-
120-
return y;
121-
122-
}
123-
124-
const std::vector<Tensor>
125-
CpuBatchNormForwardTraining(const BatchNormHandle &bnh, const Tensor &x, const Tensor &bnScale, const Tensor &bnBias,
126-
Tensor &running_mean, Tensor &running_var) {
127-
128-
Tensor y;
129-
y.ResetLike(x);
130-
131-
// mean and var for local batch
132-
Tensor mean;
133-
mean.ResetLike(running_mean);
134-
Tensor var;
135-
var.ResetLike(running_var);
136-
137-
// combine scale and bias to construct weight tensor in required format for backward
138-
Tensor w = get_bn_weight_from(bnScale, bnBias);
139-
140-
y.device()->Exec([&x, &y, &mean, &var, &w, &bnh](Context * ctx) {
141-
try {
142-
auto eng = *ctx->engine;
143-
using namespace mkldnn;
144-
145-
auto x_mem = memory({{{bnh.x_dims}, bnh.dtype, bnh.data_memory_format}, eng},
146-
x.block()->mutable_data());
147-
auto y_mem = memory({{{bnh.x_dims}, bnh.dtype, bnh.data_memory_format}, eng},
148-
y.block()->mutable_data());
149-
auto m_mem = memory(bnh.bn_fwd_pd->mean_primitive_desc(), mean.block()->mutable_data());
150-
151-
auto v_mem = memory(bnh.bn_fwd_pd->variance_primitive_desc(), var.block()->mutable_data());
152-
153-
auto w_mem = memory(bnh.bn_fwd_pd->weights_primitive_desc(), w.block()->mutable_data());
154-
155-
auto bn_fwd = batch_normalization_forward(*bnh.bn_fwd_pd, x_mem, w_mem, y_mem, m_mem, v_mem);
156-
157-
stream(stream::kind::eager).submit({bn_fwd}).wait();
158-
} catch (mkldnn::error &e) {
159-
singa::InitLogging("");
160-
LOG(FATAL) << "MKLDNN Batch Norm Backward" << "Status: " << e.status << " Message: " << e.message;
161-
}
162-
}, {x.block(), w.block()}, {y.block(), mean.block(), var.block()});
163-
164-
165-
// local implemented running mean as mkldnn does not support it yet:
166-
// https://github.com/intel/mkl-dnn/issues/371
167-
running_mean = running_mean * bnh.factor + mean * (1 - bnh.factor);
168-
running_var = running_var * bnh.factor + var * (1 - bnh.factor);
169-
170-
171-
return {y, running_mean, running_var};
172-
17348
}
17449

175-
const std::vector<Tensor> CpuBatchNormBackwardx(const BatchNormHandle &bnh,
176-
const Tensor &y, const Tensor &dy,
177-
const Tensor &x,
178-
const Tensor &bnScale, const Tensor &bnBias,
179-
const Tensor &mean, const Tensor &var) {
180-
Tensor dx;
181-
dx.ResetLike(dy);
182-
183-
// combine scale and bias to construct weight tensor in required format for backward
184-
Tensor w = get_bn_weight_from(bnScale, bnBias);
185-
186-
Tensor dw(Shape{bnScale.Size(), 2});
187-
188-
dx.device()->Exec([&dw, &x, &dx, &y, &dy, &w, &mean, &var, &bnh](Context * ctx) {
189-
190-
try {
191-
auto eng = *ctx->engine;
192-
using namespace mkldnn;
193-
194-
auto x_mem = memory({{{bnh.x_dims}, bnh.dtype, bnh.data_memory_format}, eng}, x.block()->mutable_data());
195-
auto dx_mem = memory({{{bnh.x_dims}, bnh.dtype, bnh.data_memory_format}, eng}, dx.block()->mutable_data());
196-
auto y_mem = memory({{{bnh.x_dims}, bnh.dtype, bnh.data_memory_format}, eng}, y.block()->mutable_data());
197-
auto dy_mem = memory({{{bnh.x_dims}, bnh.dtype, bnh.data_memory_format}, eng}, dy.block()->mutable_data());
198-
199-
auto m_mem = memory(bnh.bn_fwd_pd->mean_primitive_desc(), mean.block()->mutable_data());
200-
auto v_mem = memory(bnh.bn_fwd_pd->variance_primitive_desc(), var.block()->mutable_data());
201-
auto w_mem = memory(bnh.bn_fwd_pd->weights_primitive_desc(), w.block()->mutable_data());
202-
203-
204-
auto bn_bwd_d = batch_normalization_backward::desc(backward, *bnh.dx_md, *bnh.x_md, bnh.epsilon, use_scale_shift);
205-
auto bn_bwd_pd = batch_normalization_backward::primitive_desc(bn_bwd_d, eng, *bnh.bn_fwd_pd);
206-
207-
208-
auto dw_mem = memory(bn_bwd_pd.diff_weights_primitive_desc(), dw.block()->mutable_data());
209-
210-
auto bn_bwd = batch_normalization_backward(bn_bwd_pd, x_mem, m_mem, v_mem, dy_mem, w_mem, dx_mem, dw_mem);
211-
212-
stream(stream::kind::eager).submit({bn_bwd}).wait();
213-
} catch (mkldnn::error &e) {
214-
singa::InitLogging("");
215-
LOG(FATAL) << "MKLDNN Batch Norm Backward" << "Status: " << e.status << " Message: " << e.message;
216-
}
217-
218-
}, {x.block(), dy.block(), mean.block(), var.block()},
219-
{dx.block(), dw.block()});
220-
221-
singa::Tensor dbnScale(bnScale.shape());
222-
CopyDataToFrom(&dbnScale, dw, bnScale.Size(), 0, 0);
223-
singa::Tensor dbnBias(bnBias.shape());
224-
CopyDataToFrom(&dbnBias, dw, bnBias.Size(), 0, bnScale.Size());
225-
226-
CHECK(dbnScale.nDim() == bnScale.nDim()) << "dbnScale ndim not match bnScale";
227-
CHECK(dbnBias.nDim() == bnBias.nDim()) << "dbnScale ndim not match bnScale";
228-
CHECK(dbnScale.shape()[0] == bnScale.shape()[0]) << "dbnScale shape not match bnScale";
229-
CHECK(dbnBias.shape()[0] == bnBias.shape()[0]) << "dbnBias shape not match bnBias";
230-
231-
return {dx, dbnScale, dbnBias};
232-
}
233-
234-
235-
#endif // USE_MKLDNN
23650

23751
#ifdef USE_CUDNN
23852
CudnnBatchNormHandle::CudnnBatchNormHandle(const float momentum,

‎src/model/operation/batchnorm.h‎

Lines changed: 1 addition & 42 deletions
Original file line numberDiff line numberDiff line change
@@ -29,19 +29,6 @@
2929
#include "../layer/cudnn_utils.h" // check_cudnn
3030
#endif // USE_CUDNN
3131

32-
#ifdef USE_MKLDNN
33-
#include <mkldnn.hpp>
34-
35-
// combine scale and bias into weight format recognised by mkldnn api
36-
static inline singa::Tensor get_bn_weight_from(const singa::Tensor &s, const singa::Tensor &b) {
37-
singa::Tensor w(singa::Shape{s.Size(), b.Size()});
38-
CopyDataToFrom(&w, s, s.Size(), 0, 0);
39-
CopyDataToFrom(&w, b, b.Size(), s.Size(), 0);
40-
return w;
41-
}
42-
43-
44-
#endif // USE_MKLDNN
4532

4633
namespace singa {
4734

@@ -58,37 +45,9 @@ class BatchNormHandle {
5845
size_t width;
5946
bool is_2d;
6047
//bool train = true;
61-
#ifdef USE_MKLDNN
62-
mkldnn::memory::data_type dtype;
63-
mkldnn::memory::dims x_dims;
64-
mkldnn::memory::dims y_dims;
65-
mkldnn::memory::desc *x_md = nullptr;
66-
mkldnn::memory::desc *dx_md = nullptr;
67-
mkldnn::batch_normalization_forward::desc *bn_fwd_d = nullptr;
68-
mkldnn::batch_normalization_forward::primitive_desc *bn_fwd_pd = nullptr;
69-
float epsilon;
70-
mkldnn::memory::format data_memory_format;
71-
#endif //USE_MKLDNN
7248
};
7349

7450

75-
#ifdef USE_MKLDNN
76-
77-
Tensor
78-
CpuBatchNormForwardInference(const BatchNormHandle &bnh, const Tensor &x, const Tensor &bnScale, const Tensor &bnBias,
79-
Tensor &running_mean, Tensor &running_var);
80-
81-
const std::vector<Tensor>
82-
CpuBatchNormForwardTraining(const BatchNormHandle &bnh, const Tensor &x, const Tensor &bnScale, const Tensor &bnBias,
83-
Tensor &running_mean, Tensor &running_var);
84-
85-
const std::vector<Tensor> CpuBatchNormBackwardx(const BatchNormHandle &bnh,
86-
const Tensor &y, const Tensor &dy,
87-
const Tensor &x,
88-
const Tensor &bnScale, const Tensor &bnBias,
89-
const Tensor &mean, const Tensor &var);
90-
91-
#endif // USE_MKLDNN
9251

9352

9453
#ifdef USE_CUDNN
@@ -120,4 +79,4 @@ const std::vector<Tensor> GpuBatchNormBackward(const CudnnBatchNormHandle &cbnh,
12079

12180
} // namespace singa
12281

123-
#endif // SINGA_MODEL_OPERATION_BATCHNORM_H_
82+
#endif // SINGA_MODEL_OPERATION_BATCHNORM_H_

0 commit comments

Comments
 (0)