!747 change cpu kernel dir

Merge pull request !747 from kisnwang/change-cpu-kernel-dir

mindspore/ccsrc/kernel/CMakeLists.txt

@@ -17,6 +17,12 @@ if (ENABLE_D)
 	add_compile_definitions(ENABLE_D)
 endif ()
 
+if (ENABLE_CPU)
+    file(GLOB_RECURSE CPU_SRC_LIST RELATIVE ${CMAKE_CURRENT_SOURCE_DIR}
+        "cpu/*.cc"
+    )
+endif ()
+
 if (ENABLE_GPU)
     file(GLOB_RECURSE CUDA_SRC_LIST RELATIVE ${CMAKE_CURRENT_SOURCE_DIR}
         "gpu/*.cu"
@@ -37,4 +43,4 @@ if (ENABLE_GPU)
 	# add_library(_mindspore_kernel_cuda_obj OBJECT ${CUDA_SRC_LIST})
 endif()
 
-add_library(_mindspore_kernel_obj OBJECT ${KERNEL_SRC_LIST} ${GPU_SRC_LIST} ${D_SRC_LIST})
+add_library(_mindspore_kernel_obj OBJECT ${KERNEL_SRC_LIST} ${CPU_SRC_LIST} ${GPU_SRC_LIST} ${D_SRC_LIST})

mindspore/ccsrc/kernel/cpu/apply_momentum_cpu_kernel.cc

@@ -13,14 +13,13 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-#include "device/cpu/kernel/apply_momentum_cpu_kernel.h"
-#include "device/cpu/kernel/mkldnn/mkl_kernel_engine.h"
+#include "kernel/cpu/apply_momentum_cpu_kernel.h"
+#include "kernel/cpu/mkldnn/mkl_kernel_engine.h"
 #include "device/cpu/cpu_device_address.h"
 #include "common/utils.h"
 
 namespace mindspore {
-namespace device {
-namespace cpu {
+namespace kernel {
 void ApplyMomentumCPUKernel::InitKernel(const CNodePtr & /*kernel_node*/) {}
 
 bool ApplyMomentumCPUKernel::Launch(const std::vector<kernel::AddressPtr> &inputs,
@@ -44,6 +43,5 @@ bool ApplyMomentumCPUKernel::Launch(const std::vector<kernel::AddressPtr> &input
   }
   return true;
 }
-}  // namespace cpu
-}  // namespace device
+}  // namespace kernel
 }  // namespace mindspore

mindspore/ccsrc/kernel/cpu/apply_momentum_cpu_kernel.h

@@ -13,16 +13,15 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-#ifndef MINDSPORE_CCSRC_DEVICE_CPU_APPLY_MOMENTUM_CPU_KERNEL_H_
-#define MINDSPORE_CCSRC_DEVICE_CPU_APPLY_MOMENTUM_CPU_KERNEL_H_
+#ifndef MINDSPORE_CCSRC_KERNEL_CPU_APPLY_MOMENTUM_CPU_KERNEL_H_
+#define MINDSPORE_CCSRC_KERNEL_CPU_APPLY_MOMENTUM_CPU_KERNEL_H_
 
 #include <vector>
 #include <memory>
-#include "device/cpu/kernel/mkldnn/mkl_cpu_kernel.h"
+#include "kernel/cpu/mkldnn/mkl_cpu_kernel.h"
 
 namespace mindspore {
-namespace device {
-namespace cpu {
+namespace kernel {
 class ApplyMomentumCPUKernel : public MKLCPUKernel {
  public:
   ApplyMomentumCPUKernel() = default;
@@ -35,8 +34,7 @@ class ApplyMomentumCPUKernel : public MKLCPUKernel {
 };
 
 MS_REG_CPU_KERNEL(ApplyMomentum, ApplyMomentumCPUKernel);
-}  // namespace cpu
-}  // namespace device
+}  // namespace kernel
 }  // namespace mindspore
 
-#endif  // MINDSPORE_CCSRC_DEVICE_CPU_APPLY_MOMENTUM_CPU_KERNEL_H_
+#endif  // MINDSPORE_CCSRC_KERNEL_CPU_APPLY_MOMENTUM_CPU_KERNEL_H_

mindspore/ccsrc/kernel/cpu/argmax_cpu_kernel.cc

@@ -13,12 +13,11 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-#include "device/cpu/kernel/argmax_cpu_kernel.h"
+#include "kernel/cpu/argmax_cpu_kernel.h"
 #include "device/cpu/cpu_device_address.h"
 
 namespace mindspore {
-namespace device {
-namespace cpu {
+namespace kernel {
 void ArgmaxCPUKernel::InitKernel(const CNodePtr &kernel_node) {
   MS_EXCEPTION_IF_NULL(kernel_node);
   std::vector<size_t> shape = AnfAlgo::GetInputDeviceShape(kernel_node, 0);
@@ -64,6 +63,5 @@ bool ArgmaxCPUKernel::Launch(const std::vector<kernel::AddressPtr> &inputs,
   }
   return true;
 }
-}  // namespace cpu
-}  // namespace device
+}  // namespace kernel
 }  // namespace mindspore

mindspore/ccsrc/kernel/cpu/argmax_cpu_kernel.h

@@ -13,16 +13,15 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-#ifndef MINDSPORE_CCSRC_DEVICE_CPU_ARGMAX_CPU_KERNEL_H_
-#define MINDSPORE_CCSRC_DEVICE_CPU_ARGMAX_CPU_KERNEL_H_
+#ifndef MINDSPORE_CCSRC_KERNEL_CPU_ARGMAX_CPU_KERNEL_H_
+#define MINDSPORE_CCSRC_KERNEL_CPU_ARGMAX_CPU_KERNEL_H_
 #include <vector>
 #include <memory>
-#include "device/cpu/cpu_kernel.h"
-#include "device/cpu/cpu_kernel_factory.h"
+#include "kernel/cpu/cpu_kernel.h"
+#include "kernel/cpu/cpu_kernel_factory.h"
 
 namespace mindspore {
-namespace device {
-namespace cpu {
+namespace kernel {
 class ArgmaxCPUKernel : public CPUKernel {
  public:
   ArgmaxCPUKernel() = default;
@@ -39,8 +38,7 @@ class ArgmaxCPUKernel : public CPUKernel {
 };
 
 MS_REG_CPU_KERNEL(Argmax, ArgmaxCPUKernel);
-}  // namespace cpu
-}  // namespace device
+}  // namespace kernel
 }  // namespace mindspore
 
-#endif  // MINDSPORE_CCSRC_DEVICE_CPU_ARGMAX_CPU_KERNEL_H_
+#endif  // MINDSPORE_CCSRC_KERNEL_CPU_ARGMAX_CPU_KERNEL_H_

mindspore/ccsrc/kernel/cpu/bias_add_cpu_kernel.cc

@@ -14,12 +14,11 @@
  * limitations under the License.
  */
 
-#include "device/cpu/kernel/bias_add_cpu_kernel.h"
+#include "kernel/cpu/bias_add_cpu_kernel.h"
 
 namespace mindspore {
-namespace device {
-namespace cpu {
-void BiasAddCpuKernel::InitKernel(const CNodePtr &kernel_node) {
+namespace kernel {
+void BiasAddCPUKernel::InitKernel(const CNodePtr &kernel_node) {
   MS_EXCEPTION_IF_NULL(kernel_node);
   input_shape_ = AnfAlgo::GetInputDeviceShape(kernel_node, 0);
   bias_shape_ = AnfAlgo::GetInputDeviceShape(kernel_node, 1);
@@ -41,7 +40,7 @@ void BiasAddCpuKernel::InitKernel(const CNodePtr &kernel_node) {
   }
 }
 
-bool BiasAddCpuKernel::Launch(const std::vector<AddressPtr> &inputs, const std::vector<AddressPtr> & /*workspace*/,
+bool BiasAddCPUKernel::Launch(const std::vector<AddressPtr> &inputs, const std::vector<AddressPtr> & /*workspace*/,
                               const std::vector<AddressPtr> &outputs) {
   if (inputs.size() != 2 || outputs.size() != 1) {
     MS_LOG(EXCEPTION) << "inputs outputs size not supoort";
@@ -79,6 +78,5 @@ bool BiasAddCpuKernel::Launch(const std::vector<AddressPtr> &inputs, const std::
   }
   return true;
 }
-}  // namespace cpu
-}  // namespace device
+}  // namespace kernel
 }  // namespace mindspore

mindspore/ccsrc/kernel/cpu/bias_add_cpu_kernel.h

@@ -13,21 +13,20 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-#ifndef MINDSPORE_MINDSPORE_CCSRC_DEVICE_CPU_KERNEL_BIAS_ADD_CPU_KERNEL_H_
-#define MINDSPORE_MINDSPORE_CCSRC_DEVICE_CPU_KERNEL_BIAS_ADD_CPU_KERNEL_H_
+#ifndef MINDSPORE_MINDSPORE_CCSRC_KERNEL_CPU_BIAS_ADD_CPU_KERNEL_H_
+#define MINDSPORE_MINDSPORE_CCSRC_KERNEL_CPU_BIAS_ADD_CPU_KERNEL_H_
 
 #include <vector>
 #include <memory>
-#include "device/cpu/cpu_kernel.h"
-#include "device/cpu/cpu_kernel_factory.h"
+#include "kernel/cpu/cpu_kernel.h"
+#include "kernel/cpu/cpu_kernel_factory.h"
 
 namespace mindspore {
-namespace device {
-namespace cpu {
-class BiasAddCpuKernel : public CPUKernel {
+namespace kernel {
+class BiasAddCPUKernel : public CPUKernel {
  public:
-  BiasAddCpuKernel() = default;
-  ~BiasAddCpuKernel() override = default;
+  BiasAddCPUKernel() = default;
+  ~BiasAddCPUKernel() override = default;
 
   void InitKernel(const CNodePtr &kernel_node) override;
   bool Launch(const std::vector<AddressPtr> &inputs, const std::vector<AddressPtr> &workspace,
@@ -38,8 +37,7 @@ class BiasAddCpuKernel : public CPUKernel {
   std::vector<size_t> input_shape_;
   std::vector<size_t> bias_shape_;
 };
-MS_REG_CPU_KERNEL(BiasAdd, BiasAddCpuKernel);
-}  // namespace cpu
-}  // namespace device
+MS_REG_CPU_KERNEL(BiasAdd, BiasAddCPUKernel);
+}  // namespace kernel
 }  // namespace mindspore
-#endif  // MINDSPORE_MINDSPORE_CCSRC_DEVICE_CPU_KERNEL_BIAS_ADD_CPU_KERNEL_H_
+#endif  // MINDSPORE_MINDSPORE_CCSRC_KERNEL_CPU_BIAS_ADD_CPU_KERNEL_H_

mindspore/ccsrc/kernel/cpu/bias_add_grad_cpu_kernel.cc

@@ -14,12 +14,11 @@
  * limitations under the License.
  */
 
-#include "device/cpu/kernel/bias_add_grad_cpu_kernel.h"
+#include "kernel/cpu/bias_add_grad_cpu_kernel.h"
 
 namespace mindspore {
-namespace device {
-namespace cpu {
-void BiasAddGradCpuKernel::InitKernel(const CNodePtr &kernel_node) {
+namespace kernel {
+void BiasAddGradCPUKernel::InitKernel(const CNodePtr &kernel_node) {
   MS_EXCEPTION_IF_NULL(kernel_node);
   input_shape_ = AnfAlgo::GetInputDeviceShape(kernel_node, 0);
   if (input_shape_.size() != 4 && input_shape_.size() != 2) {
@@ -27,7 +26,7 @@ void BiasAddGradCpuKernel::InitKernel(const CNodePtr &kernel_node) {
   }
 }
 
-bool BiasAddGradCpuKernel::Launch(const std::vector<AddressPtr> &inputs, const std::vector<AddressPtr> & /*workspace*/,
+bool BiasAddGradCPUKernel::Launch(const std::vector<AddressPtr> &inputs, const std::vector<AddressPtr> & /*workspace*/,
                                   const std::vector<AddressPtr> &outputs) {
   if (inputs.size() != 1 || outputs.size() != 1) {
     MS_LOG(EXCEPTION) << "input output size not support";
@@ -65,6 +64,5 @@ bool BiasAddGradCpuKernel::Launch(const std::vector<AddressPtr> &inputs, const s
   }
   return true;
 }
-}  // namespace cpu
-}  // namespace device
+}  // namespace kernel
 }  // namespace mindspore

mindspore/ccsrc/kernel/cpu/bias_add_grad_cpu_kernel.h

@@ -14,21 +14,20 @@
  * limitations under the License.
  */
 
-#ifndef MINDSPORE_MINDSPORE_CCSRC_DEVICE_CPU_KERNEL_BIASADDGRADCPUKERNEL_H_
-#define MINDSPORE_MINDSPORE_CCSRC_DEVICE_CPU_KERNEL_BIASADDGRADCPUKERNEL_H_
+#ifndef MINDSPORE_MINDSPORE_CCSRC_KERNEL_CPU_BIASADDGRADCPUKERNEL_H_
+#define MINDSPORE_MINDSPORE_CCSRC_KERNEL_CPU_BIASADDGRADCPUKERNEL_H_
 
 #include <vector>
 #include <memory>
-#include "device/cpu/cpu_kernel.h"
-#include "device/cpu/cpu_kernel_factory.h"
+#include "kernel/cpu/cpu_kernel.h"
+#include "kernel/cpu/cpu_kernel_factory.h"
 
 namespace mindspore {
-namespace device {
-namespace cpu {
-class BiasAddGradCpuKernel : public CPUKernel {
+namespace kernel {
+class BiasAddGradCPUKernel : public CPUKernel {
  public:
-  BiasAddGradCpuKernel() = default;
-  ~BiasAddGradCpuKernel() override = default;
+  BiasAddGradCPUKernel() = default;
+  ~BiasAddGradCPUKernel() override = default;
 
   void InitKernel(const CNodePtr &kernel_node) override;
   bool Launch(const std::vector<AddressPtr> &inputs, const std::vector<AddressPtr> &workspace,
@@ -37,8 +36,7 @@ class BiasAddGradCpuKernel : public CPUKernel {
  private:
   std::vector<size_t> input_shape_;
 };
-MS_REG_CPU_KERNEL(BiasAddGrad, BiasAddGradCpuKernel);
-}  // namespace cpu
-}  // namespace device
+MS_REG_CPU_KERNEL(BiasAddGrad, BiasAddGradCPUKernel);
+}  // namespace kernel
 }  // namespace mindspore
-#endif  // MINDSPORE_MINDSPORE_CCSRC_DEVICE_CPU_KERNEL_BIASADDGRADCPUKERNEL_H_
+#endif  // MINDSPORE_MINDSPORE_CCSRC_KERNEL_CPU_BIASADDGRADCPUKERNEL_H_

mindspore/ccsrc/kernel/cpu/cpu_kernel.cc

@@ -13,11 +13,10 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-#include "device/cpu/cpu_kernel.h"
+#include "kernel/cpu/cpu_kernel.h"
 
 namespace mindspore {
-namespace device {
-namespace cpu {
+namespace kernel {
 void CPUKernel::InitInputOutputSize(const CNodePtr &kernel_node) {
   MS_EXCEPTION_IF_NULL(kernel_node);
   size_t input_num = AnfAlgo::GetInputTensorNum(kernel_node);
@@ -41,6 +40,5 @@ void CPUKernel::Init(const CNodePtr &kernel_node) {
   InitInputOutputSize(kernel_node);
   InitKernel(kernel_node);
 }
-}  // namespace cpu
-}  // namespace device
+}  // namespace kernel
 }  // namespace mindspore

mindspore/ccsrc/kernel/cpu/cpu_kernel.h

@@ -13,8 +13,8 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-#ifndef MINDSPORE_CCSRC_DEVICE_CPU_CPU_KERNEL_H_
-#define MINDSPORE_CCSRC_DEVICE_CPU_CPU_KERNEL_H_
+#ifndef MINDSPORE_CCSRC_KERNEL_CPU_CPU_KERNEL_H_
+#define MINDSPORE_CCSRC_KERNEL_CPU_CPU_KERNEL_H_
 
 #include <string>
 #include <vector>
@@ -28,8 +28,7 @@
 using mindspore::kernel::Address;
 using mindspore::kernel::AddressPtr;
 namespace mindspore {
-namespace device {
-namespace cpu {
+namespace kernel {
 const char KSIZE[] = "ksize";
 const char STRIDE[] = "stride";
 const char STRIDES[] = "strides";
@@ -70,8 +69,7 @@ class CPUKernel : public kernel::KernelMod {
   std::vector<size_t> output_size_list_;
   std::vector<size_t> workspace_size_list_;
 };
-}  // namespace cpu
-}  // namespace device
+}  // namespace kernel
 }  // namespace mindspore
 
-#endif  // MINDSPORE_CCSRC_DEVICE_CPU_CPU_KERNEL_H_
+#endif  // MINDSPORE_CCSRC_KERNEL_CPU_CPU_KERNEL_H_

mindspore/ccsrc/kernel/cpu/cpu_kernel_factory.cc

@@ -14,15 +14,14 @@
  * limitations under the License.
  */
 
-#include "device/cpu/cpu_kernel_factory.h"
+#include "kernel/cpu/cpu_kernel_factory.h"
 
 #include <memory>
 #include <iostream>
 #include <string>
 
 namespace mindspore {
-namespace device {
-namespace cpu {
+namespace kernel {
 CPUKernelFactory &CPUKernelFactory::Get() {
   static CPUKernelFactory instance;
   return instance;
@@ -45,6 +44,5 @@ std::shared_ptr<CPUKernel> CPUKernelFactory::Create(const std::string &kernel_na
   }
   return nullptr;
 }
-}  // namespace cpu
-}  // namespace device
+}  // namespace kernel
 }  // namespace mindspore

mindspore/ccsrc/kernel/cpu/cpu_kernel_factory.h

@@ -13,8 +13,8 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-#ifndef MINDSPORE_CCSRC_DEVICE_CPU_CPU_KERNEL_FACTORY_H_
-#define MINDSPORE_CCSRC_DEVICE_CPU_CPU_KERNEL_FACTORY_H_
+#ifndef MINDSPORE_CCSRC_KERNEL_CPU_CPU_KERNEL_FACTORY_H_
+#define MINDSPORE_CCSRC_KERNEL_CPU_CPU_KERNEL_FACTORY_H_
 
 #include <functional>
 #include <map>
@@ -22,10 +22,9 @@
 #include <string>
 #include <utility>
 #include "common/utils.h"
-#include "device/cpu/cpu_kernel.h"
+#include "kernel/cpu/cpu_kernel.h"
 namespace mindspore {
-namespace device {
-namespace cpu {
+namespace kernel {
 using CPUKernelCreator = std::function<std::shared_ptr<CPUKernel>()>;
 class CPUKernelFactory {
  public:
@@ -51,8 +50,7 @@ class CPUKernelRegistrar {
 #define MS_REG_CPU_KERNEL(KERNEL_NAME, KERNEL_CLASS)                             \
   static const CPUKernelRegistrar g_cpu_kernel_##KERNEL_NAME##_reg(#KERNEL_NAME, \
                                                                    []() { return std::make_shared<KERNEL_CLASS>(); });
-}  // namespace cpu
-}  // namespace device
+}  // namespace kernel
 }  // namespace mindspore
 
-#endif  // MINDSPORE_CCSRC_DEVICE_CPU_CPU_KERNEL_FACTORY_H_
+#endif  // MINDSPORE_CCSRC_KERNEL_CPU_CPU_KERNEL_FACTORY_H_

mindspore/ccsrc/kernel/cpu/equal_count_cpu_kernel.cc

@@ -13,12 +13,11 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-#include "device/cpu/kernel/equal_count_cpu_kernel.h"
+#include "kernel/cpu/equal_count_cpu_kernel.h"
 #include "device/cpu/cpu_device_address.h"
 
 namespace mindspore {
-namespace device {
-namespace cpu {
+namespace kernel {
 void EqualCountCPUKernel::InitKernel(const CNodePtr & /*kernel_node*/) {}
 
 bool EqualCountCPUKernel::Launch(const std::vector<kernel::AddressPtr> &inputs,
@@ -43,6 +42,5 @@ bool EqualCountCPUKernel::Launch(const std::vector<kernel::AddressPtr> &inputs,
   output[0] = count;
   return true;
 }
-}  // namespace cpu
-}  // namespace device
+}  // namespace kernel
 }  // namespace mindspore

mindspore/ccsrc/kernel/cpu/equal_count_cpu_kernel.h

@@ -13,16 +13,15 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-#ifndef MINDSPORE_CCSRC_DEVICE_CPU_EQUAL_COUNT_CPU_KERNEL_H_
-#define MINDSPORE_CCSRC_DEVICE_CPU_EQUAL_COUNT_CPU_KERNEL_H_
+#ifndef MINDSPORE_CCSRC_KERNEL_CPU_EQUAL_COUNT_CPU_KERNEL_H_
+#define MINDSPORE_CCSRC_KERNEL_CPU_EQUAL_COUNT_CPU_KERNEL_H_
 #include <vector>
 #include <memory>
-#include "device/cpu/cpu_kernel.h"
-#include "device/cpu/cpu_kernel_factory.h"
+#include "kernel/cpu/cpu_kernel.h"
+#include "kernel/cpu/cpu_kernel_factory.h"
 
 namespace mindspore {
-namespace device {
-namespace cpu {
+namespace kernel {
 class EqualCountCPUKernel : public CPUKernel {
  public:
   EqualCountCPUKernel() = default;
@@ -35,8 +34,7 @@ class EqualCountCPUKernel : public CPUKernel {
 };
 
 MS_REG_CPU_KERNEL(EqualCount, EqualCountCPUKernel);
-}  // namespace cpu
-}  // namespace device
+}  // namespace kernel
 }  // namespace mindspore
 
-#endif  // MINDSPORE_CCSRC_DEVICE_CPU_EQUAL_COUNT_CPU_KERNEL_H_
+#endif  // MINDSPORE_CCSRC_KERNEL_CPU_EQUAL_COUNT_CPU_KERNEL_H_

mindspore/ccsrc/kernel/cpu/mkldnn/conv2d_cpu_kernel.cc

@@ -13,15 +13,14 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-#include "device/cpu/kernel/mkldnn/conv2d_cpu_kernel.h"
+#include "kernel/cpu/mkldnn/conv2d_cpu_kernel.h"
 #include <string>
 #include "common/utils.h"
-#include "device/cpu/kernel/mkldnn/mkl_kernel_engine.h"
+#include "kernel/cpu/mkldnn/mkl_kernel_engine.h"
 #include "device/cpu/cpu_device_address.h"
 
 namespace mindspore {
-namespace device {
-namespace cpu {
+namespace kernel {
 void Conv2dCPUKernel::InitKernel(const CNodePtr &kernel_node) {
   MS_EXCEPTION_IF_NULL(kernel_node);
   std::vector<size_t> src_shape = AnfAlgo::GetInputDeviceShape(kernel_node, 0);
@@ -88,6 +87,5 @@ bool Conv2dCPUKernel::Launch(const std::vector<kernel::AddressPtr> &inputs,
   ExecutePrimitive();
   return true;
 }
-}  // namespace cpu
-}  // namespace device
+}  // namespace kernel
 }  // namespace mindspore

mindspore/ccsrc/kernel/cpu/mkldnn/conv2d_cpu_kernel.h

@@ -13,16 +13,15 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-#ifndef MINDSPORE_CCSRC_DEVICE_CPU_CONV2D_CPU_KERNEL_H_
-#define MINDSPORE_CCSRC_DEVICE_CPU_CONV2D_CPU_KERNEL_H_
+#ifndef MINDSPORE_CCSRC_KERNEL_CPU_CONV2D_CPU_KERNEL_H_
+#define MINDSPORE_CCSRC_KERNEL_CPU_CONV2D_CPU_KERNEL_H_
 
 #include <vector>
 #include <memory>
-#include "device/cpu/kernel/mkldnn/mkl_cpu_kernel.h"
+#include "kernel/cpu/mkldnn/mkl_cpu_kernel.h"
 
 namespace mindspore {
-namespace device {
-namespace cpu {
+namespace kernel {
 class Conv2dCPUKernel : public MKLCPUKernel {
  public:
   Conv2dCPUKernel() = default;
@@ -35,8 +34,7 @@ class Conv2dCPUKernel : public MKLCPUKernel {
 };
 
 MS_REG_CPU_KERNEL(Conv2D, Conv2dCPUKernel);
-}  // namespace cpu
-}  // namespace device
+}  // namespace kernel
 }  // namespace mindspore
 
-#endif  // MINDSPORE_CCSRC_DEVICE_CPU_CONV2D_CPU_KERNEL_H_
+#endif  // MINDSPORE_CCSRC_KERNEL_CPU_CONV2D_CPU_KERNEL_H_

mindspore/ccsrc/kernel/cpu/mkldnn/conv2d_grad_filter_cpu_kernel.cc

@@ -13,15 +13,14 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-#include "device/cpu/kernel/mkldnn/conv2d_grad_filter_cpu_kernel.h"
+#include "kernel/cpu/mkldnn/conv2d_grad_filter_cpu_kernel.h"
 #include <string>
 #include "common/utils.h"
-#include "device/cpu/kernel/mkldnn/mkl_kernel_engine.h"
+#include "kernel/cpu/mkldnn/mkl_kernel_engine.h"
 #include "device/cpu/cpu_device_address.h"
 
 namespace mindspore {
-namespace device {
-namespace cpu {
+namespace kernel {
 void Conv2dGradFilterCPUKernel::InitKernel(const CNodePtr &kernel_node) {
   MS_EXCEPTION_IF_NULL(kernel_node);
   std::vector<size_t> src_shape = AnfAlgo::GetInputDeviceShape(kernel_node, 1);
@@ -90,6 +89,5 @@ bool Conv2dGradFilterCPUKernel::Launch(const std::vector<kernel::AddressPtr> &in
   ExecutePrimitive();
   return true;
 }
-}  // namespace cpu
-}  // namespace device
+}  // namespace kernel
 }  // namespace mindspore

mindspore/ccsrc/kernel/cpu/mkldnn/conv2d_grad_filter_cpu_kernel.h

@@ -13,16 +13,15 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-#ifndef MINDSPORE_CCSRC_DEVICE_CPU_CONV2D_GRAD_FILTER_CPU_KERNEL_H_
-#define MINDSPORE_CCSRC_DEVICE_CPU_CONV2D_GRAD_FILTER_CPU_KERNEL_H_
+#ifndef MINDSPORE_CCSRC_KERNEL_CPU_CONV2D_GRAD_FILTER_CPU_KERNEL_H_
+#define MINDSPORE_CCSRC_KERNEL_CPU_CONV2D_GRAD_FILTER_CPU_KERNEL_H_
 
 #include <vector>
 #include <memory>
-#include "device/cpu/kernel/mkldnn/mkl_cpu_kernel.h"
+#include "kernel/cpu/mkldnn/mkl_cpu_kernel.h"
 
 namespace mindspore {
-namespace device {
-namespace cpu {
+namespace kernel {
 class Conv2dGradFilterCPUKernel : public MKLCPUKernel {
  public:
   Conv2dGradFilterCPUKernel() = default;
@@ -35,8 +34,7 @@ class Conv2dGradFilterCPUKernel : public MKLCPUKernel {
 };
 
 MS_REG_CPU_KERNEL(Conv2DBackpropFilter, Conv2dGradFilterCPUKernel);
-}  // namespace cpu
-}  // namespace device
+}  // namespace kernel
 }  // namespace mindspore
 
-#endif  // MINDSPORE_CCSRC_DEVICE_CPU_CONV2D_GRAD_FILTER_CPU_KERNEL_H_
+#endif  // MINDSPORE_CCSRC_KERNEL_CPU_CONV2D_GRAD_FILTER_CPU_KERNEL_H_

mindspore/ccsrc/kernel/cpu/mkldnn/conv2d_grad_input_cpu_kernel.cc

@@ -13,15 +13,14 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-#include "device/cpu/kernel/mkldnn/conv2d_grad_input_cpu_kernel.h"
+#include "kernel/cpu/mkldnn/conv2d_grad_input_cpu_kernel.h"
 #include <string>
-#include "device/cpu/kernel/mkldnn/mkl_kernel_engine.h"
+#include "kernel/cpu/mkldnn/mkl_kernel_engine.h"
 #include "device/cpu/cpu_device_address.h"
 #include "common/utils.h"
 
 namespace mindspore {
-namespace device {
-namespace cpu {
+namespace kernel {
 void Conv2dGradInputCPUKernel::InitKernel(const CNodePtr &kernel_node) {
   MS_EXCEPTION_IF_NULL(kernel_node);
   std::vector<size_t> src_shape = AnfAlgo::GetOutputDeviceShape(kernel_node, 0);
@@ -89,6 +88,5 @@ bool Conv2dGradInputCPUKernel::Launch(const std::vector<kernel::AddressPtr> &inp
   ExecutePrimitive();
   return true;
 }
-}  // namespace cpu
-}  // namespace device
+}  // namespace kernel
 }  // namespace mindspore

mindspore/ccsrc/kernel/cpu/mkldnn/conv2d_grad_input_cpu_kernel.h

@@ -13,16 +13,15 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-#ifndef MINDSPORE_CCSRC_DEVICE_CPU_CONV2D_GRAD_INPUT_CPU_KERNEL_H_
-#define MINDSPORE_CCSRC_DEVICE_CPU_CONV2D_GRAD_INPUT_CPU_KERNEL_H_
+#ifndef MINDSPORE_CCSRC_KERNEL_CPU_CONV2D_GRAD_INPUT_CPU_KERNEL_H_
+#define MINDSPORE_CCSRC_KERNEL_CPU_CONV2D_GRAD_INPUT_CPU_KERNEL_H_
 
 #include <vector>
 #include <memory>
-#include "device/cpu/kernel/mkldnn/mkl_cpu_kernel.h"
+#include "kernel/cpu/mkldnn/mkl_cpu_kernel.h"
 
 namespace mindspore {
-namespace device {
-namespace cpu {
+namespace kernel {
 class Conv2dGradInputCPUKernel : public MKLCPUKernel {
  public:
   Conv2dGradInputCPUKernel() = default;
@@ -35,8 +34,7 @@ class Conv2dGradInputCPUKernel : public MKLCPUKernel {
 };
 
 MS_REG_CPU_KERNEL(Conv2DBackpropInput, Conv2dGradInputCPUKernel);
-}  // namespace cpu
-}  // namespace device
+}  // namespace kernel
 }  // namespace mindspore
 
-#endif  // MINDSPORE_CCSRC_DEVICE_CPU_CONV2D_GRAD_INPUT_CPU_KERNEL_H_
+#endif  // MINDSPORE_CCSRC_KERNEL_CPU_CONV2D_GRAD_INPUT_CPU_KERNEL_H_

mindspore/ccsrc/kernel/cpu/mkldnn/matmul_cpu_kernel.cc

@@ -13,16 +13,15 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-#include "device/cpu/kernel/mkldnn/matmul_cpu_kernel.h"
+#include "kernel/cpu/mkldnn/matmul_cpu_kernel.h"
 #include <algorithm>
 #include <utility>
-#include "device/cpu/kernel/mkldnn/mkl_kernel_engine.h"
+#include "kernel/cpu/mkldnn/mkl_kernel_engine.h"
 #include "common/utils.h"
 #include "device/cpu/cpu_device_address.h"
 
 namespace mindspore {
-namespace device {
-namespace cpu {
+namespace kernel {
 void MatMulCPUKernel::InitKernel(const CNodePtr &kernel_node) {
   MS_EXCEPTION_IF_NULL(kernel_node);
   std::vector<size_t> src_shape = AnfAlgo::GetInputDeviceShape(kernel_node, 0);
@@ -68,6 +67,5 @@ bool MatMulCPUKernel::Launch(const std::vector<kernel::AddressPtr> &inputs,
   (void)dnnl_sgemm(trans_a_, trans_b_, dim_m_, dim_n_, dim_k_, 1.f, input_a, lda, input_b, ldb, 0.f, output, dim_n_);
   return true;
 }
-}  // namespace cpu
-}  // namespace device
+}  // namespace kernel
 }  // namespace mindspore

mindspore/ccsrc/kernel/cpu/mkldnn/matmul_cpu_kernel.h

@@ -13,16 +13,15 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-#ifndef MINDSPORE_CCSRC_DEVICE_CPU_MATMUL_CPU_KERNEL_H_
-#define MINDSPORE_CCSRC_DEVICE_CPU_MATMUL_CPU_KERNEL_H_
+#ifndef MINDSPORE_CCSRC_KERNEL_CPU_MATMUL_CPU_KERNEL_H_
+#define MINDSPORE_CCSRC_KERNEL_CPU_MATMUL_CPU_KERNEL_H_
 
 #include <vector>
 #include <memory>
-#include "device/cpu/kernel/mkldnn/mkl_cpu_kernel.h"
+#include "kernel/cpu/mkldnn/mkl_cpu_kernel.h"
 
 namespace mindspore {
-namespace device {
-namespace cpu {
+namespace kernel {
 class MatMulCPUKernel : public MKLCPUKernel {
  public:
   MatMulCPUKernel() = default;
@@ -42,8 +41,7 @@ class MatMulCPUKernel : public MKLCPUKernel {
 };
 
 MS_REG_CPU_KERNEL(MatMul, MatMulCPUKernel);
-}  // namespace cpu
-}  // namespace device
+}  // namespace kernel
 }  // namespace mindspore
 
-#endif  // MINDSPORE_CCSRC_DEVICE_CPU_MATMUL_CPU_KERNEL_H_
+#endif  // MINDSPORE_CCSRC_KERNEL_CPU_MATMUL_CPU_KERNEL_H_

mindspore/ccsrc/kernel/cpu/mkldnn/mkl_cpu_kernel.cc

@@ -13,16 +13,15 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-#include "device/cpu/kernel/mkldnn/mkl_cpu_kernel.h"
+#include "kernel/cpu/mkldnn/mkl_cpu_kernel.h"
 #include <vector>
 #include <string>
 #include <algorithm>
 #include "common/utils.h"
-#include "device/cpu/kernel/mkldnn/mkl_kernel_engine.h"
+#include "kernel/cpu/mkldnn/mkl_kernel_engine.h"
 
 namespace mindspore {
-namespace device {
-namespace cpu {
+namespace kernel {
 void MKLCPUKernel::GetPadding(const CNodePtr &kernel_node, const std::string &pad_mode,
                               const std::vector<size_t> &src_shape, int kernel_size, int stride,
                               std::vector<int> *padding_l, std::vector<int> *padding_r) {
@@ -99,6 +98,5 @@ void MKLCPUKernel::SetArgumentHandle(int arg_key, void *ptr) {
 }
 
 void MKLCPUKernel::ExecutePrimitive() { MKLKernelEngine::Get().Execute(primitive_, arguments_); }
-}  // namespace cpu
-}  // namespace device
+}  // namespace kernel
 }  // namespace mindspore

mindspore/ccsrc/kernel/cpu/mkldnn/mkl_cpu_kernel.h

@@ -13,20 +13,19 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-#ifndef MINDSPORE_CCSRC_DEVICE_CPU_MKL_CPU_KERNEL_H_
-#define MINDSPORE_CCSRC_DEVICE_CPU_MKL_CPU_KERNEL_H_
+#ifndef MINDSPORE_CCSRC_KERNEL_CPU_MKL_CPU_KERNEL_H_
+#define MINDSPORE_CCSRC_KERNEL_CPU_MKL_CPU_KERNEL_H_
 
 #include <string>
 #include <unordered_map>
 #include <memory>
 #include <vector>
 #include "dnnl.hpp"
-#include "device/cpu/cpu_kernel.h"
-#include "device/cpu/cpu_kernel_factory.h"
+#include "kernel/cpu/cpu_kernel.h"
+#include "kernel/cpu/cpu_kernel_factory.h"
 
 namespace mindspore {
-namespace device {
-namespace cpu {
+namespace kernel {
 class MKLCPUKernel : public CPUKernel {
  public:
   MKLCPUKernel() = default;
@@ -43,8 +42,7 @@ class MKLCPUKernel : public CPUKernel {
   std::unordered_map<int, dnnl::memory> arguments_;
   std::shared_ptr<dnnl::primitive> primitive_{nullptr};
 };
-}  // namespace cpu
-}  // namespace device
+}  // namespace kernel
 }  // namespace mindspore
 
-#endif  // MINDSPORE_CCSRC_DEVICE_CPU_MKL_CPU_KERNEL_H_
+#endif  // MINDSPORE_CCSRC_KERNEL_CPU_MKL_CPU_KERNEL_H_