AU: Delta diff generator shows progress % when generating full updates.

delta_diff_generator.cc

 // Copyright (c) 2010 The Chromium OS 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 "update_engine/delta_diff_generator.h"
 
 #include <errno.h>
 #include <fcntl.h>
 #include <inttypes.h>
 #include <sys/stat.h>
@@ skipping 931 matching lines @@
            e = cuts.end(); it != e; ++it) {
     TEST_AND_RETURN_FALSE(DeltaDiffGenerator::ConvertCutToFullOp(
         graph,
         *it,
         new_root,
         data_fd,
         data_file_size));
     deleted_nodes.insert(it->new_vertex);
   }
   deleted_nodes.insert(cuts[0].old_dst);
-  
+
   vector<Vertex::Index> new_op_indexes;
   new_op_indexes.reserve(op_indexes->size());
   for (vector<Vertex::Index>::iterator it = op_indexes->begin(),
            e = op_indexes->end(); it != e; ++it) {
     if (utils::SetContainsKey(deleted_nodes, *it))
       continue;
     new_op_indexes.push_back(*it);
   }
   new_op_indexes.push_back(cuts[0].old_dst);
   op_indexes->swap(new_op_indexes);
@@ skipping 25 matching lines @@
     uint64_t cut_blocks_needed = 0;
     for (vector<Extent>::const_iterator jt = it->tmp_extents.begin(),
              je = it->tmp_extents.end(); jt != je; ++jt) {
       cut_blocks_needed += jt->num_blocks();
     }
     blocks_needed += cut_blocks_needed;
     cuts_blocks_needed[&*it] = cut_blocks_needed;
   }
   LOG(INFO) << "Need to find " << blocks_needed << " blocks for "
             << cuts.size() << " cuts";
-  
+
   // Find enough blocks
   ExtentRanges scratch_ranges;
   // Each block that's supplying temp blocks and the corresponding blocks:
   typedef vector<pair<Vertex::Index, ExtentRanges> > SupplierVector;
   SupplierVector block_suppliers;
   uint64_t scratch_blocks_found = 0;
   LOG(INFO) << "scan from " << (*reverse_op_indexes)[old_dst] + 1
             << " to " << op_indexes->size();
   for (vector<Vertex::Index>::size_type i = (*reverse_op_indexes)[old_dst] + 1,
            e = op_indexes->size(); i < e; ++i) {
@@ skipping 47 matching lines @@
   TEST_AND_RETURN_FALSE(scratch_ranges.blocks() == scratch_blocks_found);
 
   // Make all the suppliers depend on this node
   for (SupplierVector::iterator it = block_suppliers.begin(),
            e = block_suppliers.end(); it != e; ++it) {
     graph_utils::AddReadBeforeDepExtents(
         &(*graph)[it->first],
         old_dst,
         it->second.GetExtentsForBlockCount(it->second.blocks()));
   }
-  
+
   // Replace temp blocks in each cut
   for (vector<CutEdgeVertexes>::const_iterator it = cuts.begin(),
            e = cuts.end(); it != e; ++it) {
     vector<Extent> real_extents =
         scratch_ranges.GetExtentsForBlockCount(cuts_blocks_needed[&*it]);
     scratch_ranges.SubtractExtents(real_extents);
 
     // Fix the old dest node w/ the real blocks
     DeltaDiffGenerator::SubstituteBlocks(&(*graph)[old_dst],
                                          it->tmp_extents,
@@ skipping 258 matching lines @@
     const string& path = paths[partition];
     LOG(INFO) << "compressing " << path;
 
     int in_fd = open(path.c_str(), O_RDONLY, 0);
     TEST_AND_RETURN_FALSE(in_fd >= 0);
     ScopedFdCloser in_fd_closer(&in_fd);
 
     for (off_t bytes_left = part_sizes[partition], counter = 0, offset = 0;
          bytes_left > 0;
          bytes_left -= chunk_size, ++counter, offset += chunk_size) {
-      LOG(INFO) << "offset = " << offset;
       DeltaArchiveManifest_InstallOperation* op = NULL;
       if (partition == 0) {
         graph->resize(graph->size() + 1);
         graph->back().file_name = path + StringPrintf("-%" PRIi64, counter);
         op = &graph->back().op;
         final_order->push_back(graph->size() - 1);
       } else {
         kernel_ops->resize(kernel_ops->size() + 1);
         op = &kernel_ops->back();
       }
-      LOG(INFO) << "have an op";
 
       vector<char> buf(min(bytes_left, chunk_size));
-      LOG(INFO) << "buf size: " << buf.size();
       ssize_t bytes_read = -1;
 
       TEST_AND_RETURN_FALSE(utils::PReadAll(
           in_fd, &buf[0], buf.size(), offset, &bytes_read));
       TEST_AND_RETURN_FALSE(bytes_read == static_cast<ssize_t>(buf.size()));
 
       vector<char> buf_compressed;
 
       TEST_AND_RETURN_FALSE(BzipCompress(buf, &buf_compressed));
       const bool compress = buf_compressed.size() < buf.size();
       const vector<char>& use_buf = compress ? buf_compressed : buf;
       if (compress) {
         op->set_type(DeltaArchiveManifest_InstallOperation_Type_REPLACE_BZ);
       } else {
         op->set_type(DeltaArchiveManifest_InstallOperation_Type_REPLACE);
       }
       op->set_data_offset(*data_file_size);
       TEST_AND_RETURN_FALSE(utils::WriteAll(fd, &use_buf[0], use_buf.size()));
       *data_file_size += use_buf.size();
       op->set_data_length(use_buf.size());
       Extent* dst_extent = op->add_dst_extents();
       dst_extent->set_start_block(offset / kBlockSize);
       dst_extent->set_num_blocks(chunk_size / kBlockSize);
+
+      LOG(INFO) << StringPrintf("%.1f", offset * 100.0 / part_sizes[partition])

[adlr, 2010/11/03 18:41:51]

how many lines does this produce? Maybe we should print a line less than every
chunk?

[petkov, 2010/11/03 18:43:55]

850 I guess? I'm OK with verbose output as long as it can be interpreted by
random devs.

+                << "% complete (offset: " << offset << ", buf size: "
+                << buf.size() << ")";
     }
   }
 
   return true;
 }
 
 bool DeltaDiffGenerator::GenerateDeltaUpdateFile(
     const string& old_root,
     const string& old_image,
     const string& new_root,
@@ skipping 237 matching lines @@
 
   LOG(INFO) << "All done. Successfully created delta file.";
   return true;
 }
 
 const char* const kBsdiffPath = "bsdiff";
 const char* const kBspatchPath = "bspatch";
 const char* const kDeltaMagic = "CrAU";
 
 };  // namespace chromeos_update_engine