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

courgette/courgette_tool.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <stdarg.h>
 #include <stddef.h>
 #include <stdint.h>
 
 #include <initializer_list>
 #include <memory>
@@ skipping 137 matching lines @@
   }
 
   printf("%s Executable\n", format.c_str());
   return result;
 }
 
 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);
   courgette::SinkStream sink;
   flow.WriteSinkStreamFromSinkStreamSet(flow.ONLY, &sink);
   if (flow.failed())
     Problem(flow.message().c_str());
 
   WriteSinkToFile(&sink, output_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);
   if (flow.failed())
     Problem(flow.message().c_str());
 
   WriteSinkToFile(&sink, output_file);
 }
 
 // Diffs two executable files, write a set of files for the diff, one file per
 // stream of the EncodedProgram format.  Each file is the bsdiff between the
 // original file's stream and the new file's stream.  This is completely
 // uninteresting to users, but it is handy for seeing how much each which
 // streams are contributing to the final file size.  Adjustment is optional.
 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());
 
   courgette::SinkStream empty_sink;
   for (int i = 0;  ; ++i) {
     courgette::SinkStream* old_stream = flow.data(flow.OLD)->sinks.stream(i);
     courgette::SinkStream* new_stream = flow.data(flow.NEW)->sinks.stream(i);
     if (old_stream == NULL && new_stream == NULL)
       break;
@@ skipping 233 matching lines @@
         UsageProblem(kUsageGen1);
       DisassembleAdjustDiff(values[0], values[1], values[2],
                             cmd_spread_1_adjusted);
     } else {
       UsageProblem("No operation specified");
     }
   }
 
   return 0;
 }