local pool neat
This commit is contained in:
parent
4b65d6e847
commit
b947253ac3
@ -1,15 +1,6 @@
|
||||
#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>
|
||||
@ -70,53 +61,21 @@ public:
|
||||
virtual ~LocalPool(void);
|
||||
|
||||
/**
|
||||
* Add data to local data pool, performs range check
|
||||
* @param storageId [out] Store ID in which the data will be stored
|
||||
* @param data
|
||||
* @param size
|
||||
* @param ignoreFault
|
||||
* @return @c RETURN_OK if write was successful
|
||||
* Documentation: See StorageManagerIF.h
|
||||
*/
|
||||
ReturnValue_t addData(store_address_t* storageId, const uint8_t * data,
|
||||
uint32_t size, bool ignoreFault = false);
|
||||
|
||||
/**
|
||||
* With this helper method, a free element of \c size is reserved.
|
||||
* @param storageId [out] storeID of the free element
|
||||
* @param size The minimum packet size that shall be reserved.
|
||||
* @param p_data [out] pointer to the pointer of free element
|
||||
* @param ignoreFault
|
||||
* @return Returns the storage identifier within the storage or
|
||||
* StorageManagerIF::INVALID_ADDRESS (in raw).
|
||||
*/
|
||||
ReturnValue_t getFreeElement(store_address_t* storageId,
|
||||
const uint32_t size, uint8_t** p_data, bool ignoreFault = false);
|
||||
|
||||
/**
|
||||
* Retrieve data from local pool
|
||||
* @param packet_id
|
||||
* @param packet_ptr
|
||||
* @param size [out] Size of retrieved data
|
||||
* @return @c RETURN_OK if data retrieval was successfull
|
||||
*/
|
||||
size_t size, bool ignoreFault = false) override;
|
||||
ReturnValue_t getFreeElement(store_address_t* storageId,const size_t size,
|
||||
uint8_t** p_data, bool ignoreFault = false) override;
|
||||
ReturnValue_t getData(store_address_t packet_id, const uint8_t** packet_ptr,
|
||||
size_t * size);
|
||||
|
||||
/**
|
||||
* Modify data by supplying a packet pointer and using that packet pointer
|
||||
* to access and modify the pool entry (via *pointer call)
|
||||
* @param packet_id Store ID of data to modify
|
||||
* @param packet_ptr [out] pointer to the pool entry to modify
|
||||
* @param size [out] size of pool entry
|
||||
* @return
|
||||
*/
|
||||
size_t * size) override;
|
||||
ReturnValue_t modifyData(store_address_t packet_id, uint8_t** packet_ptr,
|
||||
size_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();
|
||||
size_t * size) override;
|
||||
virtual ReturnValue_t deleteData(store_address_t) override;
|
||||
virtual ReturnValue_t deleteData(uint8_t* ptr, size_t size,
|
||||
store_address_t* storeId = NULL) override;
|
||||
void clearStore() override;
|
||||
ReturnValue_t initialize() override;
|
||||
protected:
|
||||
/**
|
||||
* With this helper method, a free element of \c size is reserved.
|
||||
@ -167,7 +126,7 @@ private:
|
||||
* @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);
|
||||
void write(store_address_t packet_id, 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.
|
||||
@ -190,7 +149,8 @@ private:
|
||||
* @return - #RETURN_OK on success,
|
||||
* - #DATA_TOO_LARGE otherwise.
|
||||
*/
|
||||
ReturnValue_t getPoolIndex(uint32_t packet_size, uint16_t* poolIndex, uint16_t startAtIndex = 0);
|
||||
ReturnValue_t getPoolIndex(size_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.
|
||||
@ -212,249 +172,6 @@ private:
|
||||
ReturnValue_t findEmpty(uint16_t pool_index, uint16_t* element);
|
||||
};
|
||||
|
||||
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, bool ignoreFault) {
|
||||
ReturnValue_t status = getPoolIndex(size, &address->pool_index);
|
||||
if (status != RETURN_OK) {
|
||||
sif::error << "LocalPool( " << std::hex << getObjectId() << std::dec
|
||||
<< " )::reserveSpace: Packet too large." << std::endl;
|
||||
return status;
|
||||
}
|
||||
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) {
|
||||
// if (getObjectId() == objects::IPC_STORE && address->pool_index >= 3) {
|
||||
// debug << "Reserve: Pool: " << std::dec << address->pool_index << " Index: " << address->packet_index << std::endl;
|
||||
// }
|
||||
|
||||
size_list[address->pool_index][address->packet_index] = size;
|
||||
} else {
|
||||
if (!ignoreFault and internalErrorReporter != nullptr) {
|
||||
internalErrorReporter->storeFull();
|
||||
}
|
||||
sif::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), internalErrorReporter(NULL), 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, bool ignoreFault) {
|
||||
ReturnValue_t status = reserveSpace(size, storageId, ignoreFault);
|
||||
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, bool ignoreFault) {
|
||||
ReturnValue_t status = reserveSpace(size, storageId, ignoreFault);
|
||||
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, size_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, size_t * size) {
|
||||
ReturnValue_t status = RETURN_FAILED;
|
||||
if (packet_id.pool_index >= NUMBER_OF_POOLS) {
|
||||
return ILLEGAL_STORAGE_ID;
|
||||
}
|
||||
if ((packet_id.packet_index >= n_elements[packet_id.pool_index])) {
|
||||
return ILLEGAL_STORAGE_ID;
|
||||
}
|
||||
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;
|
||||
}
|
||||
return status;
|
||||
}
|
||||
|
||||
template<uint8_t NUMBER_OF_POOLS>
|
||||
inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::deleteData(
|
||||
store_address_t packet_id) {
|
||||
|
||||
// if (getObjectId() == objects::IPC_STORE && packet_id.pool_index >= 3) {
|
||||
// debug << "Delete: Pool: " << std::dec << packet_id.pool_index << " Index: " << 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 {
|
||||
//pool_index or packet_index is too large
|
||||
sif::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 = ptr - 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;
|
||||
}
|
||||
internalErrorReporter = objectManager->get<InternalErrorReporterIF>(objects::INTERNAL_ERROR_REPORTER);
|
||||
if (internalErrorReporter == NULL){
|
||||
return RETURN_FAILED;
|
||||
}
|
||||
|
||||
//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) {
|
||||
sif::error
|
||||
<< "LocalPool::initialize: Pool is too large! Max. allowed size is: "
|
||||
<< (STORAGE_FREE - 1) << std::endl;
|
||||
return RETURN_FAILED;
|
||||
}
|
||||
}
|
||||
return RETURN_OK;
|
||||
}
|
||||
#include <framework/storagemanager/LocalPool.tpp>
|
||||
|
||||
#endif /* FRAMEWORK_STORAGEMANAGER_LOCALPOOL_H_ */
|
||||
|
||||
260
storagemanager/LocalPool.tpp
Normal file
260
storagemanager/LocalPool.tpp
Normal file
@ -0,0 +1,260 @@
|
||||
#ifndef LOCALPOOL_TPP
|
||||
#define LOCALPOOL_TPP
|
||||
|
||||
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), internalErrorReporter(nullptr),
|
||||
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]));
|
||||
//TODO checkme
|
||||
memset(size_list[n], STORAGE_FREE, (n_elements[n] * sizeof(**size_list)));
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
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, size_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(
|
||||
size_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, bool ignoreFault) {
|
||||
ReturnValue_t status = getPoolIndex(size, &address->pool_index);
|
||||
if (status != RETURN_OK) {
|
||||
sif::error << "LocalPool( " << std::hex << getObjectId() << std::dec
|
||||
<< " )::reserveSpace: Packet too large." << std::endl;
|
||||
return status;
|
||||
}
|
||||
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) {
|
||||
// if (getObjectId() == objects::IPC_STORE && address->pool_index >= 3) {
|
||||
// debug << "Reserve: Pool: " << std::dec << address->pool_index <<
|
||||
// " Index: " << address->packet_index << std::endl;
|
||||
// }
|
||||
|
||||
size_list[address->pool_index][address->packet_index] = size;
|
||||
} else {
|
||||
if (!ignoreFault and internalErrorReporter != nullptr) {
|
||||
internalErrorReporter->storeFull();
|
||||
}
|
||||
// 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(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, size_t size, bool ignoreFault) {
|
||||
ReturnValue_t status = reserveSpace(size, storageId, ignoreFault);
|
||||
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 size_t size,
|
||||
uint8_t** p_data, bool ignoreFault) {
|
||||
ReturnValue_t status = reserveSpace(size, storageId, ignoreFault);
|
||||
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, size_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, size_t* size) {
|
||||
ReturnValue_t status = RETURN_FAILED;
|
||||
if (packet_id.pool_index >= NUMBER_OF_POOLS) {
|
||||
return ILLEGAL_STORAGE_ID;
|
||||
}
|
||||
if ((packet_id.packet_index >= n_elements[packet_id.pool_index])) {
|
||||
return ILLEGAL_STORAGE_ID;
|
||||
}
|
||||
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;
|
||||
}
|
||||
return status;
|
||||
}
|
||||
|
||||
template<uint8_t NUMBER_OF_POOLS>
|
||||
inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::deleteData(
|
||||
store_address_t packet_id) {
|
||||
//if (getObjectId() == objects::IPC_STORE && packet_id.pool_index >= 3) {
|
||||
// debug << "Delete: Pool: " << std::dec << packet_id.pool_index << " Index: "
|
||||
// << 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 {
|
||||
//pool_index or packet_index is too large
|
||||
sif::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++) {
|
||||
//TODO checkme
|
||||
memset(size_list[n], STORAGE_FREE, (n_elements[n] * sizeof(**size_list)));
|
||||
}
|
||||
}
|
||||
|
||||
template<uint8_t NUMBER_OF_POOLS>
|
||||
inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::deleteData(uint8_t* ptr,
|
||||
size_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 = ptr - 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;
|
||||
}
|
||||
internalErrorReporter = objectManager->get<InternalErrorReporterIF>(
|
||||
objects::INTERNAL_ERROR_REPORTER);
|
||||
if (internalErrorReporter == NULL){
|
||||
return RETURN_FAILED;
|
||||
}
|
||||
|
||||
//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) {
|
||||
sif::error << "LocalPool::initialize: Pool is too large! "
|
||||
"Max. allowed size is: " << (STORAGE_FREE - 1) << std::endl;
|
||||
return RETURN_FAILED;
|
||||
}
|
||||
}
|
||||
return RETURN_OK;
|
||||
}
|
||||
|
||||
#endif
|
||||
@ -6,9 +6,9 @@
|
||||
#include <stddef.h>
|
||||
|
||||
/**
|
||||
* 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.
|
||||
* 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 {
|
||||
/**
|
||||
@ -94,7 +94,8 @@ public:
|
||||
* @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, bool ignoreFault = false) = 0;
|
||||
virtual ReturnValue_t addData(store_address_t* storageId,
|
||||
const uint8_t * data, size_t size, bool ignoreFault = false) = 0;
|
||||
/**
|
||||
* @brief With deleteData, the storageManager frees the memory region
|
||||
* identified by packet_id.
|
||||
@ -105,14 +106,16 @@ public:
|
||||
*/
|
||||
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.
|
||||
* @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;
|
||||
virtual ReturnValue_t deleteData(uint8_t* buffer, size_t size,
|
||||
store_address_t* storeId = nullptr) = 0;
|
||||
/**
|
||||
* @brief getData returns an address to data and the size of the data
|
||||
* for a given packet_id.
|
||||
@ -125,12 +128,12 @@ public:
|
||||
* (e.g. an illegal packet_id was passed).
|
||||
*/
|
||||
virtual ReturnValue_t getData(store_address_t packet_id,
|
||||
const uint8_t** packet_ptr, size_t * size) = 0;
|
||||
const uint8_t** packet_ptr, size_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, size_t * size) = 0;
|
||||
uint8_t** packet_ptr, size_t* size) = 0;
|
||||
/**
|
||||
* This method reserves an element of \c size.
|
||||
*
|
||||
@ -145,7 +148,7 @@ public:
|
||||
* storageId is unchanged then.
|
||||
*/
|
||||
virtual ReturnValue_t getFreeElement(store_address_t* storageId,
|
||||
const uint32_t size, uint8_t** p_data, bool ignoreFault = false ) = 0;
|
||||
const size_t size, uint8_t** p_data, bool ignoreFault = false ) = 0;
|
||||
/**
|
||||
* Clears the whole store.
|
||||
* Use with care!
|
||||
|
||||
Loading…
Reference in New Issue
Block a user