diff --git a/datapool/PoolDataSetBase.cpp b/datapool/PoolDataSetBase.cpp index 7731a8df4..010697854 100644 --- a/datapool/PoolDataSetBase.cpp +++ b/datapool/PoolDataSetBase.cpp @@ -88,7 +88,8 @@ ReturnValue_t PoolDataSetBase::readVariable(uint16_t count) { { if(protectEveryReadCommitCall) { result = registeredVariables[count]->read( - MutexIF::TimeoutType::WAITING, mutexTimeout); + timeoutTypeForSingleVars, + mutexTimeoutForSingleVars); } else { result = registeredVariables[count]->readWithoutLock(); @@ -122,7 +123,8 @@ void PoolDataSetBase::handleAlreadyReadDatasetCommit( != PoolVariableIF::NO_PARAMETER) { if(protectEveryReadCommitCall) { registeredVariables[count]->commit( - MutexIF::TimeoutType::WAITING, mutexTimeout); + timeoutTypeForSingleVars, + mutexTimeoutForSingleVars); } else { registeredVariables[count]->commitWithoutLock(); @@ -144,7 +146,8 @@ ReturnValue_t PoolDataSetBase::handleUnreadDatasetCommit( != PoolVariableIF::NO_PARAMETER) { if(protectEveryReadCommitCall) { result = registeredVariables[count]->commit( - MutexIF::TimeoutType::WAITING, mutexTimeout); + timeoutTypeForSingleVars, + mutexTimeoutForSingleVars); } else { result = registeredVariables[count]->commitWithoutLock(); @@ -219,7 +222,9 @@ PoolVariableIF** PoolDataSetBase::getContainer() const { } void PoolDataSetBase::setReadCommitProtectionBehaviour( - bool protectEveryReadCommit, uint32_t mutexTimeout) { + bool protectEveryReadCommit, MutexIF::TimeoutType timeoutType, + uint32_t mutexTimeout) { this->protectEveryReadCommitCall = protectEveryReadCommit; - this->mutexTimeout = mutexTimeout; + this->timeoutTypeForSingleVars = timeoutType; + this->mutexTimeoutForSingleVars = mutexTimeout; } diff --git a/datapool/PoolDataSetBase.h b/datapool/PoolDataSetBase.h index 665f4b33c..6f3c5fa4b 100644 --- a/datapool/PoolDataSetBase.h +++ b/datapool/PoolDataSetBase.h @@ -127,6 +127,7 @@ protected: * @param mutexTimeout */ void setReadCommitProtectionBehaviour(bool protectEveryReadCommit, + MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING, uint32_t mutexTimeout = 20); /** @@ -161,7 +162,8 @@ protected: private: bool protectEveryReadCommitCall = false; - uint32_t mutexTimeout = 20; + MutexIF::TimeoutType timeoutTypeForSingleVars; + uint32_t mutexTimeoutForSingleVars = 20; ReturnValue_t readVariable(uint16_t count); void handleAlreadyReadDatasetCommit( diff --git a/datapoollocal/LocalPoolDataSetBase.cpp b/datapoollocal/LocalPoolDataSetBase.cpp index af492146d..006239f66 100644 --- a/datapoollocal/LocalPoolDataSetBase.cpp +++ b/datapoollocal/LocalPoolDataSetBase.cpp @@ -19,15 +19,16 @@ LocalPoolDataSetBase::LocalPoolDataSetBase(HasLocalDataPoolIF *hkOwner, << "invalid!" << std::endl; #else fsfw::printError("LocalPoolDataSetBase::LocalPoolDataSetBase: Owner " - "invalid!\n\r"); + "invalid!\n"); #endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */ return; } - hkManager = hkOwner->getHkManagerHandle(); + LocalDataPoolManager* hkManager = hkOwner->getHkManagerHandle(); + mutexIfSingleDataCreator = hkManager->getMutexHandle(); this->sid.objectId = hkOwner->getObjectId(); this->sid.ownerSetId = setId; - mutex = MutexFactory::instance()->createMutex(); + //mutex = MutexFactory::instance()->createMutex(); // Data creators get a periodic helper for periodic HK data generation. if(periodicHandling) { @@ -41,34 +42,29 @@ LocalPoolDataSetBase::LocalPoolDataSetBase(sid_t sid, PoolDataSetBase(registeredVariablesArray, maxNumberOfVariables) { HasLocalDataPoolIF* hkOwner = objectManager->get( sid.objectId); - if(hkOwner != nullptr) { - hkManager = hkOwner->getHkManagerHandle(); - } + LocalDataPoolManager* hkManager = hkOwner->getHkManagerHandle(); + mutexIfSingleDataCreator = hkManager->getMutexHandle(); this->sid = sid; - - mutex = MutexFactory::instance()->createMutex(); } LocalPoolDataSetBase::LocalPoolDataSetBase( PoolVariableIF **registeredVariablesArray, - const size_t maxNumberOfVariables, bool protectFunctions): + const size_t maxNumberOfVariables): PoolDataSetBase(registeredVariablesArray, maxNumberOfVariables) { - if(protectFunctions) { - mutex = MutexFactory::instance()->createMutex(); - } - } LocalPoolDataSetBase::~LocalPoolDataSetBase() { + if(periodicHelper != nullptr) { + delete periodicHelper; + } } ReturnValue_t LocalPoolDataSetBase::lockDataPool( MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) { - if(hkManager != nullptr) { - MutexIF* poolMutex = hkManager->getMutexHandle(); - return poolMutex->lockMutex(timeoutType, timeoutMs); + if(mutexIfSingleDataCreator != nullptr) { + return mutexIfSingleDataCreator->lockMutex(timeoutType, timeoutMs); } return HasReturnvaluesIF::RETURN_OK; } @@ -146,9 +142,8 @@ ReturnValue_t LocalPoolDataSetBase::deSerializeWithValidityBuffer( } ReturnValue_t LocalPoolDataSetBase::unlockDataPool() { - if(hkManager != nullptr) { - MutexIF* mutex = hkManager->getMutexHandle(); - return mutex->unlockMutex(); + if(mutexIfSingleDataCreator != nullptr) { + return mutexIfSingleDataCreator->unlockMutex(); } return HasReturnvaluesIF::RETURN_OK; } @@ -268,19 +263,10 @@ void LocalPoolDataSetBase::initializePeriodicHelper( } void LocalPoolDataSetBase::setChanged(bool changed) { - if(mutex == nullptr) { - this->changed = changed; - return; - } - MutexHelper(mutex, MutexIF::TimeoutType::WAITING, mutexTimeout); this->changed = changed; } bool LocalPoolDataSetBase::hasChanged() const { - if(mutex == nullptr) { - return changed; - } - MutexHelper(mutex, MutexIF::TimeoutType::WAITING, mutexTimeout); return changed; } @@ -302,32 +288,16 @@ bool LocalPoolDataSetBase::bitGetter(const uint8_t* byte, } bool LocalPoolDataSetBase::isValid() const { - if(mutex == nullptr) { - return this->valid; - } - MutexHelper(mutex, MutexIF::TimeoutType::WAITING, 5); return this->valid; } void LocalPoolDataSetBase::setValidity(bool valid, bool setEntriesRecursively) { - mutex->lockMutex(timeoutType, mutexTimeout); if(setEntriesRecursively) { for(size_t idx = 0; idx < this->getFillCount(); idx++) { registeredVariables[idx] -> setValid(valid); } } this->valid = valid; - mutex->unlockMutex(); } -void LocalPoolDataSetBase::setReadCommitProtectionBehaviour( - bool protectEveryReadCommit, uint32_t mutexTimeout) { - PoolDataSetBase::setReadCommitProtectionBehaviour(protectEveryReadCommit, - mutexTimeout); -} -void LocalPoolDataSetBase::setDataSetMutexTimeout( - MutexIF::TimeoutType timeoutType, uint32_t mutexTimeout) { - this->timeoutType = timeoutType; - this->mutexTimeout = mutexTimeout; -} diff --git a/datapoollocal/LocalPoolDataSetBase.h b/datapoollocal/LocalPoolDataSetBase.h index b44f607ff..fdd8b3c75 100644 --- a/datapoollocal/LocalPoolDataSetBase.h +++ b/datapoollocal/LocalPoolDataSetBase.h @@ -57,7 +57,8 @@ public: const size_t maxNumberOfVariables, bool periodicHandling = true); /** - * @brief Constructor for users of local pool data. + * @brief Constructor for users of the local pool data, which need + * to access data created by one HK manager. * @details * @param sid Unique identifier of dataset consisting of object ID and * set ID. @@ -68,13 +69,22 @@ public: const size_t maxNumberOfVariables); /** - * Simple constructor, if the dataset is not owner permanently by - * a class with a HK manager. + * Simple constructor, if the dataset is not the owner by + * a class with a HK manager. This function should also be called by + * classes which needs to access pool variables from different creators. + * + * If the class is intended to access pool variables from different + * creators, the third argument should be set to true. The mutex + * properties can be set with #setReadCommitProtectionBehaviour . * @param registeredVariablesArray * @param maxNumberOfVariables + * @param protectEveryReadCommitCall If the pool variables are created by + * multiple creators, this flag can be set to protect all read and + * commit calls separately. */ LocalPoolDataSetBase(PoolVariableIF** registeredVariablesArray, - const size_t maxNumberOfVariables, bool protectFunctions = true); + const size_t maxNumberOfVariables, + bool protectEveryReadCommitCall = true); /** * @brief The destructor automatically manages writing the valid @@ -86,19 +96,6 @@ public: */ ~LocalPoolDataSetBase(); - /** - * If the data is pulled from different local data pools, every read and - * commit call should be mutex protected for thread safety. - * This can be specified with the second parameter. - * @param dataCreator - * @param protectEveryReadCommit - */ - void setReadCommitProtectionBehaviour(bool protectEveryReadCommit, - uint32_t mutexTimeout = 20); - - void setDataSetMutexTimeout(MutexIF::TimeoutType timeoutType, - uint32_t mutexTimeout); - void setValidityBufferGeneration(bool withValidityBuffer); sid_t getSid() const; @@ -150,13 +147,8 @@ public: protected: sid_t sid; - MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING; - uint32_t mutexTimeout = 20; - /** - * This mutex is required because the dataset can potentially be accessed - * by multiple threads for information like change status or validity. - */ - MutexIF* mutex = nullptr; + //! This mutex is used if the data is created by one object only. + MutexIF* mutexIfSingleDataCreator = nullptr; bool diagnostic = false; void setDiagnostic(bool diagnostics); @@ -211,8 +203,6 @@ protected: */ ReturnValue_t unlockDataPool() override; - LocalDataPoolManager* hkManager = nullptr; - /** * Set n-th bit of a byte, with n being the position from 0 * (most significant bit) to 7 (least significant bit)