AU: Speed up updates by using buffered writes.
Given that SSD writes are really slow, this improves performance significantly.
This reduces update time on AGZ from 375 to 100 seconds.
BUG=6901
TEST=unit tests, gmerged on device and measured speed
Change-Id: Idac7743f6eaa8f26878a2d1f6b9401513e2ca600
Review URL: http://codereview.chromium.org/3471006
diff --git a/buffered_file_writer_unittest.cc b/buffered_file_writer_unittest.cc
new file mode 100644
index 0000000..1c39a4e
--- /dev/null
+++ b/buffered_file_writer_unittest.cc
@@ -0,0 +1,132 @@
+// 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 <gtest/gtest.h>
+
+#include "update_engine/buffered_file_writer.h"
+#include "update_engine/file_writer_mock.h"
+
+using std::string;
+using testing::_;
+using testing::InSequence;
+using testing::Return;
+
+namespace chromeos_update_engine {
+
+static const int kTestFlags = O_CREAT | O_LARGEFILE | O_TRUNC | O_WRONLY;
+static const mode_t kTestMode = 0644;
+
+MATCHER_P2(MemCmp, expected, n, "") { return memcmp(arg, expected, n) == 0; }
+
+class BufferedFileWriterTest : public ::testing::Test {
+ protected:
+ FileWriterMock file_writer_mock_;
+};
+
+TEST_F(BufferedFileWriterTest, CloseErrorTest) {
+ BufferedFileWriter writer(&file_writer_mock_, 100);
+ writer.buffered_bytes_ = 1;
+ InSequence s;
+ EXPECT_CALL(file_writer_mock_, Write(&writer.buffer_[0], 1))
+ .Times(1)
+ .WillOnce(Return(50));
+ EXPECT_CALL(file_writer_mock_, Close()).Times(1).WillOnce(Return(-20));
+ EXPECT_EQ(-20, writer.Close());
+}
+
+TEST_F(BufferedFileWriterTest, CloseNoDataTest) {
+ BufferedFileWriter writer(&file_writer_mock_, 50);
+ InSequence s;
+ EXPECT_CALL(file_writer_mock_, Write(_, _)).Times(0);
+ EXPECT_CALL(file_writer_mock_, Close()).Times(1).WillOnce(Return(-30));
+ EXPECT_EQ(-30, writer.Close());
+}
+
+TEST_F(BufferedFileWriterTest, CloseWriteErrorTest) {
+ BufferedFileWriter writer(&file_writer_mock_, 100);
+ writer.buffered_bytes_ = 2;
+ InSequence s;
+ EXPECT_CALL(file_writer_mock_, Write(&writer.buffer_[0], 2))
+ .Times(1)
+ .WillOnce(Return(-10));
+ EXPECT_CALL(file_writer_mock_, Close()).Times(1).WillOnce(Return(-20));
+ EXPECT_EQ(-10, writer.Close());
+}
+
+TEST_F(BufferedFileWriterTest, ConstructorTest) {
+ BufferedFileWriter writer(&file_writer_mock_, 123);
+ EXPECT_EQ(&file_writer_mock_, writer.next_);
+ EXPECT_EQ(123, writer.buffer_size_);
+ EXPECT_TRUE(writer.buffer_ != NULL);
+ EXPECT_EQ(0, writer.buffered_bytes_);
+}
+
+TEST_F(BufferedFileWriterTest, OpenTest) {
+ BufferedFileWriter writer(&file_writer_mock_, 100);
+ EXPECT_CALL(file_writer_mock_, Open("foo", kTestFlags, kTestMode))
+ .Times(1)
+ .WillOnce(Return(20));
+ EXPECT_EQ(20, writer.Open("foo", kTestFlags, kTestMode));
+}
+
+TEST_F(BufferedFileWriterTest, WriteBufferNoDataTest) {
+ BufferedFileWriter writer(&file_writer_mock_, 300);
+ EXPECT_CALL(file_writer_mock_, Write(_, _)).Times(0);
+ EXPECT_EQ(0, writer.WriteBuffer());
+}
+
+TEST_F(BufferedFileWriterTest, WriteBufferTest) {
+ BufferedFileWriter writer(&file_writer_mock_, 200);
+ writer.buffered_bytes_ = 100;
+ EXPECT_CALL(file_writer_mock_, Write(&writer.buffer_[0], 100))
+ .Times(1)
+ .WillOnce(Return(-10));
+ EXPECT_EQ(-10, writer.WriteBuffer());
+}
+
+TEST_F(BufferedFileWriterTest, WriteErrorTest) {
+ string kData = "test_data";
+ BufferedFileWriter writer(&file_writer_mock_, 4);
+ InSequence s;
+ EXPECT_CALL(file_writer_mock_, Write(MemCmp("test", 4), 4))
+ .Times(1)
+ .WillOnce(Return(3));
+ EXPECT_CALL(file_writer_mock_, Write(MemCmp("_dat", 4), 4))
+ .Times(1)
+ .WillOnce(Return(-10));
+ EXPECT_EQ(-10, writer.Write(kData.data(), kData.size()));
+ EXPECT_EQ(0, writer.buffered_bytes_);
+}
+
+TEST_F(BufferedFileWriterTest, WriteTest) {
+ string kData = "test_data";
+ BufferedFileWriter writer(&file_writer_mock_, 100);
+ writer.buffered_bytes_ = 10;
+ EXPECT_CALL(file_writer_mock_, Write(_, _)).Times(0);
+ EXPECT_EQ(kData.size(), writer.Write(kData.data(), kData.size()));
+ EXPECT_EQ(0, memcmp(kData.data(), &writer.buffer_[10], kData.size()));
+ EXPECT_EQ(kData.size() + 10, writer.buffered_bytes_);
+}
+
+TEST_F(BufferedFileWriterTest, WriteWrapBufferTest) {
+ string kData = "test_data1";
+ BufferedFileWriter writer(&file_writer_mock_, 3);
+ writer.buffered_bytes_ = 1;
+ writer.buffer_[0] = 'x';
+ InSequence s;
+ EXPECT_CALL(file_writer_mock_, Write(MemCmp("xte", 3), 3))
+ .Times(1)
+ .WillOnce(Return(3));
+ EXPECT_CALL(file_writer_mock_, Write(MemCmp("st_", 3), 3))
+ .Times(1)
+ .WillOnce(Return(3));
+ EXPECT_CALL(file_writer_mock_, Write(MemCmp("dat", 3), 3))
+ .Times(1)
+ .WillOnce(Return(3));
+ EXPECT_EQ(kData.size(), writer.Write(kData.data(), kData.size()));
+ EXPECT_EQ(0, memcmp("a1", &writer.buffer_[0], 2));
+ EXPECT_EQ(2, writer.buffered_bytes_);
+}
+
+} // namespace chromeos_update_engine