pw_kvs#

Lightweight, persistent key-value store

Stable C++17 Code Size Impact: ~12 kB

#include <cstddef>

#include "pw_kvs/flash_test_partition.h"
#include "pw_kvs/key_value_store.h"
// Not a required dep; just here for demo comms
#include "pw_sys_io/sys_io.h"

// Create our key-value store (KVS). Sector and entry vals for this
// demo are based on @pigweed//pw_kvs:fake_flash_64_aligned_partition
constexpr size_t kMaxSectors = 6;
constexpr size_t kMaxEntries = 64;
static constexpr pw::kvs::EntryFormat kvs_format = {
  .magic = 0xd253a8a9,  // Prod apps should use a random number here
  .checksum = nullptr
};
pw::kvs::KeyValueStoreBuffer<kMaxEntries, kMaxSectors> kvs(
  &pw::kvs::FlashTestPartition(),
  kvs_format
);

kvs.Init();  // Initialize our KVS
std::byte in;
pw::sys_io::ReadByte(&in).IgnoreError();  // Get a char from the user
kvs.Put("in", in);  // Save the char to our key-value store (KVS)
std::byte out;
kvs.Get("in", &out);  // Test that the KVS stored the data correctly
pw::sys_io::WriteByte(out).IgnoreError();  // Echo the char back out
cc_binary(
    name = "app",
    srcs = ["app.cc"],
    # ...
    deps = [
        # ...
        "@pigweed//pw_kvs",
        "@pigweed//pw_kvs:fake_flash_64_aligned_partition",
        # ...
    ]
    # ...
)

pw_kvs is a flash-backed, persistent key-value storage (KVS) system with integrated wear leveling. It’s a relatively lightweight alternative to a file system.

Get started

Integrate pw_kvs into your project

Reference

pw_kvs API reference

Design

How pw_kvs manages state, does garbage collection, etc.

Code size analysis

The code size impact of using pw_kvs in your project

Get started#

Add @pigweed//pw_kvs to your target’s deps:

cc_binary(
  # ...
  deps = [
    # ...
    "@pigweed//pw_kvs",
    # ...
  ]
)

This assumes that your Bazel WORKSPACE has a repository named @pigweed that points to the upstream Pigweed repository.

Add $dir_pw_kvs to the deps list in your pw_executable() build target:

pw_executable("...") {
  # ...
  deps = [
    # ...
    "$dir_pw_kvs",
    # ...
  ]
}

Link your library to pw_kvs:

add_library(my_lib ...)
target_link_libraries(my_lib PUBLIC pw_kvs)

Use pw_kvs in your C++ code:

#include "pw_kvs/key_value_store.h"

// ...

Implement the flash memory and flash partition interfaces for your hardware. See pw_kvs/flash_memory.h.

Reference#

pw::kvs::KeyValueStore#

See Design for architectural details.

class KeyValueStore#

Flash-backed persistent key-value store (KVS) with integrated wear-leveling.

Instances are declared as instances of pw::kvs::KeyValueStoreBuffer<MAX_ENTRIES, MAX_SECTORS>, which allocates buffers for tracking entries and flash sectors.

#include "pw_kvs/key_value_store.h"
#include "pw_kvs/flash_test_partition.h"

constexpr size_t kMaxSectors = 6;
constexpr size_t kMaxEntries = 64;
static constexpr pw::kvs::EntryFormat kvs_format = {
  .magic = 0xd253a8a9,  // Prod apps should use a random number here
  .checksum = nullptr
};
pw::kvs::KeyValueStoreBuffer<kMaxEntries, kMaxSectors> kvs(
  &pw::kvs::FlashTestPartition(),
  kvs_format
);

kvs.Init();

Subclassed by pw::kvs::KeyValueStoreBuffer< kMaxEntries, kMaxUsableSectors, kRedundancy, kEntryFormats >

Public Functions

Status Init()#

Initializes the KVS. Must be called before calling other functions.

