DataStore.cpp

Go to the documentation of this file.

// Copyright CERN 2012 - Developed in collaboration with GSI

#include <fesa-core/DataStore/DataStore.h>

#include <fesa-core/DataStore/AbstractField.h>
#include <fesa-core/Core/AbstractEquipment.h>
#include <fesa-core/Synchronization/MultiplexingContext.h>
#include <fesa-core/Synchronization/AbstractMultiplexingManager.h>
#include <fesa-core/Utilities/Mutex.h>
#include <fesa-core/Utilities/SharedMutex.h>
#include <fesa-core/Utilities/Lock.h>
#include <fesa-core/Utilities/ParserElements.h>

#include <cmw-log/Logger.h>

#include <iostream>

namespace
{

CMW::Log::Logger& logger = CMW::Log::LoggerFactory::getLogger("FESA.FWK.fesa-core.DataStore.DataStore");

}

namespace fesa
{

DataStore::DataStore() :
    numberOfSettingFields_(0)
{

}

DataStore::~DataStore()
{

}

void DataStore::registerField(AbstractField* pField)
{
    if (pField->getType() == Setting)
    {
        numberOfSettingFields_++;
        pFieldCol_.insert(pFieldCol_.begin(), pField);
    }
    else
    {
        pFieldCol_.push_back(pField);
    }

    if (pField->isPersistent())
    {
        persistentCol_.push_back(pField);
    }
}

AbstractField* DataStore::getField(const std::string& name)
{
    for (uint32_t i = 0; i < pFieldCol_.size(); i++)
    {
        if (pFieldCol_[i]->getName() == name)
        {
            return pFieldCol_[i];
        }
    }
    return 0;
}

void DataStore::createMutex(char* pAddrMemory)
{
    if (AbstractEquipment::getInstance()->getProcessType() == unsplit)
    {
        pMutex_ = new Mutex(pAddrMemory);
    }
    else
    {
        pMutex_ = new SharedMutex(pAddrMemory);
    }
}

void DataStore::synchronizeSettingFields(MultiplexingContext& context)
{
    Lock pMutexLock(*pMutex_);
    for (uint32_t i = 0; i < numberOfSettingFields_; i++)
    {
        // do not commit fields that are multiplexed and the context is not multiplexed
        // because they cannot be used in the real time action
        // it will be the responsibility of another real time action to commit them.
        if (context.getType() == MultiplexingContext::NoneCtxt && (pFieldCol_[i]->isMultiplexed()))
        {
            // This context is not meant to commit a multiplexed field, so just skip it
            continue;
        }
        int32_t idx = 0;
        if (pFieldCol_[i]->getMultiplexingManager() != NULL)
        {
            idx = pFieldCol_[i]->getMultiplexingManager()->getSlot(context);
        }
        pFieldCol_[i]->commit(idx);
    }
}

void DataStore::synchronizeSettingFields()
{
    Lock pMutexLock(*pMutex_);
    for (uint32_t i = 0; i < numberOfSettingFields_; i++)
    {
        uint32_t muxDepth = 1; // non mux field has a depth of one slot
        if (pFieldCol_[i]->getMultiplexingManager() != NULL)
        {
            muxDepth = pFieldCol_[i]->getMultiplexingManager()->getDepth();
        }
        for (uint32_t idx= 0; idx < muxDepth; ++idx)
        {
            pFieldCol_[i]->commit(idx);
        }
    }
}

void DataStore::initializeFromElement(DataStoreElement& element)
{
    initialize();
    for (uint32_t fieldIdx = 0; fieldIdx < pFieldCol_.size(); fieldIdx++)
    {
        FieldElement* fieldElement = element.getFieldElement(pFieldCol_[fieldIdx]->getName());
        if (fieldElement != NULL)
        {
            pFieldCol_[fieldIdx]->initialize(*fieldElement);
            pFieldCol_[fieldIdx]->restore(*fieldElement);
        }
    }
}

void DataStore::restoreFromElement(DataStoreElement& element)
{
    for (uint32_t fieldIdx = 0; fieldIdx < persistentCol_.size(); fieldIdx++)
    {
        FieldElement* fieldElement = element.getFieldElement(persistentCol_[fieldIdx]->getName());
        if (fieldElement != NULL)
        {
            persistentCol_[fieldIdx]->restore(*fieldElement);
        }
        else
        {
            continue; // either is a new field or the field changed the name, in any case was not found in the persistent file
        }
    }
}

int32_t DataStore::getMemorySizeToAllocate()
{
    int32_t size = 0;
    for (uint32_t i = 0; i < pFieldCol_.size(); i++)
    {
        size += (pFieldCol_[i]->getFieldValueSize() * pFieldCol_[i]->getMuxDepth());
    }
    size += getSizeOfAdditionalFields();
    if (AbstractEquipment::getInstance()->getProcessType() == unsplit)
    {
        size += Mutex::getSize();
    }
    else
    {
        size += SharedMutex::getSize();
    }
    return size;
}

void DataStore::mapMemory(char* p, bool initializeFields)
{
    {
        std::ostringstream msg;
        msg << "Mapping " << (void*)p << " end" << std::endl;
        LOG_TRACE_IF(logger, msg.str());
    }

    for (uint32_t i = 0; i < pFieldCol_.size(); i++)
    {
        pFieldCol_[i]->setFieldValueAddress(p, initializeFields);
        p += pFieldCol_[i]->getFieldValueSize() * pFieldCol_[i]->getMuxDepth();
    }
    mapAdditionalFields(p);
    p += getSizeOfAdditionalFields();
    createMutex(p);
}

int32_t DataStore::getSizeOfAdditionalFields()
{
    return sizeof(bool); // isLoggable and synchronize_
}

void DataStore::mapAdditionalFields(char* p)
{
}

void DataStore::initialize()
{
}

} // fesa