git checkout 76ab26cc3eff1d7ba822d8db93723f5c9598eead

@torch.jit.script
def f(x):
    return x + x

class MyModule(torch.jit.ScriptModule):

    @torch.jit.script_method
    def f(self.x):
        return x * x

    @torch.jit.script_method
    def forward(self, x):
        return x + self.f(x)

def script(fn, optimize=True, _frames_up=0):
    if not _enabled:
        return fn
    rcb = createResolutionCallback(_frames_up + 1)
    ast = get_jit_ast(fn, is_method=False)
    graph = _jit_script_compile(ast, rcb)
    mod = ScriptModule()
    mod._create_method_from_graph('forward', graph)
    # TODO: refactor everything so we're not 1) creating a ScriptModule
    # 2) Throwing everything away except for the graph 3) Creating a new
    # ScriptModule and dumping that graph in 4) Re-populating the schema
    # because it was lost doing the previous
    mod.__getattr__('forward').forward_schema(ast, False)
    # Forward docstrings
    mod.__doc__ = fn.__doc__
    return mod

ScriptMethodStub = namedtuple('ScriptMethodStub', ('resolution_callback', 'def_', 'original_method'))


def script_method(fn):
    if not _enabled:
        return fn
    # ...
    rcb = createResolutionCallback(frames_up=2)
    ast = get_jit_ast(fn, is_method=True)
    return ScriptMethodStub(rcb, ast, fn)

class MyModule(torch.jit.ScriptModule):

    @torch.jit.script_method
    def f(self.x):
        return x * x

    @torch.jit.script_method
    def forward(self, x):
        return x + self.f(x)

class ScriptMeta(type(torch._C.ScriptModule)):

    def __init__(cls, name, bases, attrs):
        # delete all ScriptMethodStub

        @functools.wraps(original_init)
        def init_then_register(self, *args, **kwargs):
            # invoke the original __init__
            self._create_methods(defs, rcbs)

        cls.__init__ = init_then_register
        return super(ScriptMeta, cls).__init__(name, bases, attrs)


class ScriptModule(with_metaclass(ScriptMeta, torch._C.ScriptModule, Module)):
    # ......

    def __getattr__(self, attr):
        if self._has_method(attr):
            # ......
            return self._get_method(attr)
        # .....
        return Module.__getattr__(self, attr)

def get_jit_ast(fn, is_method):
    source = dedent(inspect.getsource(fn))
    py_ast = ast.parse(source)
    if len(py_ast.body) != 1 or not isinstance(py_ast.body[0], ast.FunctionDef):
        raise RuntimeError("expected a single top-level function")
    type_line = torch.jit.annotations.get_type_line(source)
    ctx = SourceContext(source, _uses_true_division(fn))
    return build_def(ctx, py_ast.body[0], type_line, is_method)

def build_def(ctx, py_def, type_line, is_method):
    returns = []
    ret_body = []
    body = py_def.body
    r = ctx.make_range(py_def.lineno, py_def.col_offset,
                       py_def.col_offset + len("def"))
    param_list = build_param_list(ctx, py_def.args)
    return_type = None
    if getattr(py_def, 'returns', None) is not None:
        return_type = build_expr(ctx, py_def.returns)
    decl = Decl(r, param_list, return_type)
    if type_line is not None:
        type_comment_decl = torch._C.parse_type_comment(type_line)
        decl = torch._C.merge_type_from_type_comment(decl, type_comment_decl, is_method)
    return Def(Ident(r, py_def.name),
               decl,
               build_stmts(ctx, body))

def build_stmts(ctx, stmts):
    stmts = [build_stmt(ctx, s) for s in stmts]
    return list(filter(None, stmts))