Returns:

  • OK - The KVS successfully initialized.

  • DATA_LOSS - The KVS initialized and is usable, but contains corrupt data.

  • UNKNOWN - Unknown error. The KVS is not initialized.

StatusWithSize Get(Key key, span<std::byte> value, size_t offset_bytes = 0) const#

Reads the value of an entry in the KVS. The value is read into the provided buffer and the number of bytes read is returned. Reads can be started at an offset.

Parameters:
  • key[in] The name of the key.

  • value[out] The buffer to read the key’s value into.

  • offset_bytes[in] The byte offset to start the read at. Optional.

Returns:

  • OK - The entry was successfully read.

  • NOT_FOUND - The key is not present in the KVS.

  • DATA_LOSS - Found the entry, but the data was corrupted.

  • RESOURCE_EXHAUSTED - The buffer could not fit the entire value, but as many bytes as possible were written to it. The number of of bytes read is returned. The remainder of the value can be read by calling Get() again with an offset.

  • FAILED_PRECONDITION - The KVS is not initialized. Call Init() before calling this method.

  • INVALID_ARGUMENT - key is empty or too long, or value is too large.

template<typename Pointer, typename = std::enable_if_t<std::is_pointer<Pointer>::value>>
inline Status Get(
const Key &key,
const Pointer &pointer,
) const#

Overload of Get() that accepts a pointer to a trivially copyable object.

If value is an array, call Get() with as_writable_bytes(span(array)), or pass a pointer to the array instead of the array itself.

template<typename T, typename std::enable_if_t<ConvertsToSpan<T>::value>* = nullptr>
inline Status Put(
const Key &key,
const T &value,
)#

Adds a key-value entry to the KVS. If the key was already present, its value is overwritten.

Parameters:
  • key[in] The name of the key. All keys in the KVS must have a unique hash. If the hash of your key matches an existing key, nothing is added and ALREADY_EXISTS is returned.

  • value[in] The value for the key. This can be a span of bytes or a trivially copyable object.

Returns:

  • OK - The entry was successfully added or updated.

  • DATA_LOSS - Checksum validation failed after writing data.

  • RESOURCE_EXHAUSTED - Not enough space to add the entry.

  • ALREADY_EXISTS - The entry could not be added because a different key with the same hash is already in the KVS.

  • FAILED_PRECONDITION - The KVS is not initialized. Call Init() before calling this method.

  • INVALID_ARGUMENT - key is empty or too long, or value is too large.

Status Delete(Key key)#

Removes a key-value entry from the KVS.

Parameters:

key[in] - The name of the key-value entry to delete.

Returns:

StatusWithSize ValueSize(Key key) const#

Returns the size of the value corresponding to the key.

Parameters:

key[in] - The name of the key.

Returns:

inline Status HeavyMaintenance()#

Performs all maintenance possible, including all needed repairing of corruption and garbage collection of reclaimable space in the KVS. When configured for manual recovery, this (along with FullMaintenance()) is the only way KVS repair is triggered.

Warning

Performs heavy garbage collection of all reclaimable space, regardless of whether there’s other valid data in the sector. This method may cause a significant amount of moving of valid entries.

inline Status FullMaintenance()#

Perform all maintenance possible, including all needed repairing of corruption and garbage collection of reclaimable space in the KVS. When configured for manual recovery, this (along with HeavyMaintenance()) is the only way KVS repair is triggered.

Does not garbage collect sectors with valid data unless the KVS is mostly full.

Status PartialMaintenance()#

Performs a portion of KVS maintenance. If configured for at least lazy recovery, will do any needed repairing of corruption. Does garbage collection of part of the KVS, typically a single sector or similar unit that makes sense for the KVS implementation.

iterator begin() const#
Returns:

The first key-value entry in the container. Used for iteration.

inline iterator end() const#
Returns:

The last key-value entry in the container. Used for iteration.

inline size_t size() const#
Returns:

The number of valid entries in the KVS.

inline size_t total_entries_with_deleted() const#
Returns:

