Today's the day. Renamed platform to framework.
This commit is contained in:
Bastian Baetz
419
storagemanager/LocalPool.h
Normal file
419
storagemanager/LocalPool.h
Normal file
@ -0,0 +1,419 @@
|
||||
/*
|
||||
* LocalPool.h
|
||||
*
|
||||
* Created on: 11.02.2015
|
||||
* Author: baetz
|
||||
*/
|
||||
|
||||
#ifndef FRAMEWORK_STORAGEMANAGER_LOCALPOOL_H_
|
||||
#define FRAMEWORK_STORAGEMANAGER_LOCALPOOL_H_
|
||||
|
||||
/**
|
||||
* @file LocalPool
|
||||
*
|
||||
* @date 02.02.2012
|
||||
* @author Bastian Baetz
|
||||
*
|
||||
* @brief This file contains the definition of the LocalPool class.
|
||||
*/
|
||||
|
||||
#include <framework/objectmanager/SystemObject.h>
|
||||
#include <framework/serviceinterface/ServiceInterfaceStream.h>
|
||||
#include <framework/storagemanager/StorageManagerIF.h>
|
||||
#include <string.h>
|
||||
//TODO: Debugging.. remove!
|
||||
//#include <config/objects/translateObjects.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.
|
||||
*/
|
||||
|
||||
template<uint8_t NUMBER_OF_POOLS = 5>
|
||||
class LocalPool: public SystemObject, public StorageManagerIF {
|
||||
public:
|
||||
/**
|
||||
* @brief This definition generally sets the number of different sized pools.
|
||||
* @details This must be less than the maximum number of pools (currently 0xff).
|
||||
*/
|
||||
// static const uint32_t NUMBER_OF_POOLS;
|
||||
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 uint32_t STORAGE_FREE = 0xFFFFFFFF;
|
||||
/**
|
||||
* @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.
|
||||
*/
|
||||
uint32_t element_sizes[NUMBER_OF_POOLS];
|
||||
/**
|
||||
* @brief n_elements stores the number of elements per pool.
|
||||
* @details These numbers are maintained for internal pool management.
|
||||
*/
|
||||
uint16_t n_elements[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.
|
||||
*/
|
||||
uint8_t* store[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.
|
||||
*/
|
||||
uint32_t* size_list[NUMBER_OF_POOLS];
|
||||
bool spillsToHigherPools; //!< A variable to determine whether higher n pools are used if the store is full.
|
||||
/**
|
||||
* @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 packet_id, const uint8_t* data, uint32_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.
|
||||
*/
|
||||
uint32_t getPageSize(uint16_t pool_index);
|
||||
/**
|
||||
* @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(uint32_t packet_size, 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.
|
||||
*/
|
||||
uint32_t getRawPosition(store_address_t packet_id);
|
||||
/**
|
||||
* With this helper method, a free element of \c size is reserved.
|
||||
*
|
||||
* @param size The minimum packet size that shall be reserved.
|
||||
* @return Returns the storage identifier within the storage or
|
||||
* StorageManagerIF::INVALID_ADDRESS (in raw).
|
||||
*/
|
||||
/**
|
||||
* 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.
|
||||
*/
|
||||
ReturnValue_t reserveSpace(const uint32_t size, store_address_t* address);
|
||||
protected:
|
||||
/**
|
||||
* @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
|
||||
*/
|
||||
virtual ReturnValue_t findEmpty(uint16_t pool_index, uint16_t* element);
|
||||
public:
|
||||
/**
|
||||
* @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.
|
||||
* <b>The sizes must be provided in ascending order.
|
||||
* </b>
|
||||
* @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).
|
||||
*/
|
||||
LocalPool(object_id_t setObjectId,
|
||||
const uint16_t element_sizes[NUMBER_OF_POOLS],
|
||||
const uint16_t n_elements[NUMBER_OF_POOLS],
|
||||
bool registered = false,
|
||||
bool spillsToHigherPools = false);
|
||||
/**
|
||||
* @brief In the LocalPool's destructor all allocated memory is freed.
|
||||
*/
|
||||
virtual ~LocalPool(void);
|
||||
ReturnValue_t addData(store_address_t* storageId, const uint8_t * data,
|
||||
uint32_t size);
|
||||
|
||||
ReturnValue_t getFreeElement(store_address_t* storageId,
|
||||
const uint32_t size, uint8_t** p_data);
|
||||
ReturnValue_t getData(store_address_t packet_id, const uint8_t** packet_ptr,
|
||||
uint32_t* size);
|
||||
ReturnValue_t modifyData(store_address_t packet_id, uint8_t** packet_ptr,
|
||||
uint32_t* size);
|
||||
virtual ReturnValue_t deleteData(store_address_t);
|
||||
virtual ReturnValue_t deleteData(uint8_t* ptr, uint32_t size,
|
||||
store_address_t* storeId = NULL);
|
||||
void clearStore();
|
||||
ReturnValue_t initialize();
|
||||
};
|
||||
|
||||
template<uint8_t NUMBER_OF_POOLS>
|
||||
inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::findEmpty(uint16_t pool_index,
|
||||
uint16_t* element) {
|
||||
ReturnValue_t status = DATA_STORAGE_FULL;
|
||||
for (uint16_t foundElement = 0; foundElement < n_elements[pool_index];
|
||||
foundElement++) {
|
||||
if (size_list[pool_index][foundElement] == STORAGE_FREE) {
|
||||
*element = foundElement;
|
||||
status = RETURN_OK;
|
||||
break;
|
||||
}
|
||||
}
|
||||
return status;
|
||||
}
|
||||
|
||||
template<uint8_t NUMBER_OF_POOLS>
|
||||
inline void LocalPool<NUMBER_OF_POOLS>::write(store_address_t packet_id,
|
||||
const uint8_t* data, uint32_t size) {
|
||||
uint8_t* ptr;
|
||||
uint32_t packet_position = getRawPosition(packet_id);
|
||||
|
||||
//check size? -> Not necessary, because size is checked before calling this function.
|
||||
ptr = &store[packet_id.pool_index][packet_position];
|
||||
memcpy(ptr, data, size);
|
||||
size_list[packet_id.pool_index][packet_id.packet_index] = size;
|
||||
}
|
||||
|
||||
//Returns page size of 0 in case store_index is illegal
|
||||
template<uint8_t NUMBER_OF_POOLS>
|
||||
inline uint32_t LocalPool<NUMBER_OF_POOLS>::getPageSize(uint16_t pool_index) {
|
||||
if (pool_index < NUMBER_OF_POOLS) {
|
||||
return element_sizes[pool_index];
|
||||
} else {
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
template<uint8_t NUMBER_OF_POOLS>
|
||||
inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::getPoolIndex(
|
||||
uint32_t packet_size, uint16_t* poolIndex, uint16_t startAtIndex) {
|
||||
for (uint16_t n = startAtIndex; n < NUMBER_OF_POOLS; n++) {
|
||||
// debug << "LocalPool " << getObjectId() << "::getPoolIndex: Pool: " << n << ", Element Size: " << element_sizes[n] << std::endl;
|
||||
if (element_sizes[n] >= packet_size) {
|
||||
*poolIndex = n;
|
||||
return RETURN_OK;
|
||||
}
|
||||
}
|
||||
return DATA_TOO_LARGE;
|
||||
}
|
||||
|
||||
template<uint8_t NUMBER_OF_POOLS>
|
||||
inline uint32_t LocalPool<NUMBER_OF_POOLS>::getRawPosition(
|
||||
store_address_t packet_id) {
|
||||
return packet_id.packet_index * element_sizes[packet_id.pool_index];
|
||||
}
|
||||
|
||||
template<uint8_t NUMBER_OF_POOLS>
|
||||
inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::reserveSpace(
|
||||
const uint32_t size, store_address_t* address) {
|
||||
ReturnValue_t status = getPoolIndex(size, &address->pool_index);
|
||||
if (status != RETURN_OK) {
|
||||
error << "LocalPool( " << std::hex << getObjectId() << std::dec
|
||||
<< " )::reserveSpace: Packet too large." << std::endl;
|
||||
}
|
||||
status = findEmpty(address->pool_index, &address->packet_index);
|
||||
while (status != RETURN_OK && spillsToHigherPools) {
|
||||
status = getPoolIndex(size, &address->pool_index, address->pool_index + 1);
|
||||
if (status != RETURN_OK) {
|
||||
//We don't find any fitting pool anymore.
|
||||
break;
|
||||
}
|
||||
status = findEmpty(address->pool_index, &address->packet_index);
|
||||
}
|
||||
if (status == RETURN_OK) {
|
||||
// debug << "LocalPool( " << translateObject(getObjectId()) << " )::reserveSpace: Empty position found: Position: Pool: " << address->pool_index << " Index: " << address->packet_index << std::endl;
|
||||
size_list[address->pool_index][address->packet_index] = size;
|
||||
} else {
|
||||
error << "LocalPool( " << std::hex << getObjectId() << std::dec
|
||||
<< " )::reserveSpace: Packet store is full." << std::endl;
|
||||
}
|
||||
return status;
|
||||
}
|
||||
|
||||
template<uint8_t NUMBER_OF_POOLS>
|
||||
inline LocalPool<NUMBER_OF_POOLS>::LocalPool(object_id_t setObjectId,
|
||||
const uint16_t element_sizes[NUMBER_OF_POOLS],
|
||||
const uint16_t n_elements[NUMBER_OF_POOLS], bool registered, bool spillsToHigherPools) :
|
||||
SystemObject(setObjectId, registered), spillsToHigherPools(spillsToHigherPools) {
|
||||
for (uint16_t n = 0; n < NUMBER_OF_POOLS; n++) {
|
||||
this->element_sizes[n] = element_sizes[n];
|
||||
this->n_elements[n] = n_elements[n];
|
||||
store[n] = new uint8_t[n_elements[n] * element_sizes[n]];
|
||||
size_list[n] = new uint32_t[n_elements[n]];
|
||||
memset(store[n], 0x00, (n_elements[n] * element_sizes[n]));
|
||||
memset(size_list[n], STORAGE_FREE, (n_elements[n] * sizeof(**size_list))); //TODO checkme
|
||||
}
|
||||
}
|
||||
|
||||
template<uint8_t NUMBER_OF_POOLS>
|
||||
inline LocalPool<NUMBER_OF_POOLS>::~LocalPool(void) {
|
||||
for (uint16_t n = 0; n < NUMBER_OF_POOLS; n++) {
|
||||
delete[] store[n];
|
||||
delete[] size_list[n];
|
||||
}
|
||||
}
|
||||
|
||||
template<uint8_t NUMBER_OF_POOLS>
|
||||
inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::addData(
|
||||
store_address_t* storageId, const uint8_t* data, uint32_t size) {
|
||||
ReturnValue_t status = reserveSpace(size, storageId);
|
||||
if (status == RETURN_OK) {
|
||||
write(*storageId, data, size);
|
||||
}
|
||||
return status;
|
||||
}
|
||||
|
||||
template<uint8_t NUMBER_OF_POOLS>
|
||||
inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::getFreeElement(
|
||||
store_address_t* storageId, const uint32_t size, uint8_t** p_data) {
|
||||
ReturnValue_t status = reserveSpace(size, storageId);
|
||||
if (status == RETURN_OK) {
|
||||
*p_data = &store[storageId->pool_index][getRawPosition(*storageId)];
|
||||
} else {
|
||||
*p_data = NULL;
|
||||
}
|
||||
return status;
|
||||
}
|
||||
|
||||
template<uint8_t NUMBER_OF_POOLS>
|
||||
inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::getData(
|
||||
store_address_t packet_id, const uint8_t** packet_ptr, uint32_t* size) {
|
||||
uint8_t* tempData = NULL;
|
||||
ReturnValue_t status = modifyData(packet_id, &tempData, size);
|
||||
*packet_ptr = tempData;
|
||||
return status;
|
||||
}
|
||||
|
||||
template<uint8_t NUMBER_OF_POOLS>
|
||||
inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::modifyData(store_address_t packet_id,
|
||||
uint8_t** packet_ptr, uint32_t* size) {
|
||||
ReturnValue_t status = RETURN_FAILED;
|
||||
if ((packet_id.packet_index < n_elements[packet_id.pool_index])
|
||||
&& (packet_id.pool_index < NUMBER_OF_POOLS)) {
|
||||
if (size_list[packet_id.pool_index][packet_id.packet_index]
|
||||
!= STORAGE_FREE) {
|
||||
uint32_t packet_position = getRawPosition(packet_id);
|
||||
*packet_ptr = &store[packet_id.pool_index][packet_position];
|
||||
*size = size_list[packet_id.pool_index][packet_id.packet_index];
|
||||
status = RETURN_OK;
|
||||
} else {
|
||||
status = DATA_DOES_NOT_EXIST;
|
||||
}
|
||||
} else {
|
||||
status = ILLEGAL_STORAGE_ID;
|
||||
}
|
||||
return status;
|
||||
}
|
||||
|
||||
template<uint8_t NUMBER_OF_POOLS>
|
||||
inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::deleteData(
|
||||
store_address_t packet_id) {
|
||||
// debug << "LocalPool( " << translateObject(getObjectId()) << " )::deleteData from store " << packet_id.pool_index << ". id is " << packet_id.packet_index << std::endl;
|
||||
ReturnValue_t status = RETURN_OK;
|
||||
uint32_t page_size = getPageSize(packet_id.pool_index);
|
||||
if ((page_size != 0)
|
||||
&& (packet_id.packet_index < n_elements[packet_id.pool_index])) {
|
||||
uint16_t packet_position = getRawPosition(packet_id);
|
||||
uint8_t* ptr = &store[packet_id.pool_index][packet_position];
|
||||
memset(ptr, 0, page_size);
|
||||
//Set free list
|
||||
size_list[packet_id.pool_index][packet_id.packet_index] = STORAGE_FREE;
|
||||
} else {
|
||||
//packet_index is too large
|
||||
error << "LocalPool:deleteData failed." << std::endl;
|
||||
status = ILLEGAL_STORAGE_ID;
|
||||
}
|
||||
return status;
|
||||
}
|
||||
|
||||
template<uint8_t NUMBER_OF_POOLS>
|
||||
inline void LocalPool<NUMBER_OF_POOLS>::clearStore() {
|
||||
for (uint16_t n = 0; n < NUMBER_OF_POOLS; n++) {
|
||||
memset(size_list[n], STORAGE_FREE, (n_elements[n] * sizeof(**size_list)));//TODO checkme
|
||||
}
|
||||
}
|
||||
|
||||
template<uint8_t NUMBER_OF_POOLS>
|
||||
inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::deleteData(uint8_t* ptr,
|
||||
uint32_t size, store_address_t* storeId) {
|
||||
store_address_t localId;
|
||||
ReturnValue_t result = ILLEGAL_ADDRESS;
|
||||
for (uint16_t n = 0; n < NUMBER_OF_POOLS; n++) {
|
||||
//Not sure if new allocates all stores in order. so better be careful.
|
||||
if ((store[n] <= ptr) && (&store[n][n_elements[n]*element_sizes[n]]) > ptr) {
|
||||
localId.pool_index = n;
|
||||
uint32_t deltaAddress = (uint32_t) ptr - (uint32_t) store[n];
|
||||
//Getting any data from the right "block" is ok. This is necessary, as IF's sometimes don't point to the first element of an object.
|
||||
localId.packet_index = deltaAddress / element_sizes[n];
|
||||
result = deleteData(localId);
|
||||
// if (deltaAddress % element_sizes[n] != 0) {
|
||||
// error << "Pool::deleteData: address not aligned!" << std::endl;
|
||||
// }
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (storeId != NULL) {
|
||||
*storeId = localId;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
template<uint8_t NUMBER_OF_POOLS>
|
||||
inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::initialize() {
|
||||
ReturnValue_t result = SystemObject::initialize();
|
||||
if (result != RETURN_OK) {
|
||||
return result;
|
||||
}
|
||||
//Check if any pool size is large than the maximum allowed.
|
||||
for (uint8_t count = 0; count < NUMBER_OF_POOLS; count++) {
|
||||
if (element_sizes[count] >= STORAGE_FREE) {
|
||||
error
|
||||
<< "LocalPool::initialize: Pool is too large! Max. allowed size is: "
|
||||
<< (STORAGE_FREE - 1) << std::endl;
|
||||
return RETURN_FAILED;
|
||||
}
|
||||
}
|
||||
return RETURN_OK;
|
||||
}
|
||||
|
||||
#endif /* FRAMEWORK_STORAGEMANAGER_LOCALPOOL_H_ */
|
||||
22
storagemanager/Makefile
Executable file
22
storagemanager/Makefile
Executable file
@ -0,0 +1,22 @@
|
||||
#!/bin/bash
|
||||
#
|
||||
# OSAL makefile
|
||||
#
|
||||
# Created on: Mar 04, 2010
|
||||
# Author: ziemke
|
||||
# Author: Claas Ziemke
|
||||
# Copyright 2010, Claas Ziemke <claas.ziemke@gmx.net>
|
||||
#
|
||||
|
||||
BASEDIR=../../
|
||||
include $(BASEDIR)options.mk
|
||||
|
||||
OBJ = $(BUILDDIR)/TmTcStorage.o
|
||||
|
||||
all: $(OBJ)
|
||||
|
||||
$(BUILDDIR)/%.o: %.cpp %.h
|
||||
$(CPP) $(CFLAGS) $(DEFINES) $(CCOPT) ${INCLUDE} -c $< -o $@
|
||||
|
||||
clean:
|
||||
$(RM) *.o *.gcno *.gcda
|
||||
121
storagemanager/PoolManager.h
Normal file
121
storagemanager/PoolManager.h
Normal file
@ -0,0 +1,121 @@
|
||||
/**
|
||||
* @file PoolManager
|
||||
*
|
||||
* @date 02.02.2012
|
||||
* @author Bastian Baetz
|
||||
*
|
||||
* @brief This file contains the definition of the PoolManager class.
|
||||
*/
|
||||
|
||||
#ifndef POOLMANAGER_H_
|
||||
#define POOLMANAGER_H_
|
||||
|
||||
|
||||
#include <framework/osal/OSAL.h>
|
||||
#include <framework/storagemanager/LocalPool.h>
|
||||
|
||||
/**
|
||||
* @brief The PoolManager class provides an intermediate data storage with
|
||||
* a fixed pool size policy for inter-process communication.
|
||||
* \details Uses local pool, but is thread-safe.
|
||||
*/
|
||||
|
||||
template <uint8_t NUMBER_OF_POOLS = 5>
|
||||
class PoolManager : public LocalPool<NUMBER_OF_POOLS> {
|
||||
protected:
|
||||
/**
|
||||
* Overwritten for thread safety.
|
||||
* Locks during execution.
|
||||
*/
|
||||
ReturnValue_t findEmpty( uint16_t pool_index, uint16_t* element );
|
||||
/**
|
||||
* \brief The mutex is created in the constructor and makes access mutual exclusive.
|
||||
* \details Locking and unlocking is done during searching for free slots and deleting existing slots.
|
||||
*/
|
||||
MutexId_t* mutex;
|
||||
public:
|
||||
PoolManager( object_id_t setObjectId, const uint16_t element_sizes[NUMBER_OF_POOLS], const uint16_t n_elements[NUMBER_OF_POOLS] );
|
||||
/**
|
||||
* @brief In the PoolManager's destructor all allocated memory is freed.
|
||||
*/
|
||||
virtual ~PoolManager( void );
|
||||
/**
|
||||
* Overwritten for thread safety.
|
||||
*/
|
||||
virtual ReturnValue_t deleteData(store_address_t);
|
||||
virtual ReturnValue_t deleteData(uint8_t* buffer, uint32_t size, store_address_t* storeId = NULL);
|
||||
};
|
||||
|
||||
template<uint8_t NUMBER_OF_POOLS>
|
||||
inline ReturnValue_t PoolManager<NUMBER_OF_POOLS>::findEmpty(uint16_t pool_index,
|
||||
uint16_t* element) {
|
||||
ReturnValue_t mutexStatus = OSAL::lockMutex( mutex, OSAL::NO_TIMEOUT );
|
||||
ReturnValue_t status = this->DATA_STORAGE_FULL;
|
||||
if ( mutexStatus == this->RETURN_OK ) {
|
||||
status = LocalPool<NUMBER_OF_POOLS>::findEmpty(pool_index, element);
|
||||
} else {
|
||||
error << "PoolManager::findEmpty: Mutex could not be acquired. Error code: " << status << std::endl;
|
||||
}
|
||||
mutexStatus = OSAL::unlockMutex( mutex );
|
||||
if (mutexStatus != this->RETURN_OK) {
|
||||
return mutexStatus;
|
||||
} else {
|
||||
return status;
|
||||
}
|
||||
}
|
||||
|
||||
template<uint8_t NUMBER_OF_POOLS>
|
||||
inline PoolManager<NUMBER_OF_POOLS>::PoolManager(object_id_t setObjectId,
|
||||
const uint16_t element_sizes[NUMBER_OF_POOLS],
|
||||
const uint16_t n_elements[NUMBER_OF_POOLS]) : LocalPool<NUMBER_OF_POOLS>(setObjectId, element_sizes, n_elements, true) {
|
||||
mutex = new MutexId_t;
|
||||
ReturnValue_t result = OSAL::createMutex( OSAL::buildName('M','T','X','1'), ( mutex ) );
|
||||
if (result != this->RETURN_OK) {
|
||||
error << "PoolManager( " << std::hex << this->getObjectId() << std::dec << " )::ctor: Creating mutex failed." << std::endl;
|
||||
}
|
||||
}
|
||||
|
||||
template<uint8_t NUMBER_OF_POOLS>
|
||||
inline PoolManager<NUMBER_OF_POOLS>::~PoolManager(void) {
|
||||
OSAL::deleteMutex( mutex );
|
||||
delete mutex;
|
||||
}
|
||||
|
||||
template<uint8_t NUMBER_OF_POOLS>
|
||||
inline ReturnValue_t PoolManager<NUMBER_OF_POOLS>::deleteData(
|
||||
store_address_t packet_id) {
|
||||
// debug << "PoolManager( " << translateObject(getObjectId()) << " )::deleteData from store " << packet_id.pool_index << ". id is " << packet_id.packet_index << std::endl;
|
||||
ReturnValue_t mutexStatus = OSAL::lockMutex( mutex, OSAL::NO_TIMEOUT );
|
||||
ReturnValue_t status = this->RETURN_OK;
|
||||
if ( mutexStatus == this->RETURN_OK ) {
|
||||
LocalPool<NUMBER_OF_POOLS>::deleteData(packet_id);
|
||||
} else {
|
||||
error << "PoolManager:deleteData: Mutex could not be acquired. Error code: " << status << std::endl;
|
||||
}
|
||||
mutexStatus = OSAL::unlockMutex( mutex );
|
||||
if (mutexStatus != this->RETURN_OK) {
|
||||
return mutexStatus;
|
||||
} else {
|
||||
return status;
|
||||
}
|
||||
}
|
||||
|
||||
template<uint8_t NUMBER_OF_POOLS>
|
||||
inline ReturnValue_t PoolManager<NUMBER_OF_POOLS>::deleteData(uint8_t* buffer, uint32_t size,
|
||||
store_address_t* storeId) {
|
||||
ReturnValue_t mutexStatus = OSAL::lockMutex( mutex, OSAL::NO_TIMEOUT );
|
||||
ReturnValue_t status = this->RETURN_OK;
|
||||
if ( mutexStatus == this->RETURN_OK ) {
|
||||
LocalPool<NUMBER_OF_POOLS>::deleteData(buffer, size, storeId);
|
||||
} else {
|
||||
error << "PoolManager:deleteData: Mutex could not be acquired. Error code: " << status << std::endl;
|
||||
}
|
||||
mutexStatus = OSAL::unlockMutex( mutex );
|
||||
if (mutexStatus != this->RETURN_OK) {
|
||||
return mutexStatus;
|
||||
} else {
|
||||
return status;
|
||||
}
|
||||
}
|
||||
|
||||
#endif /* POOLMANAGER_H_ */
|
||||
158
storagemanager/StorageManagerIF.h
Normal file
158
storagemanager/StorageManagerIF.h
Normal file
@ -0,0 +1,158 @@
|
||||
#ifndef STORAGEMANAGERIF_H_H
|
||||
#define STORAGEMANAGERIF_H_H
|
||||
|
||||
#include <framework/events/Event.h>
|
||||
#include <framework/returnvalues/HasReturnvaluesIF.h>
|
||||
#include <stddef.h>
|
||||
|
||||
//TODO: Check setting and returning of store sizes.
|
||||
|
||||
/**
|
||||
* This union defines the type that identifies where a data packet is stored in the store.
|
||||
* It comprises of a raw part to read it as raw value and a structured part to use it in
|
||||
* pool-like stores.
|
||||
*/
|
||||
union store_address_t {
|
||||
/**
|
||||
* Default Constructor, initializing to INVALID_ADDRESS
|
||||
*/
|
||||
store_address_t():raw(0xFFFFFFFF){}
|
||||
/**
|
||||
* Constructor to create an address object using the raw address
|
||||
*
|
||||
* @param rawAddress
|
||||
*/
|
||||
store_address_t(uint32_t rawAddress):raw(rawAddress){}
|
||||
|
||||
/**
|
||||
* Constructor to create an address object using pool
|
||||
* and packet indices
|
||||
*
|
||||
* @param poolIndex
|
||||
* @param packetIndex
|
||||
*/
|
||||
store_address_t(uint16_t poolIndex, uint16_t packetIndex):
|
||||
pool_index(poolIndex),packet_index(packetIndex){}
|
||||
/**
|
||||
* A structure with two elements to access the store address pool-like.
|
||||
*/
|
||||
struct {
|
||||
/**
|
||||
* The index in which pool the packet lies.
|
||||
*/
|
||||
uint16_t pool_index;
|
||||
/**
|
||||
* The position in the chosen pool.
|
||||
*/
|
||||
uint16_t packet_index;
|
||||
};
|
||||
/**
|
||||
* Alternative access to the raw value.
|
||||
*/
|
||||
uint32_t raw;
|
||||
};
|
||||
|
||||
/**
|
||||
* @brief This class provides an interface for intermediate data storage.
|
||||
* @details The Storage manager classes shall be used to store larger chunks of
|
||||
* data in RAM for exchange between tasks. This interface expects the
|
||||
* data to be stored in one consecutive block of memory, so tasks can
|
||||
* write directly to the destination pointer.
|
||||
* For interprocess communication, the stores must be locked during
|
||||
* insertion and deletion. If the receiving storage identifier is
|
||||
* passed token-like between tasks, a lock during read and write
|
||||
* operations is not necessary.
|
||||
* @author Bastian Baetz
|
||||
* @date 18.09.2012
|
||||
*/
|
||||
class StorageManagerIF : public HasReturnvaluesIF {
|
||||
public:
|
||||
static const uint8_t INTERFACE_ID = STORAGE_MANAGER_IF; //!< The unique ID for return codes for this interface.
|
||||
static const ReturnValue_t DATA_TOO_LARGE = MAKE_RETURN_CODE(1); //!< This return code indicates that the data to be stored is too large for the store.
|
||||
static const ReturnValue_t DATA_STORAGE_FULL = MAKE_RETURN_CODE(2); //!< This return code indicates that a data storage is full.
|
||||
static const ReturnValue_t ILLEGAL_STORAGE_ID = MAKE_RETURN_CODE(3); //!< This return code indicates that data was requested with an illegal storage ID.
|
||||
static const ReturnValue_t DATA_DOES_NOT_EXIST = MAKE_RETURN_CODE(4); //!< This return code indicates that the requested ID was valid, but no data is stored there.
|
||||
static const ReturnValue_t ILLEGAL_ADDRESS = MAKE_RETURN_CODE(5);
|
||||
|
||||
static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::OBSW;
|
||||
static const Event GET_DATA_FAILED = MAKE_EVENT(0, SEVERITY::LOW);
|
||||
static const Event STORE_DATA_FAILED = MAKE_EVENT(1, SEVERITY::LOW);
|
||||
|
||||
static const uint32_t INVALID_ADDRESS = 0xFFFFFFFF; //!< Indicates an invalid (i.e unused) storage address.
|
||||
/**
|
||||
* @brief This is the empty virtual destructor as required for C++ interfaces.
|
||||
*/
|
||||
virtual ~StorageManagerIF() {
|
||||
}
|
||||
;
|
||||
/**
|
||||
* @brief With addData, a free storage position is allocated and data
|
||||
* stored there.
|
||||
* @details During the allocation, the StorageManager is blocked.
|
||||
* @param storageId A pointer to the storageId to retrieve.
|
||||
* @param data The data to be stored in the StorageManager.
|
||||
* @param size The amount of data to be stored.
|
||||
* @return Returns @li RETURN_OK if data was added.
|
||||
* @li RETURN_FAILED if data could not be added.
|
||||
* storageId is unchanged then.
|
||||
*/
|
||||
virtual ReturnValue_t addData(store_address_t* storageId, const uint8_t * data, uint32_t size) = 0;
|
||||
/**
|
||||
* @brief With deleteData, the storageManager frees the memory region
|
||||
* identified by packet_id.
|
||||
* @param packet_id The identifier of the memory region to be freed.
|
||||
* @return @li RETURN_OK on success.
|
||||
* @li RETURN_FAILED if deletion did not work
|
||||
* (e.g. an illegal packet_id was passed).
|
||||
*/
|
||||
virtual ReturnValue_t deleteData(store_address_t packet_id) = 0;
|
||||
/**
|
||||
* @brief Another deleteData which uses the pointer and size of the stored data to delete the content.
|
||||
* @param buffer Pointer to the data.
|
||||
* @param size Size of data to be stored.
|
||||
* @param storeId Store id of the deleted element (optional)
|
||||
* @return @li RETURN_OK on success.
|
||||
* @li failure code if deletion did not work
|
||||
*/
|
||||
virtual ReturnValue_t deleteData(uint8_t* buffer, uint32_t size, store_address_t* storeId = NULL) = 0;
|
||||
/**
|
||||
* @brief getData returns an address to data and the size of the data
|
||||
* for a given packet_id.
|
||||
* @param packet_id The id of the data to be returned
|
||||
* @param packet_ptr The passed pointer address is set to the the memory
|
||||
* position
|
||||
* @param size The exact size of the stored data is returned here.
|
||||
* @return @li RETURN_OK on success.
|
||||
* @li RETURN_FAILED if fetching data did not work
|
||||
* (e.g. an illegal packet_id was passed).
|
||||
*/
|
||||
virtual ReturnValue_t getData(store_address_t packet_id,
|
||||
const uint8_t** packet_ptr, uint32_t* size) = 0;
|
||||
/**
|
||||
* Same as above, but not const and therefore modifiable.
|
||||
*/
|
||||
virtual ReturnValue_t modifyData(store_address_t packet_id,
|
||||
uint8_t** packet_ptr, uint32_t* size) = 0;
|
||||
/**
|
||||
* This method reserves an element of \c size.
|
||||
*
|
||||
* It returns the packet id of this element as well as a direct pointer to the
|
||||
* data of the element. It must be assured that exactly \c size data is
|
||||
* written to p_data!
|
||||
* @param storageId A pointer to the storageId to retrieve.
|
||||
* @param size The size of the space to be reserved.
|
||||
* @param p_data A pointer to the element data is returned here.
|
||||
* @return Returns @li RETURN_OK if data was added.
|
||||
* @li RETURN_FAILED if data could not be added.
|
||||
* storageId is unchanged then.
|
||||
*/
|
||||
virtual ReturnValue_t getFreeElement(store_address_t* storageId, const uint32_t size, uint8_t** p_data ) = 0;
|
||||
/**
|
||||
* Clears the whole store.
|
||||
* Use with care!
|
||||
*/
|
||||
virtual void clearStore() = 0;
|
||||
|
||||
};
|
||||
|
||||
#endif /* STORAGEMANAGERIF_H_ */
|
||||
Reference in New Issue
Block a user