class StmtBuilder(Builder):
    # ...
    @staticmethod
    def build_Expr(ctx, stmt):
        value = stmt.value
        if value.__class__.__name__ == 'Str':
            # If a statement is a string literal expression,
            # then it is a docstring. Just ignore it.
            return None
        else:
            return ExprStmt([build_expr(ctx, value)])
    # ...
    @staticmethod
    def get_assign_lhs_expr(ctx, expr):
        # ...
    # ...
    @staticmethod
    def build_Assign(ctx, stmt):
        #...
    # ......

// torch.jit.ScriptModule is a subclass of this C++ object.
// Methods here are prefixed with _ since they should not be
// public.
py::class_<Module, std::shared_ptr<Module>>(m, "ScriptModule")
    .def(py::init<>())
    .def("save", &Module::save)
    .def("_set_optimized", &Module::set_optimized)
    .def(
        "_define",
        [](std::shared_ptr<Module> m,
            const std::string& script,
            ResolutionCallback rcb, bool has_self) {
          auto self = has_self ? std::make_shared<ModuleValue>(m) : nullptr;
          return defineMethodsInModule(*m, script, pythonResolver(rcb), self);
        })
    .def("_create_methods", [](std::shared_ptr<Module> m, const std::vector<Def>& defs, const std::vector<ResolutionCallback>& rcbs) {
      std::vector<Resolver> resolvers;
      for(auto & callback : rcbs) {
        resolvers.push_back(pythonResolver(callback));
      }
      defineMethodsInModule(
        *m,
        defs,
        resolvers,
        std::make_shared<ModuleValue>(m));
    })
    .def("_get_method",
    [](Module& self, const std::string& name) -> const Method& {
      return self.get_method(name);
    }, py::return_value_policy::reference_internal)
    //.def more ...

py::class_<Method>(m, "ScriptMethod", py::dynamic_attr())
    .def("graph", [&](Method& self) {
      return self.graph();
    })
    .def("__call__", invokeScriptMethodFromPython)
    //.def more ...

inline py::object invokeScriptMethodFromPython(
    script::Method& method,
    py::args args, py::kwargs kwargs) {
  auto stack = createStackForSchema(method.getSchema(), std::move(args), std::move(kwargs));
  {
    AutoNoGIL no_gil_guard;
    method.run(stack);
  }
  return createPyObjectForStack(std::move(stack));
}

void run(Stack & stack) {
  for(at::Tensor* tp : member_inputs) {
    stack.push_back(*tp);
  }
  get_executor().run(stack);
}

IValue operator()(std::vector<IValue> stack) {
  checkInputsAgainstSchema(stack);
  run(stack);
  if (stack.size() != 1) {
    return Tuple::create(std::move(stack));
  }
  return stack.front();
}

