remove internal names

Summary: jarvis -> meta

Differential Revision: D66243117

Author: Zonglin Peng

backends/cadence/aot/pass_utils.py

@@ -50,7 +50,7 @@ def get_all_available_cadence_passes() -> Set[ExportPass]:
     return set(ALL_CADENCE_PASSES.keys())
 
 
-# Create a new filter to filter out relevant passes from all Jarvis passes.
+# Create a new filter to filter out relevant passes from all passes.
 def create_cadence_pass_filter(
     opt_level: int, debug: bool = False
 ) -> Callable[[ExportPass], bool]:

backends/cadence/aot/passes.py

@@ -40,7 +40,7 @@
 @register_cadence_pass(CadencePassAttribute(opt_level=0))
 class InitializePipeline(ExportPass):
     """
-    Initialize the Jarvis pipeline. This should invariably be the first pass to
+    Initialize the pass pipeline. This should invariably be the first pass to
     run.
     """
 
@@ -54,7 +54,7 @@ def call(self, graph_module: torch.fx.GraphModule) -> PassResult:
 @register_cadence_pass(CadencePassAttribute(opt_level=0))
 class FinalizePipeline(ExportPass):
     """
-    The final cleanup pass after running the Jarvis pipeline.
+    The final cleanup pass after running the pass pipeline.
     """
 
     def call(self, graph_module: torch.fx.GraphModule) -> PassResult:

backends/cadence/aot/utils.py

@@ -124,29 +124,29 @@ def get_ops_count(graph_module: torch.fx.GraphModule) -> Dict[str, int]:
 
 
 # Print the ops and how many times they occur multiple graph modules:
-# from export, from to_edge, and from Jarvis. Print the available
+# from export, from to_edge, and from final. Print the available
 # implementations for each op, and error out if the op is not supported.
 def print_ops_info(
     to_edge_gm: torch.fx.GraphModule,
-    jarvis_gm: torch.fx.GraphModule,
+    final_gm: torch.fx.GraphModule,
 ) -> None:
     to_edge_ops_count = get_ops_count(to_edge_gm)
-    jarvis_ops_count = get_ops_count(jarvis_gm)
+    final_ops_count = get_ops_count(final_gm)
 
     removed_ops = []
     # Get the counts of the ops that are removed from the final graph
     for k in to_edge_ops_count:
-        if k not in jarvis_ops_count:
+        if k not in final_ops_count:
             removed_ops.append(k)
 
     # Create a dict of ops and their counts to pass to tabulate
     ops_count = [
         [
             op,
-            jarvis_ops_count[op],
+            final_ops_count[op],
             to_edge_ops_count[op] if op in to_edge_ops_count else 0,
         ]
-        for op in jarvis_ops_count
+        for op in final_ops_count
     ]
     sorted_ops_count = sorted(ops_count, key=lambda x: x[1], reverse=True)
 
@@ -166,7 +166,7 @@ def print_ops_info(
             sorted_ops_count,
             headers=[
                 "Final Operators                                    ",  # one character longer than the longest op name
-                "Jarvis (Final) Graph",
+                "Final Graph",
                 "To_edge Graph",
                 "Export Graph",
             ],
@@ -181,7 +181,7 @@ def print_ops_info(
                 removed_ops_count,
                 headers=[
                     "Deleted Operators                                  ",  # one character longer than the longest op name
-                    "Jarvis (Final) Graph",
+                    "Final Graph",
                     "To_edge Graph",
                     "Export Graph",
                 ],

backends/cadence/runtime/runtime.py

@@ -28,7 +28,7 @@
 from torch.utils._pytree import TreeSpec
 
 
-class JarvisETDump:
+class CadenceETDump:
     def __init__(self, output_dir: str) -> None:
         self.tensor_dump_dir: str = os.path.join(output_dir, "tensors")
         self.etdump_path: str = os.path.join(output_dir, "etdump.etdp")
@@ -64,28 +64,26 @@ def get_outputs(self, log_to_stdout: bool = False) -> Tuple[torch.Tensor]:
             for event_block in self.et_inspector.event_blocks
             if event_block.name == "Execute"
         ]
-        logging.debug(f"[Jarvis][ETdump] output: {output}")
+        logging.debug(f"[ETdump] output: {output}")
         return output[0]
 
     def print_event_block(self) -> None:
-        logging.debug("[Jarvis][ETdump] data tabular:")
+        logging.debug("[ETdump] data tabular:")
         if logging.getLogger().level <= logging.DEBUG:
             self.et_inspector.print_data_tabular()
 
     def print_event_data(self) -> None:
-        logging.debug("[Jarvis][ETdump] event data ")
+        logging.debug("[ETdump] event data ")
         for event_block in self.et_inspector.event_blocks:
             for event in event_block.events:
                 logging.debug(event)
 
     def dump_intermediate_tensors(self) -> None:
         if self.etrecord_path is None:
-            logging.info("[Jarvis][ETdump] Intermediate tensors not available")
+            logging.info("[ETdump] Intermediate tensors not available")
             return
 
-        logging.info(
-            f"[Jarvis][ETdump] Dumping intermediate tensors to {self.tensor_dump_dir}"
-        )
+        logging.info(f"[ETdump] Dumping intermediate tensors to {self.tensor_dump_dir}")
         os.makedirs(self.tensor_dump_dir, exist_ok=True)
         exec_blocks = [
             eb for eb in self.et_inspector.event_blocks if eb.name == "Execute"
@@ -153,13 +151,13 @@ def run(
     if working_dir is None:
         working_dir = tempfile.mkdtemp(dir="/tmp")
 
-    # initialize Jarvis e2e Executor with executorch_cfg.
+    # initialize e2e Executor with executorch_cfg.
     executor = Executor(working_dir)
 
     # run Executor
     executor()
 
-    etdump = JarvisETDump(output_dir=working_dir)
+    etdump = CadenceETDump(output_dir=working_dir)
     outputs = etdump.get_outputs()
 
     assert isinstance(out_spec, TreeSpec)