modelbox: move implimentation to .cpp file

Author: pymumu

src/libmodelbox/base/config/configuration.cc

@@ -14,7 +14,6 @@
  * limitations under the License.
  */
 
-
 #include "modelbox/base/configuration.h"
 
 #include <toml.hpp>
@@ -96,6 +95,32 @@ std::unique_ptr<ConfigStore> ConfigStore::GetSubConfigStore(
   return sub_store;
 }
 
+size_t ConfigStore::Size() const { return properties_.size(); }
+
+bool ConfigStore::Contain(const std::string &key) const {
+  auto item = properties_.find(key);
+  return item != properties_.end();
+}
+
+void ConfigStore::Add(const ConfigStore &store) {
+  for (const auto &iter : store.properties_) {
+    properties_[iter.first] = iter.second;
+  }
+
+  for (const auto &iter : store.sub_key_index_) {
+    sub_key_index_[iter.first] = iter.second;
+  }
+}
+
+void ConfigStore::Copy(const ConfigStore &store, const std::string &key) {
+  if (store.Contain(key) == false) {
+    return;
+  }
+  std::string property;
+  store.ReadProperty(key, &property);
+  WriteProperty(key, property);
+}
+
 void ConfigStore::AddSubConfig(const std::string &prefix_key,
                                ConfigStore *store, size_t key_offset) const {
   auto sub_keys = GetSubKeys(prefix_key);

src/libmodelbox/base/device/device.cc

@@ -40,6 +40,23 @@ Device::Device(size_t thread_count,
   }
 }
 
