Summary: In order to support calling functions without inlining,
the interpreter will need to push another function 'frame' somewhere
when we invoke the call operator. This behavior is not easily expressible
in the current interpreter since ops can only push/pop to the stack.

Furthermore, we have accumulated several other warts because of the design:

* every Operation needs to return an int because a few ops branch
* aten::wait has to communicate with the core interpreter loop via exceptions.
* The way we encode Loop is a complicated desugaring because implementing
  it as an operator that can only push/pop the stack is hard.

To enable an easy implementation of the call instruction, and to fix the
above warts this patch changes the format of the interpreter instructions
to make it easier to encode arbitrary functionality.

Notes:
* Instructions are now 64-bit words with an opcode, and two arguments
* The var-arg register push/pop/move parts of the instructions are gone.
  Explicit instructions LOAD/STORE/MOVE now encode this logic.
* LOOP/WAIT are directly implemented as operators. We no longer desugar.
* We no longer need to lower Param and Return nodes, avoiding one
  preprocessing pass.
* Debug info is stored off to the side since now multiple Instructions
  may correspond to one node in the graph.

Future:
* This patch should not be merged on its own. A followup will add a
  pass that optimizes the register push/pop logic to cut down the
  number of raw instructions. The pretty printer already does something
  similar to inline instructions.
* The follow up patch will require performance testing before merging
  to make sure this does not regress interpreter overhead.

Test Plan: test_jit.py

Prepare interpreter for function calling
Summary: In order to support calling functions without inlining,
the interpreter will need to push another function 'frame' somewhere
when we invoke the call operator. This behavior is not easily expressible
in the current interpreter since ops can only push/pop to the stack.

Furthermore, we have accumulated several other warts because of the design:

* every Operation needs to return an int because a few ops branch
* aten::wait has to communicate with the core interpreter loop via exceptions.
* The way we encode Loop is a complicated desugaring because implementing
  it as an operator that can only push/pop the stack is hard.

To enable an easy implementation of the call instruction, and to fix the
above warts this patch changes the format of the interpreter instructions
to make it easier to encode arbitrary functionality.

Notes:
* Instructions are now 64-bit words with an opcode, and two arguments
* The var-arg register push/pop/move parts of the instructions are gone.
  Explicit instructions LOAD/STORE/MOVE now encode this logic.
* LOOP/WAIT are directly implemented as operators. We no longer desugar.
* We no longer need to lower Param and Return nodes, avoiding one
  preprocessing pass.
* Debug info is stored off to the side since now multiple Instructions
  may correspond to one node in the graph.

Future:
* This patch should not be merged on its own. A followup will add a
  pass that optimizes the register push/pop logic to cut down the
  number of raw instructions. The pretty printer already does something
  similar to inline instructions.
* The follow up patch will require performance testing before merging
  to make sure this does not regress interpreter overhead.

Test Plan: test_jit.py

gh-metadata: pytorch pytorch 21185 gh/zdevito/43/head

Prepare interpreter for function calling
Summary: In order to support calling functions without inlining,
the interpreter will need to push another function 'frame' somewhere
when we invoke the call operator. This behavior is not easily expressible
in the current interpreter since ops can only push/pop to the stack.

Furthermore, we have accumulated several other warts because of the design:

* every Operation needs to return an int because a few ops branch
* aten::wait has to communicate with the core interpreter loop via exceptions.
* The way we encode Loop is a complicated desugaring because implementing
  it as an operator that can only push/pop the stack is hard.

To enable an easy implementation of the call instruction, and to fix the
above warts this patch changes the format of the interpreter instructions
to make it easier to encode arbitrary functionality.

Notes:
* Instructions are now 64-bit words with an opcode, and two arguments
* The var-arg register push/pop/move parts of the instructions are gone.
  Explicit instructions LOAD/STORE/MOVE now encode this logic.
* LOOP/WAIT are directly implemented as operators. We no longer desugar.
* We no longer need to lower Param and Return nodes, avoiding one
  preprocessing pass.
* Debug info is stored off to the side since now multiple Instructions
  may correspond to one node in the graph.

Future:
* This patch should not be merged on its own. A followup will add a
  pass that optimizes the register push/pop logic to cut down the
  number of raw instructions. The pretty printer already does something
  similar to inline instructions.
* The follow up patch will require performance testing before merging
  to make sure this does not regress interpreter overhead.

Test Plan: test_jit.py

gh-metadata: pytorch pytorch 21185 gh/zdevito/43/head

Prepare interpreter for function calling
Summary: In order to support calling functions without inlining,
the interpreter will need to push another function 'frame' somewhere
when we invoke the call operator. This behavior is not easily expressible
in the current interpreter since ops can only push/pop to the stack.

Furthermore, we have accumulated several other warts because of the design:

* every Operation needs to return an int because a few ops branch
* aten::wait has to communicate with the core interpreter loop via exceptions.
* The way we encode Loop is a complicated desugaring because implementing
  it as an operator that can only push/pop the stack is hard.

To enable an easy implementation of the call instruction, and to fix the
above warts this patch changes the format of the interpreter instructions
to make it easier to encode arbitrary functionality.

Notes:
* Instructions are now 64-bit words with an opcode, and two arguments
* The var-arg register push/pop/move parts of the instructions are gone.
  Explicit instructions LOAD/STORE/MOVE now encode this logic.
* LOOP/WAIT are directly implemented as operators. We no longer desugar.
* We no longer need to lower Param and Return nodes, avoiding one
  preprocessing pass.
* Debug info is stored off to the side since now multiple Instructions
  may correspond to one node in the graph.

Future:
* This patch should not be merged on its own. A followup will add a
  pass that optimizes the register push/pop logic to cut down the
  number of raw instructions. The pretty printer already does something
  similar to inline instructions.
* The follow up patch will require performance testing before merging
  to make sure this does not regress interpreter overhead.

Test Plan: test_jit.py

gh-metadata: pytorch pytorch 21185 gh/zdevito/43/head

Prepare interpreter for function calling
Summary: In order to support calling functions without inlining,
the interpreter will need to push another function 'frame' somewhere
when we invoke the call operator. This behavior is not easily expressible
in the current interpreter since ops can only push/pop to the stack.

Furthermore, we have accumulated several other warts because of the design:

* every Operation needs to return an int because a few ops branch
* aten::wait has to communicate with the core interpreter loop via exceptions.
* The way we encode Loop is a complicated desugaring because implementing
  it as an operator that can only push/pop the stack is hard.

To enable an easy implementation of the call instruction, and to fix the
above warts this patch changes the format of the interpreter instructions
to make it easier to encode arbitrary functionality.

Notes:
* Instructions are now 64-bit words with an opcode, and two arguments
* The var-arg register push/pop/move parts of the instructions are gone.
  Explicit instructions LOAD/STORE/MOVE now encode this logic.
* LOOP/WAIT are directly implemented as operators. We no longer desugar.
* We no longer need to lower Param and Return nodes, avoiding one
  preprocessing pass.
* Debug info is stored off to the side since now multiple Instructions
  may correspond to one node in the graph.

Future:
* This patch should not be merged on its own. A followup will add a
  pass that optimizes the register push/pop logic to cut down the
  number of raw instructions. The pretty printer already does something
  similar to inline instructions.
* The follow up patch will require performance testing before merging
  to make sure this does not regress interpreter overhead.

Test Plan: test_jit.py

gh-metadata: pytorch pytorch 21185 gh/zdevito/43/head