Armando Montanez | f9e93e1 | 2020-04-22 07:44:14 -0700 | [diff] [blame] | 1 | // Copyright 2020 The Pigweed Authors |
| 2 | // |
| 3 | // Licensed under the Apache License, Version 2.0 (the "License"); you may not |
| 4 | // use this file except in compliance with the License. You may obtain a copy of |
| 5 | // the License at |
| 6 | // |
| 7 | // https://www.apache.org/licenses/LICENSE-2.0 |
| 8 | // |
| 9 | // Unless required by applicable law or agreed to in writing, software |
| 10 | // distributed under the License is distributed on an "AS IS" BASIS, WITHOUT |
| 11 | // WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the |
| 12 | // License for the specific language governing permissions and limitations under |
| 13 | // the License. |
| 14 | |
David Rogers | d5138f3 | 2020-04-28 15:18:56 -0700 | [diff] [blame] | 15 | // Always use stats, these tests depend on it. |
| 16 | #define PW_KVS_RECORD_PARTITION_STATS 1 |
| 17 | |
Armando Montanez | f9e93e1 | 2020-04-22 07:44:14 -0700 | [diff] [blame] | 18 | #include "gtest/gtest.h" |
David Rogers | d64cc01 | 2020-05-26 12:37:37 -0700 | [diff] [blame] | 19 | #include "pw_kvs/fake_flash_memory.h" |
Armando Montanez | f9e93e1 | 2020-04-22 07:44:14 -0700 | [diff] [blame] | 20 | #include "pw_kvs/flash_memory.h" |
David Rogers | d5138f3 | 2020-04-28 15:18:56 -0700 | [diff] [blame] | 21 | #include "pw_kvs/flash_partition_with_stats.h" |
Armando Montanez | f9e93e1 | 2020-04-22 07:44:14 -0700 | [diff] [blame] | 22 | #include "pw_kvs/key_value_store.h" |
| 23 | #include "pw_log/log.h" |
| 24 | |
| 25 | namespace pw::kvs { |
| 26 | namespace { |
| 27 | |
David Rogers | 436b3aa | 2020-08-03 08:44:10 -0700 | [diff] [blame] | 28 | // For KVS magic value always use a random 32 bit integer rather than a |
| 29 | // human readable 4 bytes. See pw_kvs/format.h for more information. |
| 30 | constexpr EntryFormat format{.magic = 0x1bce4ad5, .checksum = nullptr}; |
Armando Montanez | f9e93e1 | 2020-04-22 07:44:14 -0700 | [diff] [blame] | 31 | |
David Rogers | d5138f3 | 2020-04-28 15:18:56 -0700 | [diff] [blame] | 32 | class WearTest : public ::testing::Test { |
| 33 | protected: |
| 34 | WearTest() |
| 35 | : flash_(internal::Entry::kMinAlignmentBytes), |
| 36 | partition_(&flash_, 0, flash_.sector_count()), |
| 37 | kvs_(&partition_, format) { |
Wyatt Hepler | 1b3da3a | 2021-01-07 13:26:57 -0800 | [diff] [blame] | 38 | EXPECT_EQ(OkStatus(), kvs_.Init()); |
David Rogers | d5138f3 | 2020-04-28 15:18:56 -0700 | [diff] [blame] | 39 | } |
| 40 | |
| 41 | static constexpr size_t kSectors = 16; |
| 42 | static constexpr size_t kMaxEntries = 256; |
| 43 | static constexpr size_t kTestPartitionSectorSize = 512; |
| 44 | |
David Rogers | d64cc01 | 2020-05-26 12:37:37 -0700 | [diff] [blame] | 45 | FakeFlashMemoryBuffer<kTestPartitionSectorSize, kSectors> flash_; |
David Rogers | d5138f3 | 2020-04-28 15:18:56 -0700 | [diff] [blame] | 46 | FlashPartitionWithStatsBuffer<kSectors> partition_; |
| 47 | |
| 48 | KeyValueStoreBuffer<kMaxEntries, kSectors> kvs_; |
| 49 | }; |
| 50 | |
| 51 | // Block of data to use for entry value. Sized to 470 so the total entry results |
| 52 | // in using most of the 512 byte sector. |
| 53 | uint8_t test_data[470] = {1, 2, 3, 4, 5, 6}; |
Armando Montanez | f9e93e1 | 2020-04-22 07:44:14 -0700 | [diff] [blame] | 54 | |
| 55 | // Write a large key (i.e. only one entry fits in each sector) enough times to |
| 56 | // fill up the KVS multiple times, and ensure every sector was garbage collected |
| 57 | // multiple additional times. |
David Rogers | d5138f3 | 2020-04-28 15:18:56 -0700 | [diff] [blame] | 58 | TEST_F(WearTest, RepeatedLargeEntry) { |
Armando Montanez | f9e93e1 | 2020-04-22 07:44:14 -0700 | [diff] [blame] | 59 | // Initialize an empty KVS, erasing flash and all tracked sector erase counts. |
David Rogers | d5138f3 | 2020-04-28 15:18:56 -0700 | [diff] [blame] | 60 | partition_.ResetCounters(); |
Armando Montanez | f9e93e1 | 2020-04-22 07:44:14 -0700 | [diff] [blame] | 61 | |
| 62 | // Add enough large entries to fill the entire KVS several times. |
David Rogers | d5138f3 | 2020-04-28 15:18:56 -0700 | [diff] [blame] | 63 | for (size_t i = 0; i < kSectors * 10; ++i) { |
| 64 | // modify the value to ensure a key-value different than was previously |
| 65 | // written. |
| 66 | test_data[0]++; |
| 67 | |
Wyatt Hepler | e2cbadf | 2020-06-22 11:21:45 -0700 | [diff] [blame] | 68 | EXPECT_TRUE(kvs_.Put("large_entry", std::span(test_data)).ok()); |
Armando Montanez | f9e93e1 | 2020-04-22 07:44:14 -0700 | [diff] [blame] | 69 | } |
| 70 | |
| 71 | // Ensure every sector has been erased at several times due to garbage |
| 72 | // collection. |
David Rogers | d5138f3 | 2020-04-28 15:18:56 -0700 | [diff] [blame] | 73 | EXPECT_GE(partition_.min_erase_count(), 7u); |
| 74 | EXPECT_LE(partition_.max_erase_count(), partition_.min_erase_count() + 1u); |
| 75 | |
| 76 | partition_.SaveStorageStats(kvs_, "WearTest RepeatedLargeEntry"); |
Armando Montanez | f9e93e1 | 2020-04-22 07:44:14 -0700 | [diff] [blame] | 77 | } |
| 78 | |
David Rogers | d5138f3 | 2020-04-28 15:18:56 -0700 | [diff] [blame] | 79 | // Test a KVS with a number of entries, several sectors that are nearly full |
| 80 | // of stale (reclaimable) space, and not enough writable (free) space to add a |
| 81 | // redundant copy for any of the entries. Tests that the add redundancy step of |
| 82 | // repair is able to use garbage collection to free up space needed for the new |
| 83 | // copies. |
| 84 | TEST_F(WearTest, TwoPassFillWithLargeAndLarger) { |
| 85 | partition_.ResetCounters(); |
| 86 | |
| 87 | // Add a large entry that will only fit once per sector enough times to fill |
| 88 | // the KVS with mostly stale data. |
| 89 | for (size_t i = 0; i < kSectors; i++) { |
| 90 | // modify the value to ensure a key-value different than was previously |
| 91 | // written. |
| 92 | test_data[0]++; |
| 93 | |
| 94 | EXPECT_EQ( |
Wyatt Hepler | 1b3da3a | 2021-01-07 13:26:57 -0800 | [diff] [blame] | 95 | OkStatus(), |
Wyatt Hepler | e2cbadf | 2020-06-22 11:21:45 -0700 | [diff] [blame] | 96 | kvs_.Put("key", |
| 97 | std::as_bytes(std::span(test_data, sizeof(test_data) - 70)))); |
David Rogers | d5138f3 | 2020-04-28 15:18:56 -0700 | [diff] [blame] | 98 | } |
| 99 | |
| 100 | // Add many copies of a differently sized entry that is larger than the |
| 101 | // previous entry. |
| 102 | for (size_t i = 0; i < kSectors * 200; i++) { |
| 103 | // Modify the value to ensure a key-value different than was previously |
| 104 | // written. |
| 105 | test_data[0]++; |
| 106 | |
| 107 | printf("Add entry %zu\n", i); |
Wyatt Hepler | 1b3da3a | 2021-01-07 13:26:57 -0800 | [diff] [blame] | 108 | EXPECT_EQ(OkStatus(), kvs_.Put("big_key", test_data)); |
David Rogers | d5138f3 | 2020-04-28 15:18:56 -0700 | [diff] [blame] | 109 | } |
| 110 | |
| 111 | EXPECT_EQ(2u, kvs_.size()); |
| 112 | EXPECT_LT(partition_.max_erase_count(), |
| 113 | 2u * partition_.average_erase_count()); |
| 114 | } |
| 115 | |
| 116 | } // namespace |
Armando Montanez | f9e93e1 | 2020-04-22 07:44:14 -0700 | [diff] [blame] | 117 | } // namespace pw::kvs |