+std::string Device::GetDeviceID() const {
+  if (device_desc_ != nullptr) {
+    return device_desc_->GetDeviceId();
+  }
+
+  return "";
+}
+
+std::shared_ptr<Executor> Device::GetDeviceExecutor() { return executor_; }
+
+Status Device::DeviceExecute(const DevExecuteCallBack &fun, int32_t priority,
+                             size_t count) {
+  return STATUS_NOTSUPPORT;
+}
+
+std::string Device::GetType() const { return ""; }
+
 bool Device::NeedResourceNice() { return false; }
 
 std::list<std::future<Status>> Device::DeviceExecuteAsync(

src/libmodelbox/base/device/device_manager.cc

@@ -14,7 +14,6 @@
  * limitations under the License.
  */
 
-
 #include <stdio.h>
 
 #include <string>
@@ -27,6 +26,26 @@
 #include "modelbox/base/status.h"
 
 namespace modelbox {
+
+DeviceFactory::DeviceFactory() = default;
+DeviceFactory::~DeviceFactory() = default;
+
+std::map<std::string, std::shared_ptr<DeviceDesc>>
+DeviceFactory::DeviceProbe() {
+  return std::map<std::string, std::shared_ptr<DeviceDesc>>();
+}
+
+std::shared_ptr<Device> DeviceFactory::CreateDevice(
+    const std::string &device_id) {
+  return nullptr;
+}
+
+std::string DeviceFactory::GetDeviceFactoryType() { return ""; }
+
+std::vector<std::string> DeviceFactory::GetDeviceList() {
+  return std::vector<std::string>();
+}
+
 DeviceManager::DeviceManager() = default;
 DeviceManager::~DeviceManager() = default;
 
@@ -149,12 +168,12 @@ std::shared_ptr<Device> DeviceManager::CreateDevice(
 
   auto id_desc = device_desc_list_[device_type].find(device_id);
   if (id_desc == device_desc_list_[device_type].end()) {
-    StatusError = {STATUS_NOTFOUND,
-                   "Can't find device, type " + device_type + " id: " + device_id};
+    StatusError = {STATUS_NOTFOUND, "Can't find device, type " + device_type +
+                                        " id: " + device_id};
     MBLOG_ERROR << StatusError.Errormsg();
     return nullptr;
   }
-  
+
   auto iter = device_factory_.find(device_type);
   if (iter == device_factory_.end()) {
     StatusError = {STATUS_NOTFOUND, "device type not found: " + device_type};
@@ -173,7 +192,6 @@ std::shared_ptr<Device> DeviceManager::CreateDevice(
     return nullptr;
   }
 
-
   device->SetDeviceDesc(device_desc_list_[device_type][device_id]);
   auto &id_map = device_list_[device_type];
   id_map[device_id] = device;

src/libmodelbox/base/device/device_memory.cc

@@ -14,10 +14,10 @@
  * limitations under the License.
  */
 
-#include <utility>
-
 #include "modelbox/base/device_memory.h"
 
+#include <utility>
+
 #include "modelbox/base/device.h"
 #include "modelbox/base/log.h"
 #include "modelbox/base/slab.h"
@@ -54,6 +54,30 @@ void DeviceMemory::UpdateMemID(void *device_mem_ptr) {
   memory_id_ = std::to_string((uintptr_t)device_mem_ptr);
 }
 
+Status DeviceMemory::SetContentMutable(bool content_mutable) {
+  is_content_mutable_ = content_mutable;
+  // TODO: Protect memory in device
+  return STATUS_SUCCESS;
+}
+
+size_t DeviceMemory::GetSize() const { return size_; };
+
+size_t DeviceMemory::GetCapacity() const { return capacity_; };
+
+std::string DeviceMemory::GetMemoryID() const { return memory_id_; }
+
+std::shared_ptr<Device> DeviceMemory::GetDevice() const { return device_; }
+
+uint32_t DeviceMemory::GetMemFlags() const { return mem_flags_; }
+
+bool DeviceMemory::IsHost() const { return is_host_mem_; }
+
+bool DeviceMemory::IsSameDevice(const std::shared_ptr<DeviceMemory> &dev_mem) {
+  return dev_mem ? (device_ == dev_mem->device_ &&
+                    mem_flags_ == dev_mem->mem_flags_)
+                 : false;
+}
+
 bool DeviceMemory::IsContiguous(
     const std::vector<std::shared_ptr<DeviceMemory>> &mem_list,
     bool with_order) {
@@ -199,6 +223,8 @@ Status DeviceMemory::CountMemSize(
   return STATUS_SUCCESS;
 }
 
+Status DeviceMemory::Verify() const { return STATUS_SUCCESS; }
+
 Status DeviceMemory::Resize(size_t new_size) {
   if (new_size > capacity_) {
     MBLOG_ERROR << "New size " << new_size << " > capacity " << capacity_;

src/libmodelbox/base/drivers/driver.cc

@@ -407,7 +407,8 @@ std::shared_ptr<DriverFactory> Driver::CreateFactory() {
 
   auto holder = shared_from_this();
   std::shared_ptr<DriverFactory> child_factory(
-      factory_.get(), [&, holder](DriverFactory *child_factory) { holder->CloseFactory(); });
+      factory_.get(),
+      [&, holder](DriverFactory *child_factory) { holder->CloseFactory(); });
 
   return child_factory;
 }
@@ -418,6 +419,15 @@ void Driver::SetDriverDesc(std::shared_ptr<DriverDesc> desc) {
   desc_ = std::move(desc);
 }
 
+DriverFactory::DriverFactory() = default;
+DriverFactory::~DriverFactory() = default;
+
+std::shared_ptr<Driver> DriverFactory::GetDriver() {
+  return std::make_shared<Driver>();
+};
+
+void DriverFactory::SetDriver(const std::shared_ptr<Driver> &driver) {}
+
 // DriverDesc
 std::string DriverDesc::GetClass() { return driver_class_; }
 
@@ -505,7 +515,25 @@ void DriverDesc::SetFilePath(const std::string &file_path) {
   driver_file_path_ = file_path;
 }
 
+DriversScanResultInfo::DriversScanResultInfo() = default;
+DriversScanResultInfo::~DriversScanResultInfo() {
+  load_success_info_.clear();
+  load_failed_info_.clear();
+}
+
+std::list<std::string> &DriversScanResultInfo::GetLoadSuccessInfo() {
+  return load_success_info_;
+}
+
+std::map<std::string, std::string> &DriversScanResultInfo::GetLoadFailedInfo() {
+  return load_failed_info_;
+}
+
 // Drivers
+Drivers::Drivers()
+    : drivers_scan_result_info_(std::make_shared<DriversScanResultInfo>()){};
+Drivers::~Drivers() = default;
+
 std::shared_ptr<Drivers> Drivers::GetInstance() {
   static std::shared_ptr<Drivers> drivers = std::make_shared<Drivers>();
   return drivers;

src/libmodelbox/base/drivers/register_flowunit.cc

@@ -14,10 +14,10 @@
  * limitations under the License.
  */
 
-#include <utility>
-
 #include "modelbox/base/register_flowunit.h"
 
+#include <utility>
+
 constexpr const char *VIRTUAL_TYPE = "register_flowunit";
 
 namespace modelbox {
@@ -62,6 +62,15 @@ RegisterFlowUnitFactory::RegisterFlowUnitFactory(
   }
 }
 
+std::map<std::string, std::shared_ptr<FlowUnitDesc>>
+RegisterFlowUnitFactory::FlowUnitProbe() {
+  return desc_map_;
+}
+
+std::string RegisterFlowUnitFactory::GetFlowUnitFactoryType() {
+  return FLOWUNIT_TYPE;
+}
+
 std::shared_ptr<FlowUnit> RegisterFlowUnitFactory::CreateFlowUnit(
     const std::string &name, const std::string &unit_type) {
   auto register_flowunit = std::make_shared<RegisterFlowUnit>(name);

src/libmodelbox/base/drivers/virtual_driver.cc

@@ -14,9 +14,8 @@
  * limitations under the License.
  */
 
-
-#include <modelbox/base/config.h>
 #include <dlfcn.h>
+#include <modelbox/base/config.h>
 
 #include <memory>
 #include <utility>
@@ -50,9 +49,7 @@ Status VirtualDriverManager::Scan(const std::vector<std::string> &scan_dirs) {
   return ret;
 }
 
-Status VirtualDriverManager::Scan(const std::string &path) {
-  return STATUS_OK;
-}
+Status VirtualDriverManager::Scan(const std::string &path) { return STATUS_OK; }
 
 std::vector<std::shared_ptr<VirtualDriver>>
 VirtualDriverManager::GetAllDriverList() {
@@ -70,6 +67,10 @@ void VirtualDriver::SetVirtualDriverDesc(
   virtual_driver_desc_ = std::move(desc);
 }
 
+std::vector<std::shared_ptr<Driver>> VirtualDriver::GetBindDriver() {
+  return std::vector<std::shared_ptr<Driver>>();
+}
+
 std::shared_ptr<DriverFactory> VirtualDriver::CreateFactory() {
   return nullptr;
 }

src/libmodelbox/base/include/modelbox/base/any.h

@@ -167,18 +167,16 @@ ValueType any_cast(Any& any) {
 
 class Collection {
  public:
-  Collection() = default;
+  Collection();
 
-  virtual ~Collection() = default;
+  virtual ~Collection();
 
   template <typename T>
   void Set(const std::string& key, T&& value) {
     entrys_[key] = Any(value);
   }
 
-  void Set(const std::string& key, const char* value) {
-    entrys_[key] = Any(std::string(value));
-  }
+  void Set(const std::string& key, const char* value);
 
   template <typename T>
   bool Get(const std::string& key, T&& value) {
@@ -200,43 +198,10 @@ class Collection {
     return true;
   }
 
-  std::tuple<Any*, bool> Get(const std::string& key) {
-    auto iter = entrys_.find(key);
-    if (iter != entrys_.end()) {
-      return std::make_tuple(&(iter->second), true);
-    }
-
-    return std::make_tuple(nullptr, false);
-  }
-
-  void Merge(const Collection& other, bool is_override = false) {
-    if (!is_override) {
-      entrys_.insert(other.entrys_.begin(), other.entrys_.end());
-    } else {
-      for (auto& iter : entrys_) {
-        entrys_[iter.first] = iter.second;
-      }
-    }
-  }
+  std::tuple<Any*, bool> Get(const std::string& key);
 
-  bool CanConvert(size_t cast_code, size_t origin_code) {
-    if (cast_code == origin_code) {
-      return true;
-    }
-
-    auto iter = type_hash_code_map.find(origin_code);
-    if (iter == type_hash_code_map.end()) {
-      return false;
-    }
-
-    if (type_hash_code_map[origin_code] == cast_code) {
-      MBLOG_DEBUG
-          << "origin type is not match cast type, maybe loss the accuracy.";
-      return true;
-    }
-
-    return false;
-  }
+  void Merge(const Collection& other, bool is_override = false);
+  bool CanConvert(size_t cast_code, size_t origin_code);
 
  private:
   std::map<std::string, Any> entrys_;