Improved memory usage while applying patch....

courgette/ensemble_create.cc

 // Copyright (c) 2010 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.
 
 // The main idea in Courgette is to do patching *under a tranformation*.  The
 // input is transformed into a new representation, patching occurs in the new
 // repesentation, and then the tranform is reversed to get the patched data.
 //
 // The idea is applied to pieces (or 'elements') of the whole (or 'ensemble').
 // Each of the elements has to go through the same set of steps in lock-step.
@@ skipping 333 matching lines @@
   corrected_transformed_elements_source
       .Init(linearized_corrected_transformed_elements);
 
   Status delta2_status =
       GenerateSimpleDelta(&predicted_transformed_elements_source,
                           &corrected_transformed_elements_source,
                           transformed_elements_correction);
   if (delta2_status != C_OK)
     return delta2_status;
 
+  // Last use, free storage.
+  linearized_predicted_transformed_elements.Retire();
+
   //
   // Generate sub-patch for whole enchilada.
   //
   SinkStream predicted_ensemble;
 
   predicted_ensemble.Write(base->Buffer(), base->Remaining());
 
   SourceStreamSet corrected_transformed_elements_source_set;
   corrected_transformed_elements_source
       .Init(linearized_corrected_transformed_elements);
@@ skipping 10 matching lines @@
                                           &predicted_ensemble);
     if (status != C_OK)
       return status;
     if (!single_corrected_transformed_element.Empty())
       return C_STREAM_NOT_CONSUMED;
   }
 
   if (!corrected_transformed_elements_source_set.Empty())
     return C_STREAM_NOT_CONSUMED;
 
+  // No more references to this stream's buffer.
+  linearized_corrected_transformed_elements.Retire();
+
   FreeGenerators(&generators);
 
+  size_t final_patch_input_size = predicted_ensemble.Length();
   SourceStream predicted_ensemble_source;
   predicted_ensemble_source.Init(predicted_ensemble);
   Status delta3_status = GenerateSimpleDelta(&predicted_ensemble_source,
                                              update,
                                              ensemble_correction);
   if (delta3_status != C_OK)
     return delta3_status;
 
   //
   // Final output stream has a header followed by a StreamSet.
   //
   final_patch->WriteVarint32(CourgettePatchFile::kMagic);
   final_patch->WriteVarint32(CourgettePatchFile::kVersion);
 
   final_patch->WriteVarint32(
       CalculateCrc(old_region.start(), old_region.length()));
   final_patch->WriteVarint32(
       CalculateCrc(new_region.start(), new_region.length()));
+  final_patch->WriteSizeVarint32(final_patch_input_size);
 
   if (!patch_streams.CopyTo(final_patch))
     return C_STREAM_ERROR;
 
   VLOG(1) << "done GenerateEnsemblePatch "
           << (base::Time::Now() - start_time).InSecondsF() << "s";
 
   return C_OK;
 }
 
 }  // namespace