The number of valid entries and deleted entries yet to be collected.

inline size_t max_size() const#
Returns:

The maximum number of KV entries that’s possible in the KVS.

inline size_t empty() const#
Returns:

true if the KVS is empty.

inline uint32_t transaction_count() const#
Returns:

The number of transactions that have occurred since the KVS was first used. This value is retained across initializations, but is reset if the underlying flash is erased.

StorageStats GetStorageStats() const#
Returns:

A StorageStats struct with details about the current and past state of the KVS.

inline size_t redundancy() const#
Returns:

The number of identical copies written for each entry. A redundancy of 1 means that only a single copy is written for each entry.

inline bool error_detected() const#
Returns:

true if the KVS has any unrepaired errors.

inline size_t max_key_value_size_bytes() const#
Returns:

The maximum number of bytes allowed for a key-value combination.

bool CheckForErrors()#

Checks the KVS for any error conditions and returns true if any errors are present. Primarily intended for test and internal use.

Public Static Functions

static inline constexpr size_t max_key_value_size_bytes(size_t partition_sector_size_bytes)#
Returns:

The maximum number of bytes allowed for a given sector size for a key-value combination.

class Item#

Representation of a key-value entry during iteration.

Public Functions

inline const char *key() const#
Returns:

The key as a null-terminated string.

inline StatusWithSize Get(span<std::byte> value_buffer, size_t offset_bytes = 0) const#
Returns:

The value referred to by this iterator. Equivalent to pw::kvs::KeyValueStore::Get().

class iterator#

Supported iteration methods.

Public Functions

iterator &operator++()#

Increments to the next key-value entry in the container.

inline iterator operator++(int)#

Increments to the next key-value entry in the container.

inline const Item &operator*()#

Reads the entry’s key from flash.

inline const Item *operator->()#

Reads the entry into the Item object.

inline constexpr bool operator==(const iterator &rhs) const#

Equality comparison of two entries.

inline constexpr bool operator!=(const iterator &rhs) const#

Inequality comparison of two entries.

struct StorageStats#

Statistics about the KVS.

Statistics are since the KVS init. They’re not retained across reboots.

Public Members

size_t writable_bytes#

The number of writeable bytes remaining in the KVS. This number doesn’t include the one empty sector required for KVS garbage collection.

size_t in_use_bytes#

The number of bytes in the KVS that are already in use.

size_t reclaimable_bytes#

The maximum number of bytes possible to reclaim by garbage collection. The number of bytes actually reclaimed by maintenance depends on the type of maintenance that’s performed.

size_t sector_erase_count#

The total count of individual sector erases that have been performed.

size_t corrupt_sectors_recovered#

The number of corrupt sectors that have been recovered.

size_t missing_redundant_entries_recovered#

The number of missing redundant copies of entries that have been recovered.

Configuration#

PW_KVS_LOG_LEVEL#

Which log level to use for pw_kvs logs.

PW_KVS_MAX_FLASH_ALIGNMENT#

The maximum flash alignment supported.

PW_KVS_REMOVE_DELETED_KEYS_IN_HEAVY_MAINTENANCE#

Whether to remove deleted keys in heavy maintanence. This feature costs some code size (>1KB) and is only necessary if arbitrary key names are used. Without this feature, deleted key entries can fill the KVS, making it impossible to add more keys, even though most keys are deleted.

Design#

pw::kvs::KeyValueStore (“the KVS”) stores key and value data pairs. The key-value pairs are stored in flash partition as a key-value entry (KV entry) that consists of a header/metadata, the key data, and value data. KV entries are accessed through Put(), Get(), and Delete() operations.

Key-value entries#

Each key-value (KV) entry consists of a header/metadata, the key data, and value data. Individual KV entries are contained within a single flash sector; they do not cross sector boundaries. Because of this the maximum KV entry size is the partition sector size.

