module.h

Go to the documentation of this file.

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */
 
#ifndef TVM_RUNTIME_MODULE_H_
#define TVM_RUNTIME_MODULE_H_
 
#include <dmlc/io.h>
#include <tvm/runtime/c_runtime_api.h>
#include <tvm/runtime/container/string.h>
#include <tvm/runtime/memory.h>
#include <tvm/runtime/object.h>
 
#include <memory>
#include <mutex>
#include <string>
#include <unordered_map>
#include <vector>
 
namespace tvm {
namespace runtime {
 
enum ModulePropertyMask : int {
  kBinarySerializable = 0b001,
  kRunnable = 0b010,
  kDSOExportable = 0b100
};
 
class ModuleNode;
class PackedFunc;
 
class Module : public ObjectRef {
 public:
  Module() {}
  // constructor from container.
  explicit Module(ObjectPtr<Object> n) : ObjectRef(n) {}
  inline PackedFunc GetFunction(const String& name, bool query_imports = false);
  // The following functions requires link with runtime.
  inline void Import(Module other);
  inline ModuleNode* operator->();
  inline const ModuleNode* operator->() const;
  TVM_DLL static Module LoadFromFile(const String& file_name, const String& format = "");
  // refer to the corresponding container.
  using ContainerType = ModuleNode;
  friend class ModuleNode;
};
 
class TVM_DLL ModuleNode : public Object {
 public:
  virtual ~ModuleNode() = default;
  virtual const char* type_key() const = 0;
  virtual PackedFunc GetFunction(const String& name, const ObjectPtr<Object>& sptr_to_self) = 0;
  virtual void SaveToFile(const String& file_name, const String& format);
  virtual void SaveToBinary(dmlc::Stream* stream);
  virtual String GetSource(const String& format = "");
  virtual String GetFormat();
  PackedFunc GetFunction(const String& name, bool query_imports = false);
  void Import(Module other);
  const PackedFunc* GetFuncFromEnv(const String& name);
 
  void ClearImports() { imports_.clear(); }
 
  const std::vector<Module>& imports() const { return imports_; }
 
  virtual int GetPropertyMask() const { return 0b000; }
 
  bool IsDSOExportable() const {
    return (GetPropertyMask() & ModulePropertyMask::kDSOExportable) != 0;
  }
 
  bool IsBinarySerializable() const {
    return (GetPropertyMask() & ModulePropertyMask::kBinarySerializable) != 0;
  }
 
  virtual bool ImplementsFunction(const String& name, bool query_imports = false);
 
  // integration with the existing components.
  static constexpr const uint32_t _type_index = TypeIndex::kRuntimeModule;
  static constexpr const char* _type_key = "runtime.Module";
  // NOTE: ModuleNode can still be sub-classed
  //
  TVM_DECLARE_FINAL_OBJECT_INFO(ModuleNode, Object);
 
 protected:
  friend class Module;
  friend class ModuleInternal;
  std::vector<Module> imports_;
 
 private:
  std::unordered_map<std::string, std::shared_ptr<PackedFunc>> import_cache_;
  std::mutex mutex_;
};
 
TVM_DLL bool RuntimeEnabled(const String& target);
 
namespace symbol {
constexpr const char* tvm_get_c_metadata = "get_c_metadata";
constexpr const char* tvm_module_ctx = "__tvm_module_ctx";
constexpr const char* tvm_dev_mblob = "__tvm_dev_mblob";
constexpr const char* tvm_set_device = "__tvm_set_device";
constexpr const char* tvm_global_barrier_state = "__tvm_global_barrier_state";
constexpr const char* tvm_prepare_global_barrier = "__tvm_prepare_global_barrier";
constexpr const char* tvm_module_main = "__tvm_main__";
constexpr const char* tvm_param_prefix = "__tvm_param__";
constexpr const char* tvm_lookup_linked_param = "_lookup_linked_param";
constexpr const char* tvm_entrypoint_suffix = "run";
}  // namespace symbol
 
// implementations of inline functions.
 
inline void Module::Import(Module other) { return (*this)->Import(other); }
 
inline ModuleNode* Module::operator->() { return static_cast<ModuleNode*>(get_mutable()); }
 
inline const ModuleNode* Module::operator->() const {
  return static_cast<const ModuleNode*>(get());
}
 
inline std::ostream& operator<<(std::ostream& out, const Module& module) {
  out << "Module(type_key= ";
  out << module->type_key();
  out << ")";
 
  return out;
}
 
}  // namespace runtime
}  // namespace tvm
 
#include <tvm/runtime/packed_func.h>  // NOLINT(*)
#endif                                // TVM_RUNTIME_MODULE_H_