245 lines
9.6 KiB
C++
245 lines
9.6 KiB
C++
#ifndef FSFW_STORAGEMANAGER_LOCALPOOL_H_
|
|
#define FSFW_STORAGEMANAGER_LOCALPOOL_H_
|
|
|
|
#include <limits>
|
|
#include <set>
|
|
#include <utility>
|
|
#include <vector>
|
|
|
|
#include "fsfw/internalerror/InternalErrorReporterIF.h"
|
|
#include "fsfw/objectmanager/ObjectManagerIF.h"
|
|
#include "fsfw/objectmanager/SystemObject.h"
|
|
#include "fsfw/serviceinterface/ServiceInterfaceStream.h"
|
|
#include "fsfw/storagemanager/StorageAccessor.h"
|
|
#include "fsfw/storagemanager/StorageManagerIF.h"
|
|
|
|
/**
|
|
* @brief The LocalPool class provides an intermediate data storage with
|
|
* a fixed pool size policy.
|
|
* @details
|
|
* The class implements the StorageManagerIF interface. While the total number
|
|
* of pools is fixed, the element sizes in one pool and the number of pool
|
|
* elements per pool are set on construction. The full amount of memory is
|
|
* allocated on construction.
|
|
* The overhead is 4 byte per pool element to store the size information of
|
|
* each stored element. To maintain an "empty" information, the pool size is
|
|
* limited to 0xFFFF-1 bytes.
|
|
* It is possible to store empty packets in the pool.
|
|
* The local pool is NOT thread-safe.
|
|
*/
|
|
class LocalPool : public SystemObject, public StorageManagerIF {
|
|
public:
|
|
using pool_elem_size_t = size_type;
|
|
using n_pool_elem_t = uint16_t;
|
|
using LocalPoolCfgPair = std::pair<n_pool_elem_t, pool_elem_size_t>;
|
|
|
|
// The configuration needs to be provided with the pool sizes ascending
|
|
// but the number of pool elements as the first value is more intuitive.
|
|
// Therefore, a custom comparator was provided.
|
|
struct LocalPoolConfigCmp {
|
|
bool operator()(const LocalPoolCfgPair& a, const LocalPoolCfgPair& b) const {
|
|
if (a.second < b.second) {
|
|
return true;
|
|
} else if (a.second > b.second) {
|
|
return false;
|
|
} else {
|
|
if (a.first < b.first) {
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
};
|
|
using LocalPoolConfig = std::multiset<LocalPoolCfgPair, LocalPoolConfigCmp>;
|
|
|
|
/**
|
|
* @brief This is the default constructor for a pool manager instance.
|
|
* @details
|
|
* The pool is configured by passing a set of pairs into the constructor.
|
|
* The first value of that pair determines the number of one elements on
|
|
* the respective page of the pool while the second value determines how
|
|
* many elements with that size are created on that page.
|
|
* All regions are to zero on start up.
|
|
* @param setObjectId The object identifier to be set. This allows for
|
|
* multiple instances of LocalPool in the system.
|
|
* @param poolConfig
|
|
* This is a set of pairs to configure the number of pages in the pool,
|
|
* the size of an element on a page, the number of elements on a page
|
|
* and the total size of the pool at once while also implicitely
|
|
* sorting the pairs in the right order.
|
|
* @param registered
|
|
* Determines whether the pool is registered in the object manager or not.
|
|
* @param spillsToHigherPools A variable to determine whether
|
|
* higher n pools are used if the store is full.
|
|
*/
|
|
LocalPool(object_id_t setObjectId, const LocalPoolConfig& poolConfig, bool registered = false,
|
|
bool spillsToHigherPools = false);
|
|
|
|
void setToSpillToHigherPools(bool enable);
|
|
|
|
/**
|
|
* @brief In the LocalPool's destructor all allocated memory is freed.
|
|
*/
|
|
~LocalPool() override;
|
|
|
|
/**
|
|
* Documentation: See StorageManagerIF.h
|
|
*/
|
|
ReturnValue_t addData(store_address_t* storeId, const uint8_t* data, size_t size) override;
|
|
|
|
ReturnValue_t getFreeElement(store_address_t* storeId, size_t size, uint8_t** pData) override;
|
|
|
|
ReturnValue_t getData(store_address_t storeId, const uint8_t** packet_ptr, size_t* size) override;
|
|
|
|
ReturnValue_t modifyData(store_address_t storeId, uint8_t** packet_ptr, size_t* size) override;
|
|
|
|
ReturnValue_t deleteData(store_address_t storeId) override;
|
|
ReturnValue_t deleteData(uint8_t* ptr, size_t size, store_address_t* storeId) override;
|
|
|
|
/**
|
|
* Get the total size of allocated memory for pool data.
|
|
* There is an additional overhead of the sizes of elements which will
|
|
* be assigned to additionalSize
|
|
* @return
|
|
*/
|
|
size_t getTotalSize(size_t* additionalSize) override;
|
|
|
|
/**
|
|
* Get the fill count of the pool. Each character inside the provided
|
|
* buffer will be assigned to a rounded percentage fill count for each
|
|
* page. The last written byte (at the index bytesWritten - 1)
|
|
* will contain the total fill count of the pool as a mean of the
|
|
* percentages of single pages.
|
|
* @param buffer
|
|
* @param maxSize
|
|
*/
|
|
void getFillCount(uint8_t* buffer, uint8_t* bytesWritten) override;
|
|
|
|
void clearStore() override;
|
|
void clearSubPool(max_subpools_t poolIndex) override;
|
|
|
|
ReturnValue_t initialize() override;
|
|
|
|
/**
|
|
* Get number sub pools. Each pool has pages with a specific bucket size.
|
|
* @return
|
|
*/
|
|
[[nodiscard]] max_subpools_t getNumberOfSubPools() const override;
|
|
[[nodiscard]] bool hasDataAtId(store_address_t storeId) const override;
|
|
|
|
// Using functions provided by StorageManagerIF requires either a fully qualified path
|
|
// like for example localPool.StorageManagerIF::getFreeElement(...) or re-exporting
|
|
// the fully qualified path with the using directive.
|
|
using StorageManagerIF::getData;
|
|
using StorageManagerIF::modifyData;
|
|
|
|
protected:
|
|
/**
|
|
* With this helper method, a free element of @c size is reserved.
|
|
* @param size The minimum packet size that shall be reserved.
|
|
* @param[out] address Storage ID of the reserved data.
|
|
* @return - returnvalue::OK on success,
|
|
* - the return codes of #getPoolIndex or #findEmpty otherwise.
|
|
*/
|
|
virtual ReturnValue_t reserveSpace(size_t size, store_address_t* address);
|
|
|
|
private:
|
|
/**
|
|
* @brief This definition generally sets the number of
|
|
* different sized pools. It is derived from the number of pairs
|
|
* inside the LocalPoolConfig set on object creation.
|
|
* @details
|
|
* This must be less than the maximum number of pools (currently 0xff).
|
|
*/
|
|
const max_subpools_t NUMBER_OF_SUBPOOLS;
|
|
|
|
/**
|
|
* Indicates that this element is free.
|
|
* This value limits the maximum size of a pool.
|
|
* Change to larger data type if increase is required.
|
|
*/
|
|
static const size_type STORAGE_FREE = std::numeric_limits<size_type>::max();
|
|
/**
|
|
* @brief In this array, the element sizes of each pool is stored.
|
|
* @details The sizes are maintained for internal pool management. The sizes
|
|
* must be set in ascending order on construction.
|
|
*/
|
|
std::vector<size_type> elementSizes = std::vector<size_type>(NUMBER_OF_SUBPOOLS);
|
|
/**
|
|
* @brief n_elements stores the number of elements per pool.
|
|
* @details These numbers are maintained for internal pool management.
|
|
*/
|
|
std::vector<uint16_t> numberOfElements = std::vector<uint16_t>(NUMBER_OF_SUBPOOLS);
|
|
/**
|
|
* @brief store represents the actual memory pool.
|
|
* @details It is an array of pointers to memory, which was allocated with
|
|
* a @c new call on construction.
|
|
*/
|
|
std::vector<std::vector<uint8_t>> store = std::vector<std::vector<uint8_t>>(NUMBER_OF_SUBPOOLS);
|
|
|
|
/**
|
|
* @brief The size_list attribute stores the size values of every pool element.
|
|
* @details As the number of elements is determined on construction, the size list
|
|
* is also dynamically allocated there.
|
|
*/
|
|
std::vector<std::vector<size_type>> sizeLists =
|
|
std::vector<std::vector<size_type>>(NUMBER_OF_SUBPOOLS);
|
|
|
|
bool ignoreFault = false;
|
|
|
|
//! A variable to determine whether higher n pools are used if
|
|
//! the store is full.
|
|
bool spillsToHigherPools = false;
|
|
/**
|
|
* @brief This method safely stores the given data in the given packet_id.
|
|
* @details It also sets the size in size_list. The method does not perform
|
|
* any range checks, these are done in advance.
|
|
* @param packet_id The storage identifier in which the data shall be stored.
|
|
* @param data The data to be stored.
|
|
* @param size The size of the data to be stored.
|
|
*/
|
|
void write(store_address_t packetId, const uint8_t* data, size_t size);
|
|
/**
|
|
* @brief A helper method to read the element size of a certain pool.
|
|
* @param pool_index The pool in which to look.
|
|
* @return Returns the size of an element or 0.
|
|
*/
|
|
size_type getSubpoolElementSize(max_subpools_t subpoolIndex);
|
|
|
|
/**
|
|
* @brief This helper method looks up a fitting pool for a given size.
|
|
* @details The pools are looked up in ascending order, so the first that
|
|
* fits is used.
|
|
* @param packet_size The size of the data to be stored.
|
|
* @param[out] poolIndex The fitting pool index found.
|
|
* @return - @c returnvalue::OK on success,
|
|
* - @c DATA_TOO_LARGE otherwise.
|
|
*/
|
|
ReturnValue_t getSubPoolIndex(size_t packetSize, uint16_t* subpoolIndex,
|
|
uint16_t startAtIndex = 0);
|
|
/**
|
|
* @brief This helper method calculates the true array position in store
|
|
* of a given packet id.
|
|
* @details The method does not perform any range checks, these are done in
|
|
* advance.
|
|
* @param packet_id The packet id to look up.
|
|
* @return Returns the position of the data in store.
|
|
*/
|
|
size_type getRawPosition(store_address_t storeId);
|
|
/**
|
|
* @brief This is a helper method to find an empty element in a given pool.
|
|
* @details The method searches size_list for the first empty element, so
|
|
* duration grows with the fill level of the pool.
|
|
* @param pool_index The pool in which the search is performed.
|
|
* @param[out] element The first found element in the pool.
|
|
* @return - returnvalue::OK on success,
|
|
* - #DATA_STORAGE_FULL if the store is full
|
|
*/
|
|
ReturnValue_t findEmpty(n_pool_elem_t poolIndex, uint16_t* element);
|
|
|
|
InternalErrorReporterIF* internalErrorReporter = nullptr;
|
|
};
|
|
|
|
#endif /* FSFW_STORAGEMANAGER_LOCALPOOL_H_ */
|