KV entries are appended as needed to sectors, with append operations spread over time. Each individual KV entry is written completely as a single high-level operation. KV entries are appended to a sector as long as space is available for a given KV entry. Multiple sectors can be active for writing at any time.

When an entry is updated, an entirely new entry is written to a new location that may or may not be located in the same sectore as the old entry. The new entry uses a transaction ID greater than the old entry. The old entry remains unaltered “on-disk” but is considered “stale”. It is garbage collected at some future time.

State#

The KVS does not store any data/metadata/state in flash beyond the KV entries. All KVS state can be derived from the stored KV entries. Current state is determined at boot from flash-stored KV entries and then maintained in RAM by the KVS. At all times the KVS is in a valid state on-flash; there are no windows of vulnerability to unexpected power loss or crash. The old entry for a key is maintained until the new entry for that key is written and verified.

Each KV entry has a unique transaction ID that is incremented for each KVS update transaction. When determining system state from flash-stored KV entries, the valid entry with the highest transaction ID is considered to be the “current” entry of the key. All stored entries of the same key with lower transaction IDs are considered old or “stale”.

Updates/rewrites of a key that has been previously stored is done as a new KV entry with an updated transaction ID and the new value for the key. The internal state of the KVS is updated to reflect the new entry. The previously stored KV entries for that key are not modified or removed from flash storage, until garbage collection reclaims the “stale” entries.

Garbage collection is done by copying any currently valid KV entries in the sector to be garbage collected to a different sector and then erasing the sector.

Flash sectors#

Each flash sector is written sequentially in an append-only manner, with each following entry write being at a higher address than all of the previous entry writes to that sector since erase. Once information (header, metadata, data, etc.) is written to flash, that information is not modified or cleared until a full sector erase occurs as part of garbage collection.

Individual KV entries are contained within a single flash sector; they do not cross sector boundaries. Flash sectors can contain as many KV entries as fit in the sector.

Sectors are the minimum erase size for both Flash memory and Flash partitions. Partitions may have a different logical sector size than the memory they are part of. Partition logical sectors may be smaller due to partition overhead (encryption, wear tracking, etc) or larger due to combining raw sectors into larger logical sectors.

Storage layers#

The flash storage used by the KVS is comprised of two layers, flash memory and flash partitions.

Flash memory#

pw::kvs::FlashMemory is the lower storage layer that manages the raw read/write/erase of the flash memory device. It is an abstract base class that needs a concrete implementation before it can be used.

pw::kvs::FakeFlashMemory is a variant that uses RAM rather than flash as the storage media. This is helpful for reducing physical flash wear during unit tests and development.

Flash partitions#

pw::kvs::FlashPartition is a subset of a pw::kvs::FlashMemory. Flash memory may have one or multiple partition instances that represent different parts of the memory, such as partitions for KVS, OTA, snapshots/crashlogs, etc. Each partition has its own separate logical address space starting from zero to size bytes of the partition. Partition logical addresses do not always map directly to memory addresses due to partition encryption, sector headers, etc.

Partitions support access via pw::kvs::NonSeekableWriter and pw::kvs::SeekableReader. The reader defaults to the full size of the partition but can optionally be limited to a smaller range.

pw::kvs::FlashPartition is a concrete class that can be used directly. It has several derived variants available, such as pw::kvs::FlashPartitionWithStats and pw::kvs::FlashPartitionWithLogicalSectors.

Alignment#

Writes to flash must have a start address that is a multiple of the flash write alignment. Write size must also be a multiple of flash write alignment. Write alignment varies by flash device and partition type. Reads from flash do not have any address or size alignment requirement; reads always have a minimum alignment of 1.

Flash partitions may have a different alignment than the Flash memory they are part of, so long as the partition’s alignment is a multiple of the alignment for the memory.

Allocation#

The KVS requires more storage space than the size of the key-value data stored. This is due to the always-free sector required for garbage collection and the “write and garbage collect later” approach it uses.

The KVS works poorly when stored data takes up more than 75% of the available storage. It works best when stored data is less than 50%. Applications that need to do garbage collection at scheduled times or that write very heavily can benefit from additional flash store space.

