vm.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_RELAX_VM_VM_H_
#define TVM_RUNTIME_RELAX_VM_VM_H_
 
#ifndef TVM_RELAX_VM_ENABLE_PROFILER
#define TVM_RELAX_VM_ENABLE_PROFILER 1
#endif
 
#include <memory>
#include <string>
#include <unordered_map>
#include <vector>
 
#include "../memory/memory_manager.h"
#include "./bytecode.h"
#include "./executable.h"
 
namespace tvm {
namespace runtime {
 
using memory::Allocator;
using memory::AllocatorType;
using memory::MemoryManager;
using memory::Storage;
using memory::StorageObj;
 
namespace relax_vm {
 
enum class VMInstrumentReturnKind : int {
  kNoOp = 0,
  kSkipRun = 1,
};
 
class VMClosureObj : public ClosureObj {
 public:
  String func_name;
 
  PackedFunc impl;
 
  static constexpr const uint32_t _type_index = TypeIndex::kDynamic;
  static constexpr const char* _type_key = "relax.vm.Closure";
  TVM_DECLARE_FINAL_OBJECT_INFO(VMClosureObj, ClosureObj);
};
 
class VMClosure : public Closure {
 public:
  VMClosure(String func_name, PackedFunc impl);
  TVM_DEFINE_OBJECT_REF_METHODS(VMClosure, Closure, VMClosureObj);
 
  static PackedFunc BindLastArgs(PackedFunc func, std::vector<TVMRetValue> last_args);
};
 
class VMExtensionNode : public Object {
 protected:
  static constexpr const uint32_t _type_index = TypeIndex::kDynamic;
  static constexpr const char* _type_key = "runtime.VMExtension";
  TVM_DECLARE_BASE_OBJECT_INFO(VMExtensionNode, Object);
};
 
class VMExtension : public ObjectRef {
 public:
  TVM_DEFINE_OBJECT_REF_METHODS(VMExtension, ObjectRef, VMExtensionNode);
};
 
class VirtualMachine : public runtime::ModuleNode {
 public:
  virtual void Init(const std::vector<Device>& devices,
                    const std::vector<AllocatorType>& alloc_types) = 0;
  virtual void LoadExecutable(ObjectPtr<Executable> exec) = 0;
  virtual VMClosure GetClosure(const String& func_name) = 0;
  virtual void InvokeClosurePacked(const ObjectRef& closure_or_packedfunc, TVMArgs args,
                                   TVMRetValue* rv) = 0;
  virtual void SetInstrument(PackedFunc instrument) = 0;
 
  template <typename T, typename = std::enable_if_t<std::is_base_of<VMExtension, T>::value>>
  T GetOrCreateExtension() {
    using ContainerType = typename T::ContainerType;
    uint32_t key = ContainerType::RuntimeTypeIndex();
    if (auto it = extensions.find(key); it != extensions.end()) {
      return Downcast<T>((*it).second);
    }
    auto [it, _] = extensions.emplace(key, T::Create());
    return Downcast<T>((*it).second);
  }
 
  static ObjectPtr<VirtualMachine> Create();
  static ObjectPtr<VirtualMachine> CreateProfiler();
  static VirtualMachine* GetContextPtr(TVMArgValue arg) {
    return static_cast<VirtualMachine*>(arg.operator void*());
  }
 
  ~VirtualMachine() {}
 
  //--------------------------------------------------------------------------
  // The following section contains states that other builtin can depend on
  //--------------------------------------------------------------------------
  std::vector<Allocator*> allocators;
  std::vector<Device> devices;
  std::unordered_map<uint32_t, VMExtension> extensions;
};
 
}  // namespace relax_vm
}  // namespace runtime
}  // namespace tvm
 
#endif  // TVM_RUNTIME_RELAX_VM_VM_H_