[shoumikhin]

Depends on pytorch/executorch#25099; lands after it. compile_and_save uses the consume argument that change adds to ExecuTorch's save and write_tensor_data_to_file, so the ExecuTorch pin bump to the first nightly that has it (which also raises the minimum ExecuTorch version) will be added to this PR once #25099 merges. Only the move passes consume; every other save calls ExecuTorch exactly as before.

What is wrong today

compile_and_save writes each engine to a temporary file as soon as it is built. The ExecuTorch save then copies that file into the .pte (or the .ptd), and the file is deleted only when the call returns. So while the program is written, every engine is on disk twice. For a model whose engine is tens of gigabytes, the export needs that much more free disk, and it can fail on a device that has room for the result.

What this change does

• The backend hands each of these engine files to ExecuTorch as data that owns the file (FileBackedData(path, cleanup=True)). The file is deleted after the save anyway.
• Inside compile_and_save, the program is written with ExecuTorch's save(file_path, consume=True) and the .ptd with write_tensor_data_to_file(..., consume=True). ExecuTorch then moves each engine into the program, so each engine is on disk once. ExecuTorch does this only when the temporary directory, where the engine files are, is on the same file system as the program. Its save takes only a .pte path, so a program saved under another name is copied as before.
• With generate_etrecord, the save copies the engines instead. The ETRecord is written after the program and reads the engines, so a move would leave it nothing to read. The program is still written first, as before, so it is kept when the ETRecord can't be written.
• The docs now say that compile_and_save can write an ETRecord, unlike a plain save of a program with TensorRT engines.

Tests

• tests/py/dynamo/executorch/test_api.py, on CPU with the lowering stubbed:
  • test_compile_and_save_moves_the_engines: in the offload block that compile_and_save saves in, the program and the .ptd are written with consume=True.
  • test_compile_and_save_copies_the_engines_into_a_path_without_pte: the same with a .bin path writes both without consume.
  • test_compile_and_save_keeps_the_program_when_the_etrecord_fails: in the same block with an ETRecord, the program and the .ptd are written first, without consume, and the .pte is kept when the ETRecord save fails.
  • test_save_executorch_keeps_the_program_when_the_etrecord_fails: the same for a plain save.
  • test_save_executorch_does_not_consume: a plain save writes without consume. The stubbed ExecuTorch rejects any consume other than True, as releases without it do.
• tests/py/dynamo/executorch/test_compile_and_save.py, on an A100, with ExecuTorch from #25099:
  • the streaming test also checks that each engine reaches ExecuTorch as data that owns its file;
  • test_engines_move_into_the_program_without_a_second_copy: ExecuTorch copied no engine, and both are in the .pte;
  • test_an_etrecord_makes_the_save_copy_the_engines: with an ETRecord, the engine files keep their bytes, and both the .pte and the ETRecord are written.