The flash storage used by the KVS is multiplied by the amount of Redundancy used. A redundancy of 2 will use twice the storage, for example.

Redundancy#

The KVS supports storing redundant copies of KV entries. For a given redundancy level (N), N total copies of each KV entry are stored. Redundant copies are always stored in different sectors. This protects against corruption or even full sector loss in N-1 sectors without data loss.

Redundancy increases flash usage proportional to the redundancy level. The RAM usage for KVS internal state has a small increase with redundancy.

Garbage collection#

Storage space occupied by stale Key-value entries is reclaimed and made available for reuse through a garbage collection process. The base garbage collection operation is done to reclaim one sector at a time.

The KVS always keeps at least one sector free at all times to ensure the ability to garbage collect. This free sector is used to copy valid entries from the sector to be garbage collected before erasing the sector to be garbage collected. The always-free sector is rotated as part of the KVS wear leveling.

Garbage collection can be performed manually, by invoking the methods below, or it can be configured to happen automatically.

Wear leveling (flash wear management)#

Wear leveling is accomplished by cycling selection of the next sector to write to. This cycling spreads flash wear across all free sectors so that no one sector is prematurely worn out.

The wear leveling decision-making process follows these guidelines:

  • Location of new writes/rewrites of KV entries will prefer sectors already in-use (partially filled), with new (blank) sectors used when no in-use sectors have large enough available space for the new write.

  • New (blank) sectors selected cycle sequentially between available free sectors.

  • The wear leveling system searches for the first available sector, starting from the current write sector + 1 and wraps around to start at the end of a partition. This spreads the erase/write cycles for heavily written/rewritten KV entries across all free sectors, reducing wear on any single sector.

  • Erase count is not considered in the wear leveling decision-making process.

  • Sectors with already written KV entries that are not modified will remain in the original sector and not participate in wear-leveling, so long as the KV entries in the sector remain unchanged.

Code size analysis#

The following size report details the memory usage of KeyValueStore and FlashPartition.

Label

Segment

Delta

KeyValueStore

FLASH

+24

[section .code]

-4

quorem

-40

main

+26

pw::kvs::FlashPartition::Read()

+2

pw::kvs::FlashPartition::size_bytes()

+22

pw::Vector<>::operator[]()

DEL

-16

_GLOBAL__sub_I_test_partition

NEW

+656

pw::kvs::KeyValueStore::InitializeMetadata()

NEW

+412

pw::kvs::internal::EntryCache::Find()

NEW

+380

pw::kvs::KeyValueStore::Init()

NEW

+338

pw::kvs::internal::Sectors::Find()

NEW

+292

pw::kvs::KeyValueStore::WriteEntry()

NEW

+286

pw::kvs::KeyValueStore::UpdateEntriesToPrimaryFormat()

NEW

+276

pw::kvs::KeyValueStore::FullMaintenanceHelper()

NEW

+256

pw::kvs::KeyValueStore::GetSectorForWrite()

NEW

+256

pw::kvs::internal::Sectors::FindSectorToGarbageCollect()

NEW

+214

pw::kvs::KeyValueStore::RemoveDeletedKeyEntries()

NEW

+208

pw::kvs::internal::Entry::VerifyChecksumInFlash()

NEW

+204

pw::kvs::internal::EntryCache::AddNewOrUpdateExisting()

NEW

+196

pw::kvs::KeyValueStore::GarbageCollectSector()

NEW

+192

pw::kvs::internal::EntryCache::RemoveEntry()

NEW

+184

pw::kvs::KeyValueStore::LoadEntry()

NEW

+180

pw::kvs::KeyValueStore::AppendEntry()

NEW

+170

pw::kvs::KeyValueStore::RelocateEntry()

NEW

+166

pw::AlignedWriter::Write()

NEW

+166

pw::kvs::internal::Entry::CalculateChecksumFromFlash()

