国产硬件适配

src/02hardware/src/device_manager.cpp

@@ -2,6 +2,7 @@
 #include "hardware/devices/cpu.h"
 #include "hardware/devices/mlu.h"
 #include "hardware/devices/nvidia.h"
+#include "hardware/devices/mlu.h"
 
 namespace refactor::hardware::device {
 

src/04kernel/src/collectors/batch_normalization.cc

@@ -1,6 +1,7 @@
 #include "kernel/collectors/batch_normalization.h"
 #include "../kernels/batch_normalization/cpu_kernel.hh"
 #include "../kernels/batch_normalization/cudnn_kernel.hh"
+#include "../kernels/batch_normalization/cnnl_kernel.hh"
 
 namespace refactor::kernel {
 
@@ -20,6 +21,9 @@ namespace refactor::kernel {
             case decltype(_target)::Nvidia:
                 REGISTER(BatchNormalizationCudnn)
                 break;
+            case decltype(_target)::Mlu:
+                REGISTER(BatchNormalizationCnnl)
+                break;
             default:
                 UNREACHABLEX(void, "Unknown target");
         }

src/04kernel/src/collectors/cast.cc

@@ -1,6 +1,7 @@
 #include "kernel/collectors/cast.h"
 #include "../kernels/cast/cpu_kernel.hh"
 #include "../kernels/cast/cuda_kernel.hh"
+#include "../kernels/cast/cnnl_kernel.hh"
 
 namespace refactor::kernel {
 
@@ -24,6 +25,11 @@ namespace refactor::kernel {
                     ans.emplace_back(std::move(ptr));
                 }
                 break;
+            case decltype(_target)::Mlu:
+                if (auto ptr = CastCnnl::build(from, to); ptr) {
+                    ans.emplace_back(std::move(ptr));
+                }
+                break;
             default:
                 UNREACHABLEX(void, "Unknown target");
         }

src/04kernel/src/collectors/clip.cc

@@ -1,6 +1,7 @@
 #include "kernel/collectors/clip.h"
 #include "../kernels/clip/cpu_kernel.hh"
 #include "../kernels/clip/cuda_kernel.hh"
+#include "../kernels/clip/cnnl_kernel.hh"
 
 namespace refactor::kernel {
 
@@ -24,6 +25,11 @@ namespace refactor::kernel {
                     ans.emplace_back(std::move(ptr));
                 }
                 break;
+            case decltype(_target)::Mlu:
+                if (auto ptr = ClipCnnl::build(data, hasMax); ptr) {
+                    ans.emplace_back(std::move(ptr));
+                }
+                break;
             default:
                 UNREACHABLEX(void, "Unknown target");
         }

src/04kernel/src/collectors/concat.cc

@@ -1,13 +1,16 @@
 #include "kernel/collectors/concat.h"
 #include "../kernels/concat/cpu_kernel.hh"
 #include "../kernels/concat/cuda_kernel.hh"
+#include "../kernels/concat/cnnl_kernel.hh"
 
 namespace refactor::kernel {
 
     std::vector<KernelBox>
     ConcatCollector::filter(TensorRefs inputs, TensorRefs outputs) const {
         SplitInfo info(axis, inputs);
 
+        auto const &b = outputs[0];
+
         std::vector<KernelBox> ans;
         switch (_target) {
             case decltype(_target)::Cpu:
@@ -20,6 +23,11 @@ namespace refactor::kernel {
                     ans.emplace_back(std::move(ptr));
                 }
                 break;
+            case decltype(_target)::Mlu:
+                if (auto ptr = ConcatCnnl::build(axis, inputs, b); ptr) {
+                    ans.emplace_back(std::move(ptr));
+                }
+                break;
             default:
                 UNREACHABLEX(void, "Unknown target");
         }

src/04kernel/src/collectors/conv.cc

@@ -1,4 +1,5 @@
 #include "kernel/collectors/conv.h"
+#include "../kernels/conv/cnnl_kernel.hh"
 #include "../kernels/conv/cudnn_kernel.hh"
 
 namespace refactor::kernel {
@@ -23,6 +24,11 @@ namespace refactor::kernel {
                     ans.emplace_back(std::move(ptr));
                 }
                 break;
+            case decltype(_target)::Mlu:
+                if (auto ptr = ConvCnnl::build(poolAttrs, x, w, b, y); ptr) {
+                    ans.emplace_back(std::move(ptr));
+                }
+                break;
             default:
                 UNREACHABLEX(void, "Unknown target");
         }

src/04kernel/src/collectors/gather.cc

@@ -1,4 +1,5 @@
 #include "kernel/collectors/gather.h"
+#include "../kernels/gather/cnnl_kernel.hh"
 #include "../kernels/gather/cpu_kernel.hh"
 #include "../kernels/gather/cuda_kernel.hh"
 
@@ -8,7 +9,12 @@ namespace refactor::kernel {
     GatherCollector::filter(TensorRefs inputs, TensorRefs outputs) const {
         GatherInfo info(axis, inputs[0], inputs[1]);
 
-        std::vector<KernelBox> ans;
+        auto const &a = inputs[0];
+        auto const &b = inputs[1];
+        auto const &c = outputs[0];
+
+        std::vector<KernelBox>
+            ans;
         switch (_target) {
             case decltype(_target)::Cpu:
                 if (auto ptr = GatherCpu::build(info); ptr != nullptr) {
@@ -20,6 +26,11 @@ namespace refactor::kernel {
                     ans.emplace_back(std::move(ptr));
                 }
                 break;
+            case decltype(_target)::Mlu:
+                if (auto ptr = GatherCnnl::build(axis, a, b, c); ptr != nullptr) {
+                    ans.emplace_back(std::move(ptr));
+                }
+                break;
             default:
                 UNREACHABLEX(void, "Unknown target");
         }

src/04kernel/src/collectors/global_pool.cc

@@ -1,5 +1,6 @@
 #include "kernel/collectors/global_pool.h"
 #include "../kernels/pool/cudnn_kernel.hh"
+#include "../kernels/pool/cnnl_kernel.hh"
 
 namespace refactor::kernel {
 
@@ -28,6 +29,11 @@ namespace refactor::kernel {
                     ans.emplace_back(std::move(ptr));
                 }
                 break;
+            case decltype(_target)::Mlu:
+                if (auto ptr = PoolCnnl::build(type, false, kernelShape, attributes, x, y); ptr) {
+                    ans.emplace_back(std::move(ptr));
+                }
+                break;
             default:
                 UNREACHABLEX(void, "Unknown target");
         }

src/04kernel/src/collectors/hard_sigmoid.cc

@@ -1,4 +1,5 @@
 #include "kernel/collectors/hard_sigmoid.h"
+#include "../kernels/hard_sigmoid/cnnl_kernel.hh"
 #include "../kernels/hard_sigmoid/cpu_kernel.hh"
 #include "../kernels/hard_sigmoid/cuda_kernel.hh"
 
@@ -20,6 +21,11 @@ namespace refactor::kernel {
                     ans.emplace_back(std::move(ptr));
                 }
                 break;
+            case decltype(_target)::Mlu:
+                if (auto ptr = HardSigmoidCnnl::build(alpha, beta, a); ptr) {
+                    ans.emplace_back(std::move(ptr));
+                }
+                break;
             default:
                 UNREACHABLEX(void, "Unknown target");
         }

src/04kernel/src/collectors/mat_mul.cc

@@ -1,4 +1,5 @@
 #include "kernel/collectors/mat_mul.h"
+#include "../kernels/mat_mul/cnnl_kernel.hh"
 #include "../kernels/mat_mul/cpu_kernel.hh"
 #include "../kernels/mat_mul/cublas_kernel.hh"
 #include "kernel/attributes/mat_mul_info.h"
@@ -26,6 +27,11 @@ namespace refactor::kernel {
             case decltype(_target)::Nvidia:
                 REGISTER(MatMulCublas)
                 break;
+            case decltype(_target)::Mlu:
+                if (auto ptr = MatMulCnnl::build(inputs, outputs, transA, transB, alpha, beta); ptr) {
+                    ans.emplace_back(std::move(ptr));
+                }
+                break;
             default:
                 UNREACHABLEX(void, "Unknown target");
         }

src/04kernel/src/collectors/pad.cc

@@ -1,4 +1,5 @@
 #include "kernel/collectors/pad.h"
+#include "../kernels/pad/cnnl_kernel.hh"
 #include "../kernels/pad/cpu_kernel.hh"
 #include "../kernels/pad/cuda_kernel.hh"
 
@@ -22,11 +23,15 @@ namespace refactor::kernel {
                     ans.emplace_back(std::move(ptr));
                 }
                 break;
+            case decltype(_target)::Mlu:
+                if (auto ptr = PadCnnl::build(dims, input.get().dataType, mode, const_value); ptr) {
+                    ans.emplace_back(std::move(ptr));
+                }
+                break;
             default:
                 UNREACHABLEX(void, "Unknown target");
         }
         return ans;
     }
 
 }// namespace refactor::kernel
-

src/04kernel/src/collectors/pool.cc

@@ -1,5 +1,6 @@
 #include "kernel/collectors/pool.h"
 #include "../kernels/pool/cudnn_kernel.hh"
+#include "../kernels/pool/cnnl_kernel.hh"
 
 namespace refactor::kernel {
 
@@ -29,6 +30,11 @@ namespace refactor::kernel {
                     ans.emplace_back(std::move(ptr));
                 }
                 break;
+            case decltype(_target)::Mlu:
+                if (auto ptr = PoolCnnl::build(type, ceil, kernelShape, attributes, x, y); ptr) {
+                    ans.emplace_back(std::move(ptr));
+                }
+                break;
             default:
                 UNREACHABLEX(void, "Unknown target");
         }

src/04kernel/src/collectors/reduce.cc

@@ -1,6 +1,7 @@
 #include "kernel/collectors/reduce.h"
 #include "../kernels/reduce/cpu_kernel.hh"
 #include "../kernels/reduce/cudnn_kernel.hh"
+#include "../kernels/reduce/cnnl_kernel.hh"
 
 namespace refactor::kernel {
 
@@ -27,6 +28,9 @@ namespace refactor::kernel {
             case decltype(_target)::Nvidia:
                 REGISTER(ReduceCudnn)
                 break;
+            case decltype(_target)::Mlu:
+                REGISTER(ReduceCnnl)
+                break;
             default:
                 UNREACHABLEX(void, "Unknown target");
         }

src/04kernel/src/collectors/scatter_nd.cc

@@ -1,6 +1,7 @@
 #include "kernel/collectors/scatter_nd.h"
 #include "../kernels/scatter_nd/cpu_kernel.hh"
 #include "../kernels/scatter_nd/cuda_kernel.hh"
+#include "../kernels/scatter_nd/cnnl_kernel.hh"
 
 namespace refactor::kernel {
 
@@ -23,6 +24,11 @@ namespace refactor::kernel {
                     ans.emplace_back(std::move(ptr));
                 }
                 break;
+            case decltype(_target)::Mlu:
+                if (auto ptr = ScatterNDCnnl::build(inputs, outputs); ptr) {
+                    ans.emplace_back(std::move(ptr));
+                }
+                break;
             default:
                 UNREACHABLEX(void, "Unknown target");
         }

src/04kernel/src/collectors/select.cc

@@ -1,6 +1,7 @@
 #include "kernel/collectors/select.h"
 #include "../kernels/select/cpu_kernel.hh"
 #include "../kernels/select/cuda_kernel.hh"
+#include "../kernels/select/cnnl_kernel.hh"
 
 namespace refactor::kernel {
 
@@ -35,6 +36,9 @@ namespace refactor::kernel {
             case decltype(_target)::Nvidia:
                 REGISTER(SelectCuda)
                 break;
+            case decltype(_target)::Mlu:
+                REGISTER(SelectCnnl)
+                break;
             default:
                 UNREACHABLEX(void, "Unknown target");
         }

src/04kernel/src/collectors/simple_binary.cc

@@ -2,6 +2,7 @@
 #include "../kernels/simple_binary/binary_cudnn.hh"
 #include "../kernels/simple_binary/cpu_kernel.hh"
 #include "../kernels/simple_binary/cuda_kernel.hh"
+#include "../kernels/simple_binary/binary_cnnl.hh"
 
 namespace refactor::kernel {
 
@@ -50,6 +51,9 @@ namespace refactor::kernel {
                 REGISTER_BROCAST(BinaryCudnn)
                 REGISTER(BinaryCuda)
                 break;
+            case decltype(_target)::Mlu:
+                REGISTER_BROCAST(BinaryCnnl)
+                break;
             default:
                 UNREACHABLEX(void, "Unknown target");
         }

src/04kernel/src/collectors/simple_unary.cc

@@ -2,6 +2,8 @@
 #include "../kernels/simple_unary/cpu_kernel.hh"
 #include "../kernels/simple_unary/cuda_kernel.hh"
 #include "../kernels/simple_unary/cudnn_activation_kernel.hh"
+#include "../kernels/simple_unary/cnnl_activation_kernel.hh"
+#include "../kernels/simple_unary/cnnl_simple_unary_kernel.hh"
 #include "common.h"
 
 namespace refactor::kernel {
@@ -55,6 +57,10 @@ namespace refactor::kernel {
                 REGISTER(ActivationCudnn)
                 REGISTER(SimpleUnaryCuda)
                 break;
+            case decltype(_target)::Mlu:
+                REGISTER(ActivationCnnl)
+                REGISTER(SimpleUnaryCnnl)
+                break;
             default:
                 UNREACHABLEX(void, "Unknown target");
         }

src/04kernel/src/collectors/slice.cc

@@ -1,6 +1,7 @@
 #include "kernel/collectors/slice.h"
 #include "../kernels/slice/cpu_kernel.hh"
 #include "../kernels/slice/cuda_kernel.hh"
+#include "../kernels/slice/cnnl_kernel.hh"
 
 namespace refactor::kernel {
 
@@ -26,6 +27,11 @@ namespace refactor::kernel {
                     ans.emplace_back(std::move(ptr));
                 }
                 break;
+            case decltype(_target)::Mlu:
+                if (auto ptr = SliceCnnl::build(inputs[0].get().dataType, dimentions, inputs[0].get().shape, outputs[0].get().shape); ptr) {
+                    ans.emplace_back(std::move(ptr));
+                }
+                break;
             default:
                 UNREACHABLEX(void, "Unknown target");
         }

src/04kernel/src/collectors/softmax.cc

@@ -1,4 +1,5 @@
 #include "kernel/collectors/softmax.h"
+#include "../kernels/softmax/cnnl_kernel.hh"
 #include "../kernels/softmax/cpu_kernel.hh"
 #include "../kernels/softmax/cuda_kernel.hh"
 #include "../kernels/softmax/cudnn_kernel.hh"
@@ -28,6 +29,12 @@ namespace refactor::kernel {
                 }
                 break;
             }
+            case decltype(_target)::Mlu: {
+                if (auto ptr = SoftmaxCnnl::build(cnnl::SoftmaxAlgo::ACCURATE, info); ptr) {
+                    ans.emplace_back(std::move(ptr));
+                }
+                break;
+            }
             default:
                 UNREACHABLEX(void, "Unknown target");
         }