./torch/csrc/jit/script/init.cpp:  m.def("_jit_script_compile", [](const Def &def, ResolutionCallback rcb) {

m.def("_jit_script_compile", [](const Def &def, ResolutionCallback rcb) {
  return compileFunction(def, PythonResolver(rcb));
});

std::shared_ptr<Graph> compileFunction(Def def, const Resolver& resolver) {
  Module m;
  defineMethodsInModule(m, {def}, {resolver}, nullptr);
  return m.get_method(def.name().name()).graph();
}

void defineMethodsInModule(Module & m, const std::vector<Def>& definitions, const std::vector<Resolver>& resolvers, SugaredValuePtr self) {
  // ......
  for(Def def : definitions) {
    // ......
    auto creator = [def, &table, resolver, self](Method& method) {
      to_ir(def, table, resolver, self,  method);
    };
    Method& method = m.create_method(name, creator);
    // ......
  }
  // ......
}

// 'prim' symbols are synthetic operators that occur only in the IR
// and don't have corresponding implementations in ATen.

// 'onnx' symbols correspond to ONNX operators.  Their semantics
// are defined in https://github.com/onnx/onnx/blob/master/docs/Operators.md
// The particular version we are targeting is specified by '_onnx_opset_version'
// in torch.onnx.symbolic
//
// In general, most ONNX operators won't get an entry here, because they
// are handled from the Python end.  However, you may occasionally need
// to intern an ONNX symbol here so that you can conveniently write an
// optimization on ONNX operations.

// 'attr' symbols are attribute keys.  They are shared between both ONNX and ATen
// operators (you disambiguate their meaning by looking at the operator itself).
// In general, you only need to define attribute keys that are used by
// onnx or prim; ATen attributes are automatically generated in FORALL_ATTR_BASE_SYMBOLS.

// Note [Symbol allocation]
// ~~~~~~~~~~~~~~~~~~~~~~~~
//
//  1. Symbol namespace is split up into namespaces.
//
//  2. The intended access pattern for built-in symbols is onnx::MatMul
//  in the torch::jit namespace (this is a Symbol).
//


// Built-in constant definition strategy:
// - Enum is the most convenient way to generate a contiguous sequence
//   of numbers for an identifier.
// - However, an enum gives you a fresh type.  We want onnx::MatMul to
//   be type Symbol, not some random enum type!
// - Therefore, after using enums to generate the sequence of integers,
//   we then declare constexpr Symbols to get everything the actual Symbol
//   type we want.  Symbols must be constexpr to be valid to be "case"ed on.

using unique_t = uint32_t;

static const std::string domain_prefix = "org.PyTorch.";

// A Symbol is like an interned string, but with a little extra
// structure; it is namespaced via SymbolNamespace and the resulting
// intern pointers support efficient namespace testing.
struct TORCH_API Symbol {
// more code omitted ......

// Graph represents one "function" of computation.
// It uses a simple ownership model where the graph owns all the nodes inside it.
// All references inside the graph are raw pointers.
// Destroying the Graph will invalidate any pointers to nodes in the graph.
struct Graph;

// Node is the base class of the IR graph. It represents one computation
// and dependencies on a list of Values. The "prim-ops", so to speak.
struct Node;

// A Value represents an input or output to node that is either a
// Tensor or an opaque Handle object, as determined by type().
struct Value;

// ......

// A list of nodes, with inputs and outputs
struct Block;

// Each use is represented by this type, see Node::uses()
// 'user' is the consumer of the value, offset is the index into
// 'user's input this where the produces will be found.
struct Use {
  Use(Node * user, size_t offset)
  : user(user), offset(offset) {}
  Node * user;
  size_t offset;
};

// ......

// Scope is a node of a trie that represents the tree of nested scopes.
// Individual scopes are pushed and popped from Graph, which holds a
// pointer to the current scope. Each Node in Graph holds a pointer
// to the scope that was current when the node was created.
// The trie never needs to shrink, it only grows until it is disposed
// of when Graph is deallocated. Hence, pointers to scopes held by nodes
// will always be valid as long as Graph is alive.
struct Scope {

// The AST can contain nodes like `self`, `self.b` or `Python_fn` that
// are not first-class values in the graph representation, but instead
// will be desugared based on how they are used in the AST.

// SugaredValue is used to temporarily represent these values in a way
// that separates their behavior from the AST -> IR converter itself.
// This allows us to keep dependencies on Python minimal.

struct SugaredValue : public std::enable_shared_from_this<SugaredValue> {

void emitStatements(List<Stmt>::const_iterator begin, List<Stmt>::const_iterator end) {
  for (; begin != end; ++begin) {
    auto stmt = *begin;
    switch (stmt.kind()) {
      case TK_IF:
        emitIf(If(stmt));
        break;
      case TK_WHILE:
        emitWhile(While(stmt));
        break;
      case TK_FOR:
        emitFor(For(stmt));
        break;
      case TK_ASSIGN:
        emitAssignment(Assign(stmt));
        break;
      case TK_GLOBAL:
        for (auto ident : Global(stmt).names()) {
          const auto& name = Ident(ident).name();
          environment_stack->setVar(ident.range(), name, graph->addInput(name));
        }
        break;
      case TK_EXPR_STMT: {
        auto exprs = ExprStmt(stmt).exprs();
        for (const auto& expr : exprs) {
          emitSugaredExpr(expr, 0);
        }
      }
      break;
      case TK_RETURN:
        throw ErrorReport(stmt) << "return statements can appear only at the end "
                                << "of the function body";
        break;
    }
  }
}

// any expression that can produce a SugaredValue is handled here
// expressions that only return a single Value* are handled in emitSimpleExpr
std::shared_ptr<SugaredValue> emitSugaredExpr(Expr tree, size_t n_binders) {
  switch(tree.kind()) {
    case TK_VAR:
      return environment_stack->getSugaredVar(Var(tree).name());
    case '.': {
      auto select = Select(tree);
      auto sv = emitSugaredExpr(select.value(), 1);
      return sv->attr(select.range(), method, select.selector().name());
    }
    case TK_APPLY: {
      auto apply = Apply(tree);
      auto inputs = getNamedValues(apply.inputs(), true);
      auto attributes = fmap(apply.attributes(), [&](const Attribute& attr) {
        return NamedValue(attr.range(), attr.name().name(), emitExpr(attr.value()));
      });
      // the apply is directly an identifier 'foo'
      if(apply.callee().kind() == TK_VAR) {
        return emitApplyIdent(Var(apply.callee()).name(), inputs, attributes, n_binders);
      }
      return emitApplyExpr(apply.callee(), inputs, attributes, n_binders);
    } break;
    default:
      return std::make_shared<SimpleValue>(emitSimpleExpr(tree));
  }
}

if(NamedParameter* v = module->find_parameter(field)) {
  return std::make_shared<SimpleValue>(m.get_or_add_parameter(v->slot()));
}

Value * get_or_add_parameter(at::Tensor* slot) {
  auto it = member_input_index.find(slot);
  if(it != member_input_index.end()) {
    return graph()->inputs().at(it->second);
  }
  // add it as a new parameter
  member_inputs.push_back(slot);
  member_input_index[slot] = graph()->inputs().size();
  return graph()->addInput();
}

GraphExecutor& get_executor() {
  std::call_once(executor_init, [&]{
    executor = GraphExecutor(graph(), optimize);
  });
  return executor;
}

GraphExecutor::GraphExecutor(std::shared_ptr<Graph> graph, bool optimize)
: pImpl(new GraphExecutorImpl(std::move(graph), optimize)) {}

void GraphExecutor::run(Stack & inputs) {
  return pImpl->run(inputs);
}

GraphExecutorImpl(std::shared_ptr<Graph> graph, bool optimize)
  : graph(prepareGraph(graph))
  , optimize(optimize)
  , num_inputs(this->graph->inputs().size())
  , num_flat_inputs(countFlatInputs(graph))
  , num_outputs(this->graph->outputs().size()) {}

// entry point where execution begins
void run(Stack & stack) {
  AT_CHECK(stack.size() >= num_inputs, "expected ", num_inputs, " inputs, but got only ", stack.size());

  if(tracer::isTracing()) {
    return runTraced(stack);
  }

  auto & execution_plan = optimize ? getOrCompile(stack) : getOrCompileFallback();
  return execution_plan.run(stack);
}

const ExecutionPlan & getOrCompileFallback() {
  std::lock_guard<std::mutex> lock(compile_mutex);
  if(!fallback) {
    auto graph_ = graph->copy();
    runRequiredPasses(graph_);
    fallback = ExecutionPlan(graph_);
  }
  return fallback;
}

const ExecutionPlan & getOrCompile(const Stack& stack) {
  // outside lock guard, to minimize the time holding the lock on the fast path
  // ArgumentSpec even computes its hashCode here.
  ArgumentSpec spec(autograd::GradMode::is_enabled(), last(stack, num_inputs), num_flat_inputs);
  {
    std::lock_guard<std::mutex> lock(compile_mutex);
    auto it = plan_cache.find(spec);
    if (it != plan_cache.end())
      return it->second;
    auto plan = compileSpec(spec);
    auto r = plan_cache.emplace(std::move(spec), std::move(plan));
    return r.first->second;
  }
}

ExecutionPlan compileSpec(const ArgumentSpec & spec) {
  auto opt_graph = graph->copy();
  setInputTypes(*opt_graph, spec);

  // Phase 1. Specialize to input definedness (this is very important for
  //          gradient graphs), and run required passes to bring the graph
  //          to an executable form.
  runRequiredPasses(opt_graph);

  // Phase 2. Propagate detailed information about the spec through the
  //          graph (enabled more specializations in later passes).
  //          Shape propagation sometimes depends on certain arguments being
  //          constants, and constant propagation doesn't need shape information
  //          anyway, so it's better to run it first.
  ConstantPropagation(opt_graph);
  PropagateInputShapes(*opt_graph);
  PropagateRequiresGrad(opt_graph);

  // Phase 3. Run differentiable optimizations (i.e. simple graph rewrites that
  //          we can still execute using autograd).
  runOptimization(opt_graph, spec);

  // Phase 4. If this graph will be differentiated, we need to slice out the
  //          symbolically differentiable subgraphs for further optimizations.
  // Phase 5. Apply non-differentiable optimizations to the graphs we've found
  //          (or the whole grpah if we know we won't need its derivative).
  if (needsGradient(opt_graph)) {
    auto diff_nodes = CreateAutodiffSubgraphs(*opt_graph);
    for (Node * dnode : diff_nodes) {
      auto diff_graph = std::move(dnode->g(attr::Subgraph));
      Gradient gradient = differentiate(diff_graph);
      runNondiffOptimization(gradient.f);
      packGradient(gradient, dnode);
    }
    InlineAutodiffSubgraphs(opt_graph);
  } else {
    runNondiffOptimization(opt_graph);
  }
  // Make sure there are no leftovers from any passes.
  EliminateDeadCode(opt_graph);
  return ExecutionPlan(opt_graph);
}

void runOptimization(std::shared_ptr<Graph>& graph, const ArgumentSpec& spec) {
  EliminateDeadCode(graph);
  EliminateCommonSubexpression(graph);
  UnrollLoops(graph);
  PeepholeOptimize(graph);
  CheckInplace(graph);
  BatchMM(graph);
}

void runNondiffOptimization(std::shared_ptr<Graph>& graph) {
  FuseGraph(graph);
}

// ......

void runRequiredPasses(const std::shared_ptr<Graph>& g)  {
  specializeUndef(*g);
  LowerGradOf(*g);
  // implicit inserted expand nodes are not necessarily always valid
  // when used inside script methods that might have unstable shapes
  // we remove the implicitly created ones, and have shape analysis
  // add valid expand nodes when the shapes are stable
  RemoveExpands(g);
  CanonicalizeOps(g);
  EliminateDeadCode(g);
}

struct ExecutionPlan {
  ExecutionPlan() = default;
  ExecutionPlan(std::shared_ptr<Graph> graph)
    : code(graph)
    , graph(std::move(graph)) {}

  void run(Stack& stack) const {
    return InterpreterState(code).runOneStage(stack);
  }

  operator bool() const {
    return static_cast<bool>(graph);
  }

  ExecutionPlanState getDebugState() {
    ExecutionPlanState state;
    state.code = &code;
    state.graph = graph.get();
    return state;
  }

  Code code;
  std::shared_ptr<Graph> graph;
};

Code::Code(std::shared_ptr<Graph>& graph)
    : pImpl(new CodeImpl(graph)) {}
Code::~Code() = default;

const std::vector<GraphExecutor*>& Code::grad_executors() {
  return pImpl->grad_executors();
}

InterpreterState::InterpreterState(const Code & code)
  : pImpl(new InterpreterStateImpl(code)) {}
InterpreterState::~InterpreterState() = default;

void InterpreterState::runOneStage(Stack & stack) {
  return pImpl->runOneStage(stack);
}

PreprocessGraph preprocess;
std::vector<Instruction> instructions;

CodeImpl(std::shared_ptr<Graph>& graph_)
    : preprocess(*graph_) {
  graph = preprocess.graph;
  // std::cout << "into code graph:\n" << *graph << "\n";
  insertNodesFromBlock(graph->block());
}

// Before we translate to intepreter instructions, we do
// some preprocessing of the graph to turn it into a form that is closer
// to what the instructions will look like.
// In particular we:
// * (TODO) desugar Loop trip counts into c = 0, c += 1 instructions in the loop
// * flatten stages so that each stage starts with a load from the stack
//   and ends with a store to the stack
// *. computes move_flags (see Outputs), and inserts
// *  Drop nodes are inserted for any node that is unused to create a dummy use
//    that will cause the interpreter to free the node.
//    A drop node is just a node with no outputs that just pops its inputs off the stack,
//    to ensure the interpreter release references to nodes that are never used.
//    Drop nodes are also inserted when the last use of a node is in some conditionally
//    run control flow (e.g. one side of an If) and the interpreter must free
//    the node only after the control flow has reconverged
// Outputs are:
// * graph - the post processed copy of g
// * move_flags[n] - a list of booleans, one for each input,
//   indicating whether this is the last use of the value. The interpreter
//   should generate a move rather than a copy in this case.
// * stage_input_types: the type annotations on the inputs to each stage
//   these can be removed once the the backward tracer is no longer used

struct PreprocessGraph {
  PreprocessGraph(Graph & g)
  : graph(g.copy()) {
    desugarTripCounts(graph->block());
    stage_input_types = flattenStages(*graph);
    dropUnused(graph->block());
    // fill in move_flags by scanning blocks;
    move_flags = findLastUses(*graph);
    //TODO: desugar Loop trip counts, for now we drop trip counts
  }
  // Outputs of the preprocessing:
  std::shared_ptr<Graph> graph;
  // for each input, should we move rather than copy the inputs
  std::unordered_map<Node*, std::vector<uint8_t>> move_flags;
  std::vector<std::vector<TypePtr>> stage_input_types;

};

void insertNodesFromBlock(Block* block) {
  for(auto node : block->nodes()) {
    const auto & source_location = node->getSourceLocation();
    switch(node->kind()) {
      case prim::If: {
        // x = if c:
        //   <then_block>
        //   -> (vt)
        // else:
        //    <else_block>
        //   -> (vf)

        // turns into:
        //   JumpNZ c, then
        //   <else_block>
        //   x = vf
        //   Jump end
        // then:
        //   <then_block>
        //   x = vt
        // end:

        // prim::Placeholder instructions are replaced with branch instructions
        // when the branch target locations are known
        auto cond_branch = insertInstruction(prim::Placeholder, source_location, node->inputs(), moveFlags(node), {});
        auto then_block = node->blocks()[0];
        auto else_block = node->blocks()[1];
        insertNodesFromBlock(else_block);
        insertAssign(source_location,else_block->outputs(), moveFlags(else_block), node->outputs());
        auto jump = insertInstruction(prim::Placeholder, source_location, {}, {}, {});
        auto then_block_start = instructions.size();
        insertNodesFromBlock(then_block);
        insertAssign(source_location, then_block->outputs(), moveFlags(then_block), node->outputs());
        createJump(jump, instructions.size());
        createJumpNZ(cond_branch, then_block_start);
      } break;
      case prim::Loop: {
        // omitted ......
      } break;
      default: {
        insertInstruction(node);
      } break;
    }
    // each stage ends with a load instruction
    // we record where these instructions occur, and use them to
    // exit the interpreter
    if(node->kind() == prim::Load) {
      stage_end.push_back(instructions.size());
    }
  }
}

InterpreterStateImpl(const Code & code)
: function(code.pImpl),
  int_data(function->int_data.data()),
  bool_data(function->bool_data),
  registers(function->register_size) {
}
void runOneStage(Stack & stack) {
  // std::cout << "running stage: " << current_stage << " of " << function->stage_end.size() << "\n";
  // std::cout << *function->graph << "\n";
  // function->dump(std::cout);
  size_t pc = current_pc;
  size_t last = function->stage_end[current_stage];
  auto & instructions = function->instructions;
  while(pc < last) {
      // std::cout << "executing " << pc << ": ";
      // function->dumpInstruction(std::cout, pc);
      // std::cout << "\n";
      try {
        auto & inst = instructions[pc];
        loadTensorsFromRegisters(inst.inputs, stack);
        size_t new_pc = pc + 1 + inst.callback(stack);
        for(int i = inst.outputs.size - 1; i >= 0; i--) {
          int reg = get(inst.outputs,i);
          registers[reg] = pop(stack);
          // std::cout << "pop reg[" << reg << "];\n" << registers[reg].pImpl << "\n";
        }
        pc = new_pc;
      } catch(std::exception & e) {
        if(!instructions[pc].debug_location)
          throw; // rethrow original exception
        // throw a new exception with enhanced debugging information
        instructions[pc].debug_location->wrapAndRethrowException(e, "operation failed in interpreter");
      }
  }
  current_pc = pc;
  current_stage++;
}

// jump when input is not 0
void createJumpNZ(int from_inst, int to_inst) {
  auto & inst = instructions[from_inst];
  JIT_ASSERT(inst.debug_name == prim::Placeholder);
  auto offset = relativeJump(from_inst, to_inst);
  inst.callback = [offset](Stack & stack) {
    auto t = pop(stack).toInt();
    return (t != 0) ? offset : 0;
  };
  inst.debug_name = prim::JumpNZ;
}

size_t insertInstruction(Node * n) {
  auto inst = insertInstruction(n->kind(), n->getSourceLocation(), n->inputs(), moveFlags(n) , n->outputs());
  instructions[inst].callback = getOperation(n);
  return inst;
}

torch/csrc/jit/generated/register_aten_ops.cpp:RegisterOperators reg({
torch/csrc/jit/fusers/common/fusion_handle_impl.cpp:RegisterOperators reg_fused_operators({
torch/csrc/jit/custom_operator.h:/// so in the global scope when a `RegisterOperators` object is assigned to a
torch/csrc/jit/custom_operator.h:struct TORCH_API RegisterOperators {
torch/csrc/jit/custom_operator.h:  RegisterOperators() = default;
torch/csrc/jit/custom_operator.h:  RegisterOperators(std::vector<Operator> operators) {
torch/csrc/jit/custom_operator.h:  RegisterOperators(const std::string& name, Implementation&& implementation) {
torch/csrc/jit/custom_operator.h:  RegisterOperators& op(
torch/csrc/jit/Python_interpreter.cpp:RegisterOperators reg({
torch/csrc/jit/register_special_ops.cpp:RegisterOperators reg({
torch/csrc/jit/graph_executor.cpp:RegisterOperators reg_graph_executor_ops({
torch/csrc/jit/constants.cpp:RegisterOperators reg({
torch/csrc/jit/register_prim_ops.cpp:RegisterOperators reg({
torch/csrc/jit/register_prim_ops.cpp:RegisterOperators reg2({
torch/csrc/jit/test_jit.cpp:    RegisterOperators reg({createOperator(
torch/csrc/jit/test_jit.cpp:    RegisterOperators reg({createOperator(
torch/csrc/jit/test_jit.cpp:    RegisterOperators reg({createOperator(
torch/csrc/jit/test_jit.cpp:    RegisterOperators reg(