NEW

+164

pw::kvs::internal::Entry::Read()

NEW

+160

pw::kvs::internal::Entry::Write()

NEW

+156

pw::kvs::internal::Entry::Copy()

NEW

+154

pw::kvs::KeyValueStore::PutBytes()

NEW

+144

pw::kvs::KeyValueStore::FixedSizeGet()

NEW

+144

pw::kvs::KeyValueStore::FullMaintenanceHelper()::{lambda()#1}::operator()()

NEW

+140

pw::kvs::KeyValueStore::WriteEntryForNewKey()

NEW

+136

pw::kvs::KeyValueStore::CreateEntry()

NEW

+134

pw::kvs::KeyValueStore::CopyEntryToSector()

NEW

+134

pw::kvs::internal::Entry::ValueMatches()

NEW

+130

pw::kvs::KeyValueStore::GetStorageStats()

NEW

+128

pw::kvs::KeyValueStore::AddRedundantEntries()

NEW

+126

pw::kvs::internal::Entry::ReadValue()

NEW

+122

pw::kvs::KeyValueStore::UpdateKeyDescriptor()

NEW

+118

pw::kvs::internal::(anonymous namespace)::Contains<>()

NEW

+116

pw::kvs::KeyValueStore::CreateOrUpdateKeyDescriptor()

NEW

+116

pw::kvs::KeyValueStore::Get()

NEW

+110

pw::kvs::KeyValueStore::CheckForErrors()

NEW

+110

pw::kvs::KeyValueStore::RepairCorruptSectors()

NEW

+108

_GLOBAL__sub_I_working_buffer

NEW

+108

pw::kvs::KeyValueStore::ScanForEntry()

NEW

+104

pw::kvs::KeyValueStore::EnsureEntryRedundancy()

NEW

+104

pw::kvs::KeyValueStore::ReadEntry()

NEW

+98

pw::kvs::internal::Entry::CalculateChecksum()

NEW

+92

pw::kvs::internal::Entry::Entry()

NEW

+88

pw::kvs::KeyValueStore::RelocateKeyAddressesInSector()

NEW

+88

pw::kvs::internal::Entry::VerifyChecksum()

NEW

+78

pw::kvs::KeyValueStore::KeyValueStore()

NEW

+78

pw::kvs::internal::Entry::AddPaddingBytesToChecksum()

NEW

+76

pw::kvs::internal::EntryCache::AddNew()

NEW

+74

pw::AlignedWriter::Flush()

NEW

+72

pw::kvs::KeyValueStore::EnsureFreeSectorExists()

NEW

+70

pw::kvs::KeyValueStore::GetAddressesForWrite()

NEW

+60

pw::kvs::KeyValueStore::FindEntry()

NEW

+58

pw::kvs::KeyValueStore::WriteEntryForExistingKey()

NEW

+56

pw::AlignedWriter::AddBytesToBuffer()

NEW

+56

pw::kvs::KeyValueStore::FixErrors()

NEW

+56

pw::kvs::internal::EntryMetadata::RemoveAddress()

NEW

+52

pw::kvs::internal::EntryCache::Iterator<>::operator*()

NEW

+48

pw::kvs::KeyValueStore::GarbageCollect()

NEW

+48

pw::kvs::internal::EntryMetadata::Reset()

NEW

+44

pw::kvs::ChecksumAlgorithm::Verify()

NEW

+44

pw::kvs::internal::EntryCache::FindIndex()

NEW

+44

pw::kvs::internal::EntryCache::ResetAddresses()

NEW

+42

pw::kvs::FlashPartition::Output::DoWrite()

NEW

+42

pw::kvs::KeyValueStore::FindExisting()

NEW

+42

pw::kvs::internal::Sectors::WearLeveledSectorFromIndex()

NEW

+40

pw::kvs::FlashPartition::AppearsErased()

NEW

+40

pw::kvs::KeyValueStore::Repair()

NEW

+40

pw::kvs::internal::Sectors::AddressInSector()

NEW

+38

pw::kvs::KeyValueStore::ValueSize()

NEW

+38

pw::kvs::internal::EntryCache::addresses()

NEW

+38

pw::kvs::internal::Sectors::FromAddress()

NEW

+38

pw::kvs::internal::Sectors::NextWritableAddress()

NEW

+36

pw::kvs::FlashPartition::Input::DoRead()

NEW

+36

pw::kvs::internal::EntryCache::AddAddressIfRoom()

NEW

+34

pw::kvs::KeyValueStore::CheckWriteOperation()

NEW

+32

memcmp

NEW

+32

pw::kvs::internal::Entry::Update()

NEW

+30

pw::kvs::internal::EntryCache::present_entries()

NEW

+30

pw::kvs::internal::EntryFormats::Find()

NEW

+28

pw::kvs::internal::Entry::ReadKey()

NEW

+28

pw::kvs::internal::Entry::size()

NEW

+26

pw::kvs::ChecksumAlgorithm::Finish()

NEW

+26

pw::kvs::internal::EntryMetadata::AddNewAddress()

NEW

+24

pw::AlignUp()

NEW

+24

pw::kvs::internal::Sectors::BaseAddress()

NEW

+20

pw::Output::Write()

NEW

+20

pw::kvs::ChecksumAlgorithm::Update()

NEW

+12

pw::kvs::FlashPartition::Input

NEW

+12

pw::kvs::FlashPartition::Output

NEW

+8

kvs_format

+10,248

FlashPartition

FLASH

+20

[section .code]

-16

_ctype_

+140

main

NEW

+216

pw::kvs::FakeFlashMemory::Write()

NEW

+168

_GLOBAL__sub_I__ZN2pw3kvs18FlashTestPartitionEv

NEW

+140

pw::kvs::FlashPartition::Write()

NEW

+132

pw::kvs::FlashPartition::IsRegionErased()

NEW

+116

pw::kvs::FlashPartition::Erase()

NEW

+110

pw::kvs::FlashError::Check()

NEW

+100

pw::kvs::FakeFlashMemory::Erase()

NEW

+94

pw::kvs::FakeFlashMemory::Read()

NEW

+80

pw::kvs::FlashPartition::FlashPartition()

NEW

+68

pw::kvs::FlashPartition::Read()

NEW

+64

pw::kvs::FlashPartition::CheckBounds()

NEW

+48

pw::kvs::FakeFlashMemory::FlashAddressToMcuAddress()

NEW

+48

pw::kvs::FakeFlashMemoryBuffer<>

NEW

+48

pw::kvs::FlashPartition

NEW

+28

_GLOBAL__sub_I__ZN2pw3kvs10FlashError5CheckENS_4spanIS1_Lj4294967295EEEmj

NEW

+28

__cxa_atexit

NEW

+24

pw::kvs::FlashPartition::size_bytes()

NEW

+20

pw::kvs::FakeFlashMemoryBuffer<>::~FakeFlashMemoryBuffer()

NEW

+20

pw::kvs::FlashPartition::PartitionToFlashAddress()

NEW

+18

pw::kvs::FlashPartition::~FlashPartition()

NEW

+16

_GLOBAL__sub_I_test_partition

NEW

+16

__wrap_free

NEW

+10

__aeabi_atexit

NEW

+10

operator delete()

NEW

+8

[section .ARM]

NEW

+8

pw::kvs::FlashTestPartition()

NEW

+6

pw::kvs::FakeFlashMemory::Disable()

NEW

+6

pw::kvs::FakeFlashMemory::Enable()

NEW

+6

pw::kvs::FlashMemory::SelfTest()

NEW

+6

pw::kvs::FlashPartition::Init()

NEW

+6

pw::kvs::FlashPartition::sector_size_bytes()

NEW

+4

pw::kvs::FakeFlashMemory::IsEnabled()

NEW

+4

pw::kvs::FlashPartition::sector_count()

+1,820