1 /** 2 * Copyright 2021 Huawei Technologies Co., Ltd 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 #ifndef MINDSPORE_CCSRC_RUNTIME_HARDWARE_CPU_CPU_DEVICE_CONTEXT_H_ 17 #define MINDSPORE_CCSRC_RUNTIME_HARDWARE_CPU_CPU_DEVICE_CONTEXT_H_ 18 19 #include <vector> 20 #include <memory> 21 #include <string> 22 #include <mutex> 23 #include "runtime/hardware/device_context.h" 24 #include "runtime/hardware/device_context_manager.h" 25 #include "runtime/device/memory_manager.h" 26 27 namespace mindspore { 28 namespace device { 29 namespace cpu { 30 class CPUDeviceResManager : public DeviceResManager { 31 public: CPUDeviceResManager()32 CPUDeviceResManager() {} 33 ~CPUDeviceResManager() override = default; 34 35 void Initialize() override; 36 37 void Destroy() override; 38 39 std::vector<void *> AllocateContinuousMemory(const std::vector<size_t> &size_list, 40 uint32_t stream_id = kDefaultStreamIndex) const override; 41 42 DeviceAddressPtr CreateDeviceAddress(const KernelTensorPtr &kernel_tensor) const override; 43 DeviceAddressPtr CreateDeviceAddress(void *ptr, size_t size, const ShapeVector &shape_vector, const Format &format, 44 TypeId type_id, const std::string &device_name, uint32_t device_id, 45 uint32_t stream_id) const override; 46 47 bool LoadCollectiveCommLib() override; 48 49 void MoveTo(const tensor::TensorPtr &src_tensor, const tensor::TensorPtr &dst_tensor, const std::string &to, 50 bool blocking, bool *return_self) override; 51 52 // Relevant function to allocate and free device memory of raw ptr. 53 void *AllocateMemory(size_t size, uint32_t stream_id = kDefaultStreamIndex) const override; 54 void FreeMemory(void *ptr) const override; 55 void FreePartMemorys(const std::vector<void *> &free_addrs, const std::vector<void *> &keep_addrs, 56 const std::vector<size_t> &keep_addr_sizes) const override; 57 }; 58 59 class CPUKernelExecutor : public KernelExecutor { 60 public: 61 CPUKernelExecutor() = default; 62 ~CPUKernelExecutor() override = default; 63 64 void OptimizeGraph(const FuncGraphPtr &graph) const override; 65 66 void CreateKernel(const std::vector<CNodePtr> &nodes) const override; 67 kernel::KernelModPtr CreateKernelMod(const std::string &op_name) const override; 68 69 // Kernel that is not supported by other device can be backed off and rebuilt on the CPU. 70 // The function will set kernel info and create kernel mod. 71 void RebuildKernelSelectBackoffOp(const std::vector<CNodePtr> &nodes) const; 72 73 void PreprocessBeforeRun(const FuncGraphPtr &graph) const override; 74 75 bool LaunchKernel(const CNodePtr &kernel, const std::vector<KernelTensor *> &inputs, 76 const std::vector<KernelTensor *> &workspace, const std::vector<KernelTensor *> &outputs, 77 KernelMod *kernel_mod, void * /*stream*/) const override; 78 79 bool ExecuteKernelTask(const runtime::KernelTaskType &task_type, const device::DeviceAddressPtrList &input_addr_list, 80 const device::DeviceAddressPtrList &output_addr_list, const size_t &stream_id) const override; 81 82 private: 83 // Select the matching backend kernels according to the data type and format of input and output for all 84 // execution operators, and set final device data type and format information for backend kernels, device 85 // data type and format which replace original data type and format will use for executing kernels. 86 void SetOperatorInfo(const KernelGraphPtr &graph) const; 87 void SingleOpGraphOptimize(const KernelGraphPtr &graph) const; 88 void OptimizeGraphImpl(const KernelGraphPtr &graph) const; 89 void OptimizeMindIR(const KernelGraphPtr &graph) const; 90 #ifndef ENABLE_SECURITY 91 // Launch a kernel and record the elapsed time end to end. 92 bool LaunchKernelWithProfiling(const CNodePtr &kernel, const std::vector<KernelTensor *> &inputs, 93 const std::vector<KernelTensor *> &workspace, 94 const std::vector<KernelTensor *> &outputs, KernelMod *kernel_mod) const; 95 #endif 96 // Launch a kernel by 'KernelMod' of the kernel. 97 bool DoLaunchKernel(const CNodePtr &kernel, const std::vector<KernelTensor *> &inputs, 98 const std::vector<KernelTensor *> &workspace, const std::vector<KernelTensor *> &outputs, 99 KernelMod *kernel_mod) const; 100 void UpdateKernelRefInfo(const KernelGraphPtr &graph) const; 101 102 mutable std::mutex launch_mutex_; 103 }; 104 105 class CPUDeviceContext : public DeviceInterface<CPUKernelExecutor, CPUDeviceResManager> { 106 public: CPUDeviceContext(const DeviceContextKey & device_context_key)107 explicit CPUDeviceContext(const DeviceContextKey &device_context_key) : DeviceInterface(device_context_key) {} 108 ~CPUDeviceContext() override = default; 109 110 void Initialize() override; 111 112 void Destroy() override; 113 GetRunMode(const FuncGraphPtr & func_graph)114 RunMode GetRunMode(const FuncGraphPtr &func_graph) const override { return RunMode::kKernelMode; } 115 116 private: 117 DISABLE_COPY_AND_ASSIGN(CPUDeviceContext); 118 }; 119 } // namespace cpu 120 } // namespace device 121 } // namespace mindspore 122 123 #endif // MINDSPORE_CCSRC_RUNTIME_HARDWARE_CPU_CPU_DEVICE_CONTEXT_H_ 124