1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
|
#include <torch/csrc/jit/ir/scope.h>
#include <ATen/core/function.h>
namespace torch {
namespace jit {
ScopePtr Scope::intrusive_from_this() {
c10::raw::intrusive_ptr::incref(this); // we are creating a new pointer
// from a raw `this` pointer
// so we need to bump the refcount
// to account for this ownership
return c10::intrusive_ptr<Scope>::reclaim(this);
}
Scope::Scope() {
name_ = Symbol::scope("");
}
Scope::Scope(ScopePtr parent, Symbol name) {
name_ = name;
parent_ = std::move(parent);
}
ScopePtr Scope::push(Symbol name) {
return c10::make_intrusive<Scope>(intrusive_from_this(), name);
}
ScopePtr Scope::parent() {
if (!parent_) {
throw std::runtime_error("Cannot get parent from Scope with no parent");
}
return parent_;
}
bool Scope::isRoot() const {
return !parent_;
}
bool Scope::isBlank() const {
static const Symbol blank = Symbol::scope("");
return isRoot() && name() == blank;
}
ScopePtr Scope::getRoot() {
ScopePtr current = intrusive_from_this();
while (current->parent_) {
current = current->parent_;
}
return current;
}
size_t Scope::getDepth() {
size_t d = 1;
ScopePtr current = intrusive_from_this();
while (current->parent_) {
current = current->parent_;
d += 1;
}
return d;
}
Symbol Scope::name() const {
return name_;
}
std::string Scope::namesFromRoot(const std::string& separator) const {
// TODO: I think the answer is we shouldn't have used Symbol here
std::string out = this->name_.toUnqualString();
if (this->isRoot()) {
return out;
}
ScopePtr parent = this->parent_;
while (!parent->isRoot()) {
// NOLINTNEXTLINE(performance-inefficient-string-concatenation)
out = std::string(parent->name_.toUnqualString()) + separator + out;
parent = parent->parent_;
}
return out;
}
InlinedCallStackPtr InlinedCallStack::intrusive_from_this() {
c10::raw::intrusive_ptr::incref(this); // we are creating a new pointer
// from a raw `this` pointer
// so we need to bump the refcount
// to account for this ownership
return c10::intrusive_ptr<InlinedCallStack>::reclaim(this);
}
InlinedCallStack::InlinedCallStack(Function* fn, SourceRange source_range)
: fn_(fn), source_range_(std::move(source_range)) {}
InlinedCallStack::InlinedCallStack(
InlinedCallStackPtr callee,
Function* fn,
SourceRange source_range)
: callee_(std::move(callee)),
fn_(fn),
source_range_(std::move(source_range)) {}
c10::optional<InlinedCallStackPtr> InlinedCallStack::callee() const {
return callee_;
}
std::vector<InlinedCallStackEntry> InlinedCallStack::vec() {
std::vector<InlinedCallStackEntry> r;
c10::optional<InlinedCallStackPtr> current = intrusive_from_this();
while (current) {
r.emplace_back(std::make_pair((*current)->fn_, (*current)->source_range_));
current = (*current)->callee_;
}
return r;
}
} // namespace jit
} // namespace torch
|
