mirror of
https://github.com/pytorch/pytorch.git
synced 2025-10-20 21:14:14 +08:00
64caee1356
Summary: Pull Request resolved: https://github.com/pytorch/pytorch/pull/66131 Turns out that a model with 72k instructions causes about 0.5MiB of additional memory overhead (if there's an 8 byte memory overhead per instruction). This is not necessary if we're building w/o eager symbolication support. This change eliminates the 8 byte `debug_handle` if the build is w/o eager symbolication support. ghstack-source-id: 140045478 (Note: this ignores all push blocking failures!) Test Plan: ``` buck build -c "pt.enable_eager_symbolication"=1 //xplat/caffe2/fb/lite_predictor:lite_predictor buck build //xplat/caffe2/fb/lite_predictor:lite_predictor ``` Reviewed By: kimishpatel Differential Revision: D31387784 fbshipit-source-id: af56787ad833b990a46b79ab021e512edaa22143
46 lines
1.5 KiB
C++
46 lines
1.5 KiB
C++
#pragma once
|
|
#include <ATen/core/ivalue.h>
|
|
#include <ATen/core/operator_name.h>
|
|
#include <torch/csrc/jit/runtime/instruction.h>
|
|
#include <vector>
|
|
|
|
namespace torch {
|
|
namespace jit {
|
|
namespace mobile {
|
|
using Stack = std::vector<c10::IValue>;
|
|
using DebugHandle = int64_t;
|
|
// NOLINTNEXTLINE(cppcoreguidelines-pro-type-member-init)
|
|
struct Code {
|
|
// TODO: Combine instructions and debug handles vector
|
|
// into std::vector<<std::pair<Instruction, DebugHandle>>
|
|
std::vector<Instruction> instructions_;
|
|
std::vector<DebugHandle> debug_handles_;
|
|
std::vector<c10::OperatorName> op_names_;
|
|
std::vector<std::function<void(Stack&)>> operators_;
|
|
std::vector<c10::IValue> constants_;
|
|
std::vector<c10::TypePtr> types_;
|
|
size_t register_size_; // Aggregated output size.
|
|
};
|
|
|
|
struct InterpreterState {
|
|
TORCH_API explicit InterpreterState(std::shared_ptr<Code> code);
|
|
TORCH_API bool run(Stack& stack);
|
|
|
|
private:
|
|
std::shared_ptr<Code> code_;
|
|
c10::IValue& reg(size_t reg);
|
|
std::vector<c10::IValue> registers_;
|
|
};
|
|
|
|
// Interpreter executes instruction in a loop one by one
|
|
// from a list of instructions. PC is a program counter pointer
|
|
// pointing to the current instruction being executed.
|
|
// This function returns the current PC.
|
|
// Note that this is set only when exception occurs.
|
|
// since this is a thread local variable and setting it for
|
|
// every instruction will add overhead of thread local variable access.
|
|
int64_t getInterpretersExceptionPC();
|
|
} // namespace mobile
|
|
} // namespace jit
|
|
} // namespace torch
|