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_VM_VM_H_
#define TVM_RUNTIME_VM_VM_H_
 
#include <tvm/runtime/container/closure.h>
#include <tvm/runtime/memory/memory_manager.h>
#include <tvm/runtime/module.h>
#include <tvm/runtime/object.h>
#include <tvm/runtime/packed_func.h>
#include <tvm/runtime/registry.h>
#include <tvm/runtime/vm/bytecode.h>
#include <tvm/runtime/vm/executable.h>
 
#include <memory>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>
 
namespace tvm {
namespace runtime {
 
using memory::Allocator;
using memory::AllocatorType;
using memory::MemoryManager;
using memory::Storage;
using memory::StorageObj;
 
namespace vm {
 
class VMClosureObj : public ClosureObj {
 public:
  size_t func_index;
  std::vector<ObjectRef> free_vars;
 
  static constexpr const uint32_t _type_index = TypeIndex::kDynamic;
  static constexpr const char* _type_key = "vm.Closure";
  TVM_DECLARE_FINAL_OBJECT_INFO(VMClosureObj, ClosureObj);
};
 
class VMClosure : public Closure {
 public:
  VMClosure(size_t func_index, std::vector<ObjectRef> free_vars);
  TVM_DEFINE_OBJECT_REF_METHODS(VMClosure, Closure, VMClosureObj);
};
 
struct VMFunction {
  std::string name;
  std::vector<std::string> params;
  std::vector<Instruction> instructions;
  Index register_file_size = 0;
  std::vector<Index> param_device_indexes;
 
  VMFunction(std::string name, std::vector<std::string> params,
             std::vector<Instruction> instructions, Index register_file_size,
             std::vector<Index> param_device_indexes)
      : name(std::move(name)),
        params(std::move(params)),
        instructions(std::move(instructions)),
        register_file_size(register_file_size),
        param_device_indexes(std::move(param_device_indexes)) {
    ICHECK_EQ(this->params.size(), this->param_device_indexes.size());
  }
 
  VMFunction() = default;
 
  friend std::ostream& operator<<(std::ostream& os, const VMFunction&);
};
 
struct VMFrame {
  Index pc;
  Index func_index;
  Index args;
  const Instruction* code;
 
  std::vector<ObjectRef> register_file;
 
  RegName caller_return_register;
 
  VMFrame(Index pc, Index func_index, Index args, const Instruction* code, Index register_file_size)
      : pc(pc),
        func_index(func_index),
        args(args),
        code(code),
        register_file(register_file_size),
        caller_return_register(0) {}
};
 
class TVM_DLL VirtualMachine : public runtime::ModuleNode {
 public:
  virtual PackedFunc GetFunction(const String& name, const ObjectPtr<Object>& sptr_to_self);
 
  virtual ~VirtualMachine() {}
 
  const char* type_key() const final { return "VirtualMachine"; }
 
  VirtualMachine() : frames_(), func_index_(0), code_(nullptr), pc_(0), exec_(nullptr) {}
 
  virtual void LoadExecutable(const ObjectPtr<Executable>& exec);
 
  int GetPropertyMask() const final { return ModulePropertyMask::kRunnable; }
 
 protected:
  void PushFrame(Index arg_count, Index ret_pc, const VMFunction& vm_func);
 
  Index PopFrame();
 
  inline void WriteRegister(RegName reg, const ObjectRef& obj);
 
  ObjectRef ReadRegister(RegName reg) const;
 
  int64_t LoadScalarInt(RegName reg) const;
 
  ObjectRef Invoke(const VMFunction& func, const std::vector<ObjectRef>& args);
 
  // TODO(@jroesch): I really would like this to be a global variable.
  ObjectRef Invoke(const std::string& name, const std::vector<ObjectRef>& args);
 
  ObjectRef Invoke(const VMFunction& func, const std::vector<ObjectRef>& input_args,
                   const std::vector<ObjectRef>& output_args);
 
  virtual void InvokePacked(Index packed_index, const PackedFunc& func, Index arg_count,
                            Index output_size, const std::vector<ObjectRef>& args);
 
  void Init(const std::vector<Device>& physical_devices,
            const std::vector<AllocatorType>& alloc_types);
 
  void RunLoop(const std::vector<Index>& output_tensor_reg_indices = {});
 
  Device GetDevice(Index device_index) const;
  Allocator* GetAllocator(Index device_index) const;
 
  void InvokeGlobal(const VMFunction& func, const std::vector<ObjectRef>& args);
 
  void SetInput(std::string name, TVMArgs args, int offset);
 
  void SetOneInput(std::string name, const TVMArgValue& tag, const TVMArgValue& tensor);
 
  void SetOutputs(std::string name, TVMArgs args);
 
  void PrintInfoAndSetInputArgs(const VMFunction& func, const std::vector<ObjectRef>& args);
 
  void SetOutputTensorsToRegister(const std::string& func_name,
                                  const std::vector<ObjectRef>& outputs);
 
  virtual void OpStartHook(Instruction instr);
 
  virtual void OpStopHook();
 
 private:
  int64_t GetInputIndexFromVMFunction(const std::string& func_name,
                                      const std::string& input_name) const;
 
  int64_t GetInputIndexFromName(const std::vector<std::string>& params,
                                const std::string& input_name) const;
 
  const VMFunction& CheckAndGetVMFunction(const std::string& func_name) const;
 
  void CreateInputsOrCheckSize(const std::string& func_name, size_t size);
 
  void SetInputTensorWithIndex(std::vector<ObjectRef>& tensors,  // NOLINT(*)
                               const TVMArgValue& tensor, int index, Device dev);
 
  ObjectRef TensorFromTVMArgValueToObjectRef(const TVMArgValue& tensor) const;
 
  Index GetResultRegisterIndex() const;
 
  void CalculatePreResultOpIndex(Index res_index);
 
  std::vector<Index> GetOutputTensorRegIndices();
 
  void WriteAllocatedTensor(const Instruction& instr);
 
  void WriteAllocatedTensorFromOutside(const Instruction& instr);
 
  bool FindIndex(const std::vector<Index>& indices, Index val) const;
 
 protected:
  std::vector<PackedFunc> packed_funcs_;
  std::vector<VMFrame> frames_;
  Index func_index_;
  const Instruction* code_;
  Index pc_;
  ObjectRef return_register_;
  ObjectPtr<Executable> exec_;
  std::unordered_map<std::string, std::vector<ObjectRef>> inputs_;
  std::unordered_map<std::string, bool> set_outputs_enabled_;
  Index preresult_op_index_ = -1;
  std::unordered_map<std::string, std::vector<Index>> output_tensor_reg_indices_;
  std::unordered_map<std::string, std::vector<ObjectRef>> outputs_;
  std::vector<Device> devices_;
  std::vector<Allocator*> allocators_;
  std::vector<ObjectRef> const_pool_;
};
 
}  // namespace vm
}  // namespace runtime
}  // namespace tvm
 
#endif  // TVM_RUNTIME_VM_VM_H_