[Courgette] Reduce AssemblyProgram to reduce Courgette-apply RAM floor and disk churn.

courgette/courgette_tool.cc

Index: courgette/courgette_tool.cc
diff --git a/courgette/courgette_tool.cc b/courgette/courgette_tool.cc
index 46bd578e1d38b4db610295686a3d97dcb870ef40..7abcf6ea1b1933b76ab24cfc72b5fcb09e6e5a51 100644
--- a/courgette/courgette_tool.cc
+++ b/courgette/courgette_tool.cc
@@ -155,8 +155,10 @@ void Disassemble(const base::FilePath& input_file,
                  const base::FilePath& output_file) {
   CourgetteFlow flow;
   BufferedFileReader input_buffer(input_file, flow.name(flow.ONLY));
-  flow.ReadAssemblyProgramFromBuffer(flow.ONLY, input_buffer, false);
-  flow.CreateEncodedProgramFromAssemblyProgram(flow.ONLY);
+  flow.ReadDisassemblerFromBuffer(flow.ONLY, input_buffer);
+  flow.CreateAssemblyProgramFromDisassembler(flow.ONLY, false);
+  flow.CreateEncodedProgramFromDisassemblerAndAssemblyProgram(flow.ONLY);
+  flow.DestroyDisassembler(flow.ONLY);
   flow.DestroyAssemblyProgram(flow.ONLY);
   flow.WriteSinkStreamSetFromEncodedProgram(flow.ONLY);
   flow.DestroyEncodedProgram(flow.ONLY);
@@ -171,16 +173,27 @@ void Disassemble(const base::FilePath& input_file,
 void DisassembleAndAdjust(const base::FilePath& old_file,
                           const base::FilePath& new_file,
                           const base::FilePath& output_file) {
+  // Flow graph and process sequence (DA = Disassembler, AP = AssemblyProgram,
+  // EP = EncodedProgram, Adj = Adjusted):
+  //   [1 Old DA] --> [2 Old AP]    [4 New AP] <-- [3 New DA]
+  //                      |             |              |
+  //                      |             v (move)       v
+  //                      +---> [5 Adj New AP] --> [6 New EP]
+  //                                               (7 Write)
   CourgetteFlow flow;
   BufferedFileReader old_buffer(old_file, flow.name(flow.OLD));
   BufferedFileReader new_buffer(new_file, flow.name(flow.NEW));
-  flow.ReadAssemblyProgramFromBuffer(flow.OLD, old_buffer, true);
-  flow.ReadAssemblyProgramFromBuffer(flow.NEW, new_buffer, true);
-  flow.AdjustNewAssemblyProgramToMatchOld();
+  flow.ReadDisassemblerFromBuffer(flow.OLD, old_buffer);       // 1
+  flow.CreateAssemblyProgramFromDisassembler(flow.OLD, true);  // 2
+  flow.DestroyDisassembler(flow.OLD);

[Will Harris, 2017/05/05 22:26:22]

can these create and destroys be managed with smart pointer lifetimes instead of
explicit calls?

[huangs, 2017/05/14 04:27:55]

Yes, then we won't need the flow.Destroy*() functions. To implement this we can
add reference counting inside CourgetteFlow::Data, update them on creation & use
(with error handing), and deallocate on the 1->0 transition. I judge this to be
over-complication though, but can do it on a follow-up if you insist?

+  flow.ReadDisassemblerFromBuffer(flow.NEW, new_buffer);       // 3
+  flow.CreateAssemblyProgramFromDisassembler(flow.NEW, true);  // 4
+  flow.AdjustNewAssemblyProgramToMatchOld();                   // 5
   flow.DestroyAssemblyProgram(flow.OLD);
-  flow.CreateEncodedProgramFromAssemblyProgram(flow.NEW);
+  flow.CreateEncodedProgramFromDisassemblerAndAssemblyProgram(flow.NEW);  // 6
   flow.DestroyAssemblyProgram(flow.NEW);
-  flow.WriteSinkStreamSetFromEncodedProgram(flow.NEW);
+  flow.DestroyDisassembler(flow.NEW);
+  flow.WriteSinkStreamSetFromEncodedProgram(flow.NEW);  // 7
   flow.DestroyEncodedProgram(flow.NEW);
   courgette::SinkStream sink;
   flow.WriteSinkStreamFromSinkStreamSet(flow.NEW, &sink);
@@ -199,20 +212,33 @@ void DisassembleAdjustDiff(const base::FilePath& old_file,
                            const base::FilePath& new_file,
                            const base::FilePath& output_file_root,
                            bool adjust) {
+  // Same as PatchGeneratorX86_32::Transform(), except Adjust is optional, and
+  // |flow|'s internal SinkStreamSet get used.
+  // Flow graph and process sequence (DA = Disassembler, AP = AssemblyProgram,
+  // EP = EncodedProgram, Adj = Adjusted):
+  //   [1 Old DA] --> [2 Old AP]   [6 New AP] <-- [5 New DA]
+  //       |            |   |          |              |
+  //       v            |   |          v (move)       v
+  //   [3 Old EP] <-----+   +->[7 Adj New AP] --> [8 New EP]
+  //   (4 Write)                                  (9 Write)
   CourgetteFlow flow;
   BufferedFileReader old_buffer(old_file, flow.name(flow.OLD));
   BufferedFileReader new_buffer(new_file, flow.name(flow.NEW));
-  flow.ReadAssemblyProgramFromBuffer(flow.OLD, old_buffer, adjust);
-  flow.ReadAssemblyProgramFromBuffer(flow.NEW, new_buffer, adjust);
+  flow.ReadDisassemblerFromBuffer(flow.OLD, old_buffer);                  // 1
+  flow.CreateAssemblyProgramFromDisassembler(flow.OLD, adjust);           // 2
+  flow.CreateEncodedProgramFromDisassemblerAndAssemblyProgram(flow.OLD);  // 3
+  flow.DestroyDisassembler(flow.OLD);
+  flow.WriteSinkStreamSetFromEncodedProgram(flow.OLD);  // 4
+  flow.DestroyEncodedProgram(flow.OLD);
+  flow.ReadDisassemblerFromBuffer(flow.NEW, new_buffer);         // 5
+  flow.CreateAssemblyProgramFromDisassembler(flow.NEW, adjust);  // 6
   if (adjust)
-    flow.AdjustNewAssemblyProgramToMatchOld();
-  flow.CreateEncodedProgramFromAssemblyProgram(flow.OLD);
+    flow.AdjustNewAssemblyProgramToMatchOld();  // 7, optional
   flow.DestroyAssemblyProgram(flow.OLD);
-  flow.CreateEncodedProgramFromAssemblyProgram(flow.NEW);
+  flow.CreateEncodedProgramFromDisassemblerAndAssemblyProgram(flow.NEW);  // 8
   flow.DestroyAssemblyProgram(flow.NEW);
-  flow.WriteSinkStreamSetFromEncodedProgram(flow.OLD);
-  flow.DestroyEncodedProgram(flow.OLD);
-  flow.WriteSinkStreamSetFromEncodedProgram(flow.NEW);
+  flow.DestroyDisassembler(flow.NEW);
+  flow.WriteSinkStreamSetFromEncodedProgram(flow.NEW);  // 9
   flow.DestroyEncodedProgram(flow.NEW);
   if (flow.failed())
     Problem(flow.message().c_str());