AU: Speed up full update payload generation by running multiple threads.

delta_performer_unittest.cc

 // Copyright (c) 2009 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 <sys/mount.h>
 #include <inttypes.h>
 
 #include <algorithm>
 #include <string>
 #include <vector>
 
 #include <base/file_util.h>
 #include <base/scoped_ptr.h>
 #include <base/string_util.h>
 #include <google/protobuf/repeated_field.h>
 #include <gtest/gtest.h>
 
 #include "update_engine/delta_diff_generator.h"
 #include "update_engine/delta_performer.h"
 #include "update_engine/extent_ranges.h"
+#include "update_engine/full_update_generator.h"
 #include "update_engine/graph_types.h"
 #include "update_engine/payload_signer.h"
 #include "update_engine/prefs_mock.h"
 #include "update_engine/test_utils.h"
 #include "update_engine/update_metadata.pb.h"
 #include "update_engine/utils.h"
 
 namespace chromeos_update_engine {
 
 using std::min;
@@ skipping 75 matching lines @@
   int fd = open(path.c_str(), O_CREAT | O_TRUNC | O_WRONLY, 0644);
   TEST_AND_RETURN_FALSE_ERRNO(fd >= 0);
   ScopedFdCloser fd_closer(&fd);
   off_t rc = lseek(fd, size + 1, SEEK_SET);
   TEST_AND_RETURN_FALSE_ERRNO(rc != static_cast<off_t>(-1));
   int return_code = ftruncate(fd, size);
   TEST_AND_RETURN_FALSE_ERRNO(return_code == 0);
   return true;
 }
 
-void DoSmallImageTest(bool full_kernel, bool noop) {
+void DoSmallImageTest(bool full_kernel, bool full_rootfs, bool noop) {
   string a_img, b_img;
   EXPECT_TRUE(utils::MakeTempFile("/tmp/a_img.XXXXXX", &a_img, NULL));
   ScopedPathUnlinker a_img_unlinker(a_img);
   EXPECT_TRUE(utils::MakeTempFile("/tmp/b_img.XXXXXX", &b_img, NULL));
   ScopedPathUnlinker b_img_unlinker(b_img);
 
   CreateExtImageAtPath(a_img, NULL);
 
   int image_size = static_cast<int>(utils::FileSize(a_img));
 
@@ skipping 87 matching lines @@
   EXPECT_TRUE(utils::MakeTempFile("/tmp/delta.XXXXXX", &delta_path, NULL));
   LOG(INFO) << "delta path: " << delta_path;
   ScopedPathUnlinker delta_path_unlinker(delta_path);
   {
     string a_mnt, b_mnt;
     ScopedLoopMounter a_mounter(a_img, &a_mnt, MS_RDONLY);
     ScopedLoopMounter b_mounter(b_img, &b_mnt, MS_RDONLY);
 
     EXPECT_TRUE(
         DeltaDiffGenerator::GenerateDeltaUpdateFile(
-            a_mnt,
-            a_img,
+            full_rootfs ? "" : a_mnt,
+            full_rootfs ? "" : a_img,
             b_mnt,
             b_img,
             full_kernel ? "" : old_kernel,
             new_kernel,
             delta_path,
             kUnittestPrivateKeyPath));
   }
 
   // Read delta into memory.
   vector<char> delta;
@@ skipping 35 matching lines @@
       EXPECT_EQ(1, manifest.kernel_install_operations_size());
     }
 
     if (full_kernel) {
       EXPECT_FALSE(manifest.has_old_kernel_info());
     } else {
       EXPECT_EQ(old_kernel_data.size(), manifest.old_kernel_info().size());
       EXPECT_FALSE(manifest.old_kernel_info().hash().empty());
     }
 
+    if (full_rootfs) {
+      EXPECT_FALSE(manifest.has_old_rootfs_info());
+    } else {
+      EXPECT_EQ(image_size, manifest.old_rootfs_info().size());
+      EXPECT_FALSE(manifest.old_rootfs_info().hash().empty());
+    }
+
     EXPECT_EQ(new_kernel_data.size(), manifest.new_kernel_info().size());
-    EXPECT_EQ(image_size, manifest.old_rootfs_info().size());
     EXPECT_EQ(image_size, manifest.new_rootfs_info().size());
 
     EXPECT_FALSE(manifest.new_kernel_info().hash().empty());
-    EXPECT_FALSE(manifest.old_rootfs_info().hash().empty());
     EXPECT_FALSE(manifest.new_rootfs_info().hash().empty());
   }
 
   PrefsMock prefs;
   EXPECT_CALL(prefs, SetInt64(kPrefsManifestMetadataSize,
                               manifest_metadata_size)).WillOnce(Return(true));
   EXPECT_CALL(prefs, SetInt64(kPrefsUpdateStateNextOperation, _))
       .WillRepeatedly(Return(true));
   EXPECT_CALL(prefs, GetInt64(kPrefsUpdateStateNextOperation, _))
       .WillOnce(Return(false));
