#ifndef FSFW_STORAGEMANAGER_LOCALPOOL_H_ #define FSFW_STORAGEMANAGER_LOCALPOOL_H_ #include "StorageManagerIF.h" #include "../objectmanager/SystemObject.h" #include "../objectmanager/ObjectManagerIF.h" #include "../serviceinterface/ServiceInterfaceStream.h" #include "../internalError/InternalErrorReporterIF.h" #include "../storagemanager/StorageAccessor.h" #include #include #include #include /** * @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 size_type = size_t; using poolElementSize = size_type; using numberPoolElements = uint16_t; using LocalPoolCfgPair = std::pair; using LocalPoolConfig = std::multiset; /** * @brief This definition generally sets the number of different sized pools. * @details This must be less than the maximum number of pools (currently 0xff). */ const uint8_t NUMBER_OF_POOLS; /** * @brief This is the default constructor for a pool manager instance. * @details By passing two arrays of size NUMBER_OF_POOLS, the constructor * allocates memory (with @c new) for store and size_list. These * regions are all set to zero on start up. * @param setObjectId The object identifier to be set. This allows for * multiple instances of LocalPool in the system. * @param element_sizes An array of size NUMBER_OF_POOLS in which the size * of a single element in each pool is determined. * The sizes must be provided in ascending order. * * @param n_elements An array of size NUMBER_OF_POOLS in which the * number of elements for each pool is determined. * The position of these values correspond to those in * element_sizes. * @param registered Register the pool in object manager or not. * Default is false (local pool). * @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); /** * @brief In the LocalPool's destructor all allocated memory is freed. */ virtual ~LocalPool(void); /** * Documentation: See StorageManagerIF.h */ ReturnValue_t addData(store_address_t* storeId, const uint8_t * data, size_t size, bool ignoreFault = false) override; ReturnValue_t getFreeElement(store_address_t* storeId,const size_t size, uint8_t** pData, bool ignoreFault = false) override; ConstAccessorPair getData(store_address_t storeId) override; ReturnValue_t getData(store_address_t storeId, ConstStorageAccessor& constAccessor) override; ReturnValue_t getData(store_address_t storeId, const uint8_t** packet_ptr, size_t * size) override; AccessorPair modifyData(store_address_t storeId) override; ReturnValue_t modifyData(store_address_t storeId, StorageAccessor& storeAccessor) override; ReturnValue_t modifyData(store_address_t storeId, uint8_t** packet_ptr, size_t * size) override; virtual ReturnValue_t deleteData(store_address_t storeId) override; virtual ReturnValue_t deleteData(uint8_t* ptr, size_t size, store_address_t* storeId = nullptr) override; void clearStore() override; ReturnValue_t initialize() override; 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 - #RETURN_OK on success, * - the return codes of #getPoolIndex or #findEmpty otherwise. */ virtual ReturnValue_t reserveSpace(const size_t size, store_address_t* address, bool ignoreFault); private: /** * 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::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 elementSizes = std::vector(NUMBER_OF_POOLS); /** * @brief n_elements stores the number of elements per pool. * @details These numbers are maintained for internal pool management. */ std::vector numberOfElements = std::vector(NUMBER_OF_POOLS); /** * @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> store = std::vector>(NUMBER_OF_POOLS); /** * @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> sizeLists = std::vector>(NUMBER_OF_POOLS); //! 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 getPageSize(uint16_t poolIndex); /** * @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. * @return Returns the pool that fits or StorageManagerIF::INVALID_ADDRESS. */ /** * @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 - #RETURN_OK on success, * - #DATA_TOO_LARGE otherwise. */ ReturnValue_t getPoolIndex(size_t packetSize, uint16_t* poolIndex, 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 - #RETURN_OK on success, * - #DATA_STORAGE_FULL if the store is full */ ReturnValue_t findEmpty(uint16_t poolIndex, uint16_t* element); InternalErrorReporterIF *internalErrorReporter = nullptr; }; #endif /* FSFW_STORAGEMANAGER_LOCALPOOL_H_ */