From d61073783cceec294838dd9913e997bb789402f6 Mon Sep 17 00:00:00 2001 From: Christopher Haster Date: Tue, 25 Jul 2017 13:50:43 -0500 Subject: [PATCH] bd: Added ProfilingBlockDevice for measuring higher-level applications --- .../filesystem/util_block_device/main.cpp | 63 +++++++ .../filesystem/bd/ProfilingBlockDevice.cpp | 105 ++++++++++++ features/filesystem/bd/ProfilingBlockDevice.h | 159 ++++++++++++++++++ 3 files changed, 327 insertions(+) create mode 100644 features/filesystem/bd/ProfilingBlockDevice.cpp create mode 100644 features/filesystem/bd/ProfilingBlockDevice.h diff --git a/features/TESTS/filesystem/util_block_device/main.cpp b/features/TESTS/filesystem/util_block_device/main.cpp index 50867568ac..ede82e6861 100644 --- a/features/TESTS/filesystem/util_block_device/main.cpp +++ b/features/TESTS/filesystem/util_block_device/main.cpp @@ -21,6 +21,7 @@ #include "HeapBlockDevice.h" #include "SlicingBlockDevice.h" #include "ChainingBlockDevice.h" +#include "ProfilingBlockDevice.h" #include using namespace utest::v1; @@ -176,6 +177,67 @@ void test_chaining() { TEST_ASSERT_EQUAL(0, err); } +// Simple test which read/writes blocks on a chain of block devices +void test_profiling() { + HeapBlockDevice bd(BLOCK_COUNT*BLOCK_SIZE, BLOCK_SIZE); + uint8_t *write_block = new uint8_t[BLOCK_SIZE]; + uint8_t *read_block = new uint8_t[BLOCK_SIZE]; + + // Test under profiling + ProfilingBlockDevice profiler(&bd); + + int err = profiler.init(); + TEST_ASSERT_EQUAL(0, err); + + TEST_ASSERT_EQUAL(BLOCK_SIZE, profiler.get_erase_size()); + TEST_ASSERT_EQUAL(BLOCK_COUNT*BLOCK_SIZE, profiler.size()); + + // Fill with random sequence + srand(1); + for (int i = 0; i < BLOCK_SIZE; i++) { + write_block[i] = 0xff & rand(); + } + + // Write, sync, and read the block + err = profiler.erase(0, BLOCK_SIZE); + TEST_ASSERT_EQUAL(0, err); + + err = profiler.program(write_block, 0, BLOCK_SIZE); + TEST_ASSERT_EQUAL(0, err); + + err = profiler.read(read_block, 0, BLOCK_SIZE); + TEST_ASSERT_EQUAL(0, err); + + // Check that the data was unmodified + srand(1); + for (int i = 0; i < BLOCK_SIZE; i++) { + TEST_ASSERT_EQUAL(0xff & rand(), read_block[i]); + } + + // Check with original block device + err = bd.read(read_block, 0, BLOCK_SIZE); + TEST_ASSERT_EQUAL(0, err); + + // Check that the data was unmodified + srand(1); + for (int i = 0; i < BLOCK_SIZE; i++) { + TEST_ASSERT_EQUAL(0xff & rand(), read_block[i]); + } + + delete[] write_block; + delete[] read_block; + err = profiler.deinit(); + TEST_ASSERT_EQUAL(0, err); + + // Check that profiled operations match expectations + bd_size_t read_count = profiler.get_read_count(); + TEST_ASSERT_EQUAL(BLOCK_SIZE, read_count); + bd_size_t program_count = profiler.get_program_count(); + TEST_ASSERT_EQUAL(BLOCK_SIZE, program_count); + bd_size_t erase_count = profiler.get_erase_count(); + TEST_ASSERT_EQUAL(BLOCK_SIZE, erase_count); +} + // Test setup utest::v1::status_t test_setup(const size_t number_of_cases) { @@ -186,6 +248,7 @@ utest::v1::status_t test_setup(const size_t number_of_cases) { Case cases[] = { Case("Testing slicing of a block device", test_slicing), Case("Testing chaining of block devices", test_chaining), + Case("Testing profiling of block devices", test_profiling), }; Specification specification(test_setup, cases); diff --git a/features/filesystem/bd/ProfilingBlockDevice.cpp b/features/filesystem/bd/ProfilingBlockDevice.cpp new file mode 100644 index 0000000000..6baa24cb90 --- /dev/null +++ b/features/filesystem/bd/ProfilingBlockDevice.cpp @@ -0,0 +1,105 @@ +/* mbed Microcontroller Library + * Copyright (c) 2017 ARM Limited + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "ProfilingBlockDevice.h" + + +ProfilingBlockDevice::ProfilingBlockDevice(BlockDevice *bd) + : _bd(bd) + , _read_count(0) + , _program_count(0) + , _erase_count(0) +{ +} + +int ProfilingBlockDevice::init() +{ + return _bd->init(); +} + +int ProfilingBlockDevice::deinit() +{ + return _bd->deinit(); +} + +int ProfilingBlockDevice::read(void *b, bd_addr_t addr, bd_size_t size) +{ + int err = _bd->read(b, addr, size); + if (!err) { + _read_count += size; + } + return err; +} + +int ProfilingBlockDevice::program(const void *b, bd_addr_t addr, bd_size_t size) +{ + int err = _bd->program(b, addr, size); + if (!err) { + _program_count += size; + } + return err; +} + +int ProfilingBlockDevice::erase(bd_addr_t addr, bd_size_t size) +{ + int err = _bd->erase(addr, size); + if (!err) { + _erase_count += size; + } + return err; +} + +bd_size_t ProfilingBlockDevice::get_read_size() const +{ + return _bd->get_read_size(); +} + +bd_size_t ProfilingBlockDevice::get_program_size() const +{ + return _bd->get_program_size(); +} + +bd_size_t ProfilingBlockDevice::get_erase_size() const +{ + return _bd->get_erase_size(); +} + +bd_size_t ProfilingBlockDevice::size() const +{ + return _bd->size(); +} + +void ProfilingBlockDevice::reset() +{ + _read_count = 0; + _program_count = 0; + _erase_count = 0; +} + +bd_size_t ProfilingBlockDevice::get_read_count() const +{ + return _read_count; +} + +bd_size_t ProfilingBlockDevice::get_program_count() const +{ + return _program_count; +} + +bd_size_t ProfilingBlockDevice::get_erase_count() const +{ + return _erase_count; +} diff --git a/features/filesystem/bd/ProfilingBlockDevice.h b/features/filesystem/bd/ProfilingBlockDevice.h new file mode 100644 index 0000000000..9bfa08d33c --- /dev/null +++ b/features/filesystem/bd/ProfilingBlockDevice.h @@ -0,0 +1,159 @@ +/* mbed Microcontroller Library + * Copyright (c) 2017 ARM Limited + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ +#ifndef MBED_PROFILING_BLOCK_DEVICE_H +#define MBED_PROFILING_BLOCK_DEVICE_H + +#include "BlockDevice.h" +#include "mbed.h" + + +/** Block device for measuring storage operations of another block device + * + * @code + * #include "mbed.h" + * #include "HeapBlockDevice.h" + * #include "ProfilingBlockDevice.h" + * + * // Create a heap block device and profiling block device + * HeapBlockDevice mem(64*512, 512); + * ProfilingBlockDevice profiler(&mem); + * + * // do block device work.... + * + * printf("read count: %lld\n", profiler.get_read_count()); + * printf("program count: %lld\n", profiler.get_program_count()); + * printf("erase count: %lld\n", profiler.get_erase_count()); + */ +class ProfilingBlockDevice : public BlockDevice +{ +public: + /** Lifetime of the memory block device + * + * @param bd Block device to back the ProfilingBlockDevice + */ + ProfilingBlockDevice(BlockDevice *bd); + + /** Lifetime of a block device + */ + virtual ~ProfilingBlockDevice() {}; + + /** Initialize a block device + * + * @return 0 on success or a negative error code on failure + * @note The init and deinit functions do not effect profile counts + */ + virtual int init(); + + /** Deinitialize a block device + * + * @return 0 on success or a negative error code on failure + * @note The init and deinit functions do not effect profile counts + */ + virtual int deinit(); + + /** Read blocks from a block device + * + * @param buffer Buffer to read blocks into + * @param addr Address of block to begin reading from + * @param size Size to read in bytes, must be a multiple of read block size + * @return 0 on success, negative error code on failure + */ + virtual int read(void *buffer, bd_addr_t addr, bd_size_t size); + + /** Program blocks to a block device + * + * The blocks must have been erased prior to being programmed + * + * @param buffer Buffer of data to write to blocks + * @param addr Address of block to begin writing to + * @param size Size to write in bytes, must be a multiple of program block size + * @return 0 on success, negative error code on failure + */ + virtual int program(const void *buffer, bd_addr_t addr, bd_size_t size); + + /** Erase blocks on a block device + * + * The state of an erased block is undefined until it has been programmed + * + * @param addr Address of block to begin erasing + * @param size Size to erase in bytes, must be a multiple of erase block size + * @return 0 on success, negative error code on failure + */ + virtual int erase(bd_addr_t addr, bd_size_t size); + + /** Get the size of a readable block + * + * @return Size of a readable block in bytes + */ + virtual bd_size_t get_read_size() const; + + /** Get the size of a programable block + * + * @return Size of a programable block in bytes + * @note Must be a multiple of the read size + */ + virtual bd_size_t get_program_size() const; + + /** Get the size of a eraseable block + * + * @return Size of a eraseable block in bytes + * @note Must be a multiple of the program size + */ + virtual bd_size_t get_erase_size() const; + + /** Get the total size of the underlying device + * + * @return Size of the underlying device in bytes + */ + virtual bd_size_t size() const; + + /** Reset the current profile counts to zero + */ + void reset(); + + /** Get number of bytes that have been read from the block device + * + * @return The number of bytes that have been read from the block device + */ + bd_size_t get_read_count() const; + + /** Get number of bytes that have been programed to the block device + * + * @return The number of bytes that have been programed to the block device + */ + bd_size_t get_program_count() const; + + /** Get number of bytes that have been erased from the block device + * + * @return The number of bytes that have been erased from the block device + */ + bd_size_t get_erase_count() const; + +private: + BlockDevice *_bd; + bd_size_t _read_count; + bd_size_t _program_count; + bd_size_t _erase_count; +}; + + +#endif