@@ skipping 42 matching lines @@
   EXPECT_TRUE(utils::FileExists(kUnittestPublicKeyPath));
   EXPECT_TRUE(performer.VerifyPayload(
       kUnittestPublicKeyPath,
       OmahaHashCalculator::OmahaHashOfData(delta),
       delta.size()));
   EXPECT_TRUE(performer.VerifyAppliedUpdate(a_img, old_kernel));
 }
 }
 
 TEST(DeltaPerformerTest, RunAsRootSmallImageTest) {
-  DoSmallImageTest(false, false);
+  DoSmallImageTest(false, false, false);
 }
 
 TEST(DeltaPerformerTest, RunAsRootFullKernelSmallImageTest) {
-  DoSmallImageTest(true, false);
+  DoSmallImageTest(true, false, false);
+}
+
+TEST(DeltaPerformerTest, RunAsRootFullSmallImageTest) {
+  DoSmallImageTest(true, true, false);
 }
 
 TEST(DeltaPerformerTest, RunAsRootNoopSmallImageTest) {
-  DoSmallImageTest(false, true);
-}
-
-TEST(DeltaPerformerTest, NewFullUpdateTest) {
-  vector<char> new_root(20 * 1024 * 1024);
-  vector<char> new_kern(16 * 1024 * 1024);
-  const off_t kChunkSize = 128 * 1024;
-  FillWithData(&new_root);
-  FillWithData(&new_kern);
-  // Assume hashes take 2 MiB beyond the rootfs.
-  off_t new_rootfs_size = new_root.size() - 2 * 1024 * 1024;
-
-  string new_root_path;
-  EXPECT_TRUE(utils::MakeTempFile("/tmp/NewFullUpdateTest_R.XXXXXX",
-                                  &new_root_path,
-                                  NULL));
-  ScopedPathUnlinker new_root_path_unlinker(new_root_path);
-  EXPECT_TRUE(WriteFileVector(new_root_path, new_root));
-
-  string new_kern_path;
-  EXPECT_TRUE(utils::MakeTempFile("/tmp/NewFullUpdateTest_K.XXXXXX",
-                                  &new_kern_path,
-                                  NULL));
-  ScopedPathUnlinker new_kern_path_unlinker(new_kern_path);
-  EXPECT_TRUE(WriteFileVector(new_kern_path, new_kern));
-
-  string out_blobs_path;
-  int out_blobs_fd;
-  EXPECT_TRUE(utils::MakeTempFile("/tmp/NewFullUpdateTest_D.XXXXXX",
-                                  &out_blobs_path,
-                                  &out_blobs_fd));
-  ScopedPathUnlinker out_blobs_path_unlinker(out_blobs_path);
-  ScopedFdCloser out_blobs_fd_closer(&out_blobs_fd);
-
-  off_t out_blobs_length = 0;
-
-  Graph graph;
-  vector<DeltaArchiveManifest_InstallOperation> kernel_ops;
-  vector<Vertex::Index> final_order;
-
-  EXPECT_TRUE(DeltaDiffGenerator::ReadFullUpdateFromDisk(&graph,
-                                                         new_kern_path,
-                                                         new_root_path,
-                                                         new_rootfs_size,
-                                                         out_blobs_fd,
-                                                         &out_blobs_length,
-                                                         kChunkSize,
-                                                         &kernel_ops,
-                                                         &final_order));
-  EXPECT_EQ(new_rootfs_size / kChunkSize, graph.size());
-  EXPECT_EQ(new_rootfs_size / kChunkSize, final_order.size());
-  EXPECT_EQ(new_kern.size() / kChunkSize, kernel_ops.size());
-  for (off_t i = 0; i < (new_rootfs_size / kChunkSize); ++i) {
-    EXPECT_EQ(i, final_order[i]);
-    EXPECT_EQ(1, graph[i].op.dst_extents_size());
-    EXPECT_EQ(i * kChunkSize / kBlockSize,
-              graph[i].op.dst_extents(0).start_block()) << "i = " << i;
-    EXPECT_EQ(kChunkSize / kBlockSize,
-              graph[i].op.dst_extents(0).num_blocks());
-    if (graph[i].op.type() !=
-        DeltaArchiveManifest_InstallOperation_Type_REPLACE) {
-      EXPECT_EQ(DeltaArchiveManifest_InstallOperation_Type_REPLACE_BZ,
-                graph[i].op.type());
-    }
-  }
+  DoSmallImageTest(false, false, true);
 }
 
 TEST(DeltaPerformerTest, IsIdempotentOperationTest) {
   DeltaArchiveManifest_InstallOperation op;
   EXPECT_TRUE(DeltaPerformer::IsIdempotentOperation(op));
   *(op.add_dst_extents()) = ExtentForRange(0, 5);
   EXPECT_TRUE(DeltaPerformer::IsIdempotentOperation(op));
   *(op.add_src_extents()) = ExtentForRange(4, 1);
   EXPECT_FALSE(DeltaPerformer::IsIdempotentOperation(op));
   op.clear_src_extents();
   *(op.add_src_extents()) = ExtentForRange(5, 3);
   EXPECT_TRUE(DeltaPerformer::IsIdempotentOperation(op));
   *(op.add_dst_extents()) = ExtentForRange(20, 6);
   EXPECT_TRUE(DeltaPerformer::IsIdempotentOperation(op));
   *(op.add_src_extents()) = ExtentForRange(19, 2);
   EXPECT_FALSE(DeltaPerformer::IsIdempotentOperation(op));
 }
 
 }  // namespace chromeos_update_engine