[RUNTIME] Update Module and Registry to use String Container (apache#14902)

This PR updates the Module and Registry's DLL function
to use String container instead of std::string.

While it is impossible to obtain a stable ABI due to the nature
of c++, and it is important to keep that flexibility,
it is helpful to keep small set of tvm/runtime functions to
work with use a String so it is more stable across compilers.

Author: tqchen

apps/dso_plugin_module/plugin_module.cc

@@ -35,8 +35,7 @@ class MyModuleNode : public ModuleNode {
 
   virtual const char* type_key() const final { return "MyModule"; }
 
-  virtual PackedFunc GetFunction(const std::string& name,
-                                 const ObjectPtr<Object>& sptr_to_self) final {
+  virtual PackedFunc GetFunction(const String& name, const ObjectPtr<Object>& sptr_to_self) final {
     if (name == "add") {
       return TypedPackedFunc<int(int)>([sptr_to_self, this](int value) { return value_ + value; });
     } else if (name == "mul") {

include/tvm/runtime/module.h

@@ -90,7 +90,7 @@ class Module : public ObjectRef {
    *  This function will return PackedFunc(nullptr) if function do not exist.
    * \note Implemented in packed_func.cc
    */
-  inline PackedFunc GetFunction(const std::string& name, bool query_imports = false);
+  inline PackedFunc GetFunction(const String& name, bool query_imports = false);
   // The following functions requires link with runtime.
   /*!
    * \brief Import another module into this module.
@@ -111,7 +111,7 @@ class Module : public ObjectRef {
    * \note This function won't load the import relationship.
    *  Re-create import relationship by calling Import.
    */
-  TVM_DLL static Module LoadFromFile(const std::string& file_name, const std::string& format = "");
+  TVM_DLL static Module LoadFromFile(const String& file_name, const String& format = "");
   // refer to the corresponding container.
   using ContainerType = ModuleNode;
   friend class ModuleNode;
@@ -165,14 +165,13 @@ class TVM_DLL ModuleNode : public Object {
    *   If the function need resource from the module(e.g. late linking),
    *   it should capture sptr_to_self.
    */
-  virtual PackedFunc GetFunction(const std::string& name,
-                                 const ObjectPtr<Object>& sptr_to_self) = 0;
+  virtual PackedFunc GetFunction(const String& name, const ObjectPtr<Object>& sptr_to_self) = 0;
   /*!
    * \brief Save the module to file.
    * \param file_name The file to be saved to.
    * \param format The format of the file.
    */
-  virtual void SaveToFile(const std::string& file_name, const std::string& format);
+  virtual void SaveToFile(const String& file_name, const String& format);
   /*!
    * \brief Save the module to binary stream.
    * \param stream The binary stream to save to.
@@ -186,12 +185,12 @@ class TVM_DLL ModuleNode : public Object {
    * \param format Format of the source code, can be empty by default.
    * \return Possible source code when available.
    */
-  virtual std::string GetSource(const std::string& format = "");
+  virtual String GetSource(const String& format = "");
   /*!
    * \brief Get the format of the module, when available.
    * \return Possible format when available.
    */
-  virtual std::string GetFormat();
+  virtual String GetFormat();
   /*!
    * \brief Get packed function from current module by name.
    *
@@ -201,7 +200,7 @@ class TVM_DLL ModuleNode : public Object {
    *  This function will return PackedFunc(nullptr) if function do not exist.
    * \note Implemented in packed_func.cc
    */
-  PackedFunc GetFunction(const std::string& name, bool query_imports = false);
+  PackedFunc GetFunction(const String& name, bool query_imports = false);
   /*!
    * \brief Import another module into this module.
    * \param other The module to be imported.
@@ -217,7 +216,7 @@ class TVM_DLL ModuleNode : public Object {
    * \param name name of the function.
    * \return The corresponding function.
    */
-  const PackedFunc* GetFuncFromEnv(const std::string& name);
+  const PackedFunc* GetFuncFromEnv(const String& name);
   /*! \return The module it imports from */
   const std::vector<Module>& imports() const { return imports_; }
 
@@ -268,7 +267,7 @@ class TVM_DLL ModuleNode : public Object {
  * \param target The target module name.
  * \return Whether runtime is enabled.
  */
-TVM_DLL bool RuntimeEnabled(const std::string& target);
+TVM_DLL bool RuntimeEnabled(const String& target);
 
 /*! \brief namespace for constant symbols */
 namespace symbol {

include/tvm/runtime/packed_func.h

@@ -1942,7 +1942,7 @@ inline TVMRetValue::operator T() const {
   return PackedFuncValueConverter<T>::From(*this);
 }
 
-inline PackedFunc Module::GetFunction(const std::string& name, bool query_imports) {
+inline PackedFunc Module::GetFunction(const String& name, bool query_imports) {
   return (*this)->GetFunction(name, query_imports);
 }
 

include/tvm/runtime/registry.h

@@ -43,9 +43,9 @@
 #ifndef TVM_RUNTIME_REGISTRY_H_
 #define TVM_RUNTIME_REGISTRY_H_
 
+#include <tvm/runtime/container/string.h>
 #include <tvm/runtime/packed_func.h>
 
-#include <string>
 #include <type_traits>
 #include <utility>
 #include <vector>
@@ -295,32 +295,32 @@ class Registry {
    * \param override Whether allow override existing function.
    * \return Reference to the registry.
    */
-  TVM_DLL static Registry& Register(const std::string& name, bool override = false);  // NOLINT(*)
+  TVM_DLL static Registry& Register(const String& name, bool override = false);  // NOLINT(*)
   /*!
    * \brief Erase global function from registry, if exist.
    * \param name The name of the function.
    * \return Whether function exist.
    */
-  TVM_DLL static bool Remove(const std::string& name);
+  TVM_DLL static bool Remove(const String& name);
   /*!
    * \brief Get the global function by name.
    * \param name The name of the function.
    * \return pointer to the registered function,
    *   nullptr if it does not exist.
    */
-  TVM_DLL static const PackedFunc* Get(const std::string& name);  // NOLINT(*)
+  TVM_DLL static const PackedFunc* Get(const String& name);  // NOLINT(*)
   /*!
    * \brief Get the names of currently registered global function.
    * \return The names
    */
-  TVM_DLL static std::vector<std::string> ListNames();
+  TVM_DLL static std::vector<String> ListNames();
 
   // Internal class.
   struct Manager;
 
  protected:
   /*! \brief name of the function */
-  std::string name_;
+  String name_;
   /*! \brief internal packed function */
   PackedFunc func_;
   friend struct Manager;

include/tvm/runtime/vm/executable.h

@@ -64,7 +64,7 @@ class TVM_DLL Executable : public ModuleNode {
    *
    * \return PackedFunc or nullptr when it is not available.
    */
-  PackedFunc GetFunction(const std::string& name, const ObjectPtr<Object>& sptr_to_self) final;
+  PackedFunc GetFunction(const String& name, const ObjectPtr<Object>& sptr_to_self) final;
 
   /*! \brief Get the property of the runtime module .*/
   int GetPropertyMask() const final { return ModulePropertyMask::kBinarySerializable; };
@@ -88,7 +88,7 @@ class TVM_DLL Executable : public ModuleNode {
    * \param path The path to write the serialized data to.
    * \param format The format of the serialized blob.
    */
-  void SaveToFile(const std::string& path, const std::string& format) final;
+  void SaveToFile(const String& path, const String& format) final;
 
   /*!
    * \brief Serialize the executable into global section, constant section, and

include/tvm/runtime/vm/vm.h

@@ -164,7 +164,7 @@ class TVM_DLL VirtualMachine : public runtime::ModuleNode {
    *   If the function needs resource from the module(e.g. late linking),
    *   it should capture sptr_to_self.
    */
-  virtual PackedFunc GetFunction(const std::string& name, const ObjectPtr<Object>& sptr_to_self);
+  virtual PackedFunc GetFunction(const String& name, const ObjectPtr<Object>& sptr_to_self);
 
   virtual ~VirtualMachine() {}
 

src/relay/backend/aot_executor_codegen.cc

@@ -1310,7 +1310,7 @@ class AOTExecutorCodegen : public MixedModeVisitor {
 class AOTExecutorCodegenModule : public runtime::ModuleNode {
  public:
   AOTExecutorCodegenModule() {}
-  virtual PackedFunc GetFunction(const std::string& name, const ObjectPtr<Object>& sptr_to_self) {
+  virtual PackedFunc GetFunction(const String& name, const ObjectPtr<Object>& sptr_to_self) {
     if (name == "init") {
       return PackedFunc([sptr_to_self, this](TVMArgs args, TVMRetValue* rv) {
         ICHECK_EQ(args.num_args, 2) << "The expected of arguments are: "

src/relay/backend/build_module.cc

@@ -172,7 +172,7 @@ class RelayBuildModule : public runtime::ModuleNode {
    * \param sptr_to_self The pointer to the module node.
    * \return The corresponding member function.
    */
-  PackedFunc GetFunction(const std::string& name, const ObjectPtr<Object>& sptr_to_self) final {
+  PackedFunc GetFunction(const String& name, const ObjectPtr<Object>& sptr_to_self) final {
     if (name == "get_graph_json") {
       return PackedFunc(
           [sptr_to_self, this](TVMArgs args, TVMRetValue* rv) { *rv = this->GetGraphJSON(); });

src/relay/backend/contrib/ethosu/source_module.cc

@@ -78,7 +78,7 @@ class EthosUModuleNode : public ModuleNode {
    * \param file_name The file to be saved to.
    * \param format The format of the file.
    */
-  void SaveToFile(const std::string& file_name, const std::string& format) final {
+  void SaveToFile(const String& file_name, const String& format) final {
     std::string fmt = GetFileFormat(file_name, format);
     ICHECK_EQ(fmt, "c") << "Can only save to format="
                         << "c";
@@ -87,9 +87,9 @@ class EthosUModuleNode : public ModuleNode {
     out.close();
   }
 
-  std::string GetSource(const std::string& format) final { return c_source; }
+  String GetSource(const String& format) final { return c_source; }
 
-  std::string GetFormat() override { return "c"; }
+  String GetFormat() override { return "c"; }
 
   Array<CompilationArtifact> GetArtifacts() { return compilation_artifacts_; }
 
@@ -101,7 +101,7 @@ class EthosUModuleNode : public ModuleNode {
    *
    * \return The function pointer when it is found, otherwise, PackedFunc(nullptr).
    */
-  PackedFunc GetFunction(const std::string& name, const ObjectPtr<Object>& sptr_to_self) final {
+  PackedFunc GetFunction(const String& name, const ObjectPtr<Object>& sptr_to_self) final {
     if (name == "get_func_names") {
       return PackedFunc([sptr_to_self, this](TVMArgs args, TVMRetValue* rv) {
         Array<String> func_names;

src/relay/backend/graph_executor_codegen.cc

@@ -628,7 +628,7 @@ class GraphExecutorCodegen : public backend::MemoizedExprTranslator<std::vector<
 class GraphExecutorCodegenModule : public runtime::ModuleNode {
  public:
   GraphExecutorCodegenModule() {}
-  virtual PackedFunc GetFunction(const std::string& name, const ObjectPtr<Object>& sptr_to_self) {
+  virtual PackedFunc GetFunction(const String& name, const ObjectPtr<Object>& sptr_to_self) {
     if (name == "init") {
       return PackedFunc([sptr_to_self, this](TVMArgs args, TVMRetValue* rv) {
         ICHECK_EQ(args.num_args, 2) << "The expected of arguments are: "