ThreadPriorityConfiguration.cpp

Go to the documentation of this file.

// Copyright CERN 2012 - Developed in collaboration with GSI

#include <fesa-core/Core/ThreadPriorityConfiguration.h>

#include <fesa-core/Core/FesaDefs.h>
#include <fesa-core/Exception/FesaException.h>
#include <fesa-core/Utilities/XMLParser.h>
#include <fesa-core/Utilities/ProcessConfiguration.h>

#include <cmw-log/Logger.h>


namespace
{

CMW::Log::Logger& startUpTrackingLogger = CMW::Log::LoggerFactory::getLogger("FESA.DIAG.FWK.StartUpTracking");

} // namespace


namespace fesa
{

ThreadPriorityConfiguration::~ThreadPriorityConfiguration()
{
}

ThreadPriorityConfigurationFromFile::ThreadPriorityConfigurationFromFile(XMLParser& xmlParser, const ProcessConfiguration* processConfiguration) :
    xmlParser_(xmlParser),
    processConfiguration_(processConfiguration)
{
}

ThreadPriorityConfigurationFromFile::~ThreadPriorityConfigurationFromFile()
{
}

int32_t ThreadPriorityConfigurationFromFile::getPrioCMW() const
{
    int32_t prio = 0;

    AttributeXML* attr =  xmlParser_.extractAttribute(threadCmwXMLElementName, priorityAttributeName);
    if (attr == 0)
    {
        if(processConfiguration_->isDefined(PropertyTag::NO_RT_SCHEDULING))
            prio = DEFAULT_NICE_PRIO_RDA_SERVER_THREAD;
        else
            prio = DEFAULT_RT_PRIO_RDA_SERVER_THREAD;

        std::ostringstream stream;
        stream << std::endl;
        stream << "------------------------------------------ Information -------------------------------------------"  << std::endl;
        stream << "You did not specify a prio-value for the RDA-SERVER-THREAD" << std::endl;
        stream << "The default priority value of " << prio << " will be used now for this thread!" << std::endl;
        stream << "--------------------------------------------------------------------------------------------------"  << std::endl;
        LOG_INFO_IF(startUpTrackingLogger, stream.str());
    }
    else
    {
        prio = atoi((attr->value_).c_str());
        delete attr;  // It is up to the caller of "extractAttribute" to delete the attributeXML object
    }

    return prio;
}

int32_t ThreadPriorityConfigurationFromFile::getPrioPersistence() const
{
    int32_t prio = 0;

    AttributeXML* attr =  xmlParser_.extractAttribute(threadPersistenceXMLElementName, priorityAttributeName);
    if (attr == 0)
    {
        if(processConfiguration_->isDefined(PropertyTag::NO_RT_SCHEDULING))
            prio = DEFAULT_NICE_PRIO_PERSISTANCE_THREAD;
        else
            prio = DEFAULT_RT_PRIO_PERSISTANCE_THREAD;

        std::ostringstream stream;
        stream << std::endl;
        stream << "------------------------------------------ Information -------------------------------------------"  << std::endl;
        stream << "You did not specify a prio-value for the PERSISTANCY-THREAD" << std::endl;
        stream << "The default priority value of " << prio << " will be used now for this thread!" << std::endl;
        stream << "--------------------------------------------------------------------------------------------------"  << std::endl;
        LOG_INFO_IF(startUpTrackingLogger, stream.str());
    }
    else
    {
        prio = atoi((attr->value_).c_str());
        delete attr;  // It is up to the caller of "extractAttribute" to delete the attributeXML object
    }

    return prio;
}

int32_t  ThreadPriorityConfigurationFromFile::getPrioNotificationConsumer() const
{
    int32_t prio = 0;
    AttributeXML* attr =  xmlParser_.extractAttribute(threadNotificationConsumerXMLElementName, priorityAttributeName);
    if (attr == 0)
    {
        if(processConfiguration_->isDefined(PropertyTag::NO_RT_SCHEDULING))
            prio = DEFAULT_NICE_PRIO_CLIENT_NOTIFICATION_THREAD;
        else
            prio = DEFAULT_RT_PRIO_CLIENT_NOTIFICATION_THREAD;

        std::ostringstream stream;
        stream << std::endl;
        stream << "------------------------------------------ Information -------------------------------------------"  << std::endl;
        stream << "You did not specify a prio-value for the SERVER-NOTIFICATION-THREAD" << std::endl;
        stream << "The default priority value of " << prio << " will be used now for this thread!" << std::endl;
        stream << "--------------------------------------------------------------------------------------------------"  << std::endl;
        LOG_INFO_IF(startUpTrackingLogger, stream.str());
    }
    else
    {
        prio = atoi((attr->value_).c_str());
        delete attr;  // It is up to the caller of "extractAttribute" to delete the attributeXML object
    }

    return prio;
}

int32_t ThreadPriorityConfigurationFromFile::getPrioRTScheduler(const std::string& name) const
{
    int32_t prio = 0;
    std::string rtSchedulerName = name + threadRTSchedulerXMLElementName;
    AttributeXML* attr =  xmlParser_.extractAttribute(rtSchedulerName, priorityAttributeName);
    if (attr == 0)
    {
        if(processConfiguration_->isDefined(PropertyTag::NO_RT_SCHEDULING))
            prio = DEFAULT_NICE_PRIO_CONCURRENCY_LAYER;
        else
            prio = DEFAULT_RT_PRIO_CONCURRENCY_LAYER;

        std::ostringstream stream;
        stream << std::endl;
        stream << "------------------------------------------ Information -------------------------------------------"  << std::endl;
        stream << "You did not specify a prio-value for the concurrency-layer " << name << std::endl;
        stream << "The default priority value of " << prio << " will be used now for the thread of this concurrency-layer!" << std::endl;
        stream << "--------------------------------------------------------------------------------------------------"  << std::endl;
        LOG_INFO_IF(startUpTrackingLogger, stream.str());
    }
    else
    {
        prio = atoi((attr->value_).c_str());
        delete attr;  // It is up to the caller of "extractAttribute" to delete the attributeXML object
    }

    return prio;
}

int32_t ThreadPriorityConfigurationFromFile::getPrioEventSource(const std::string& name) const
{
    int32_t prio = 0;
    std::string eventSourceName = name + threadEventSourceXMLElementName;
    AttributeXML* attr =  xmlParser_.extractAttribute(eventSourceName, priorityAttributeName);
    if (attr == 0)
    {
        if(processConfiguration_->isDefined(PropertyTag::NO_RT_SCHEDULING))
            prio = DEFAULT_NICE_PRIO_EVENT_SOURCE;
        else
            prio = DEFAULT_RT_PRIO_EVENT_SOURCE;

        std::ostringstream stream;
        stream << std::endl;
        stream << "------------------------------------------ Information -------------------------------------------"  << std::endl;
        stream << "You did not specify a prio-value for the event-source " << name << std::endl;
        stream << "The default priority value of " << prio << " will be used now for the thread of this event-source!" << std::endl;
        stream << "--------------------------------------------------------------------------------------------------"  << std::endl;
        LOG_INFO_IF(startUpTrackingLogger, stream.str());
    }
    else
    {
        prio = atoi((attr->value_).c_str());
        delete attr;  // It is up to the caller of "extractAttribute" to delete the attributeXML object
    }

    return prio;
}

int32_t ThreadPriorityConfigurationFromFile::getPrioNotificationthread(const std::string& className, const std::string& notificationThreadKey) const
{
    // The xpath is: //prio-management/classes/className/client-notification-threads/notificationThreadKey
    int32_t prio = 0;
    std::string notificationName =  className + threadClientNotificationXMLElementName + notificationThreadKey;

    //13.12.2012 Alex ... quickfixed in release-trunk for GSI-release (FESA-3245 takes care for complete-fix)
    AttributeXML* attr = 0;
    //AttributeXML* attr =  xmlParser_.extractAttribute(threadNotificationConsumerXMLElementName, priorityAttributeName);

    if (attr == 0)
    {
        if(processConfiguration_->isDefined(PropertyTag::NO_RT_SCHEDULING))
        {
            prio = DEFAULT_NICE_PRIO_CLIENT_NOTIFICATION_THREAD;
        }
        else
        {
            prio = DEFAULT_RT_PRIO_CLIENT_NOTIFICATION_THREAD;
        }
        std::ostringstream stream;
        stream << std::endl;
        stream << "------------------------------------------ Information -------------------------------------------"  << std::endl;
        stream << "You did not specify a prio-value for the " << notificationThreadKey << std::endl;
        stream << "The default priority value of " << prio << " will be used now for this thread!" << std::endl;
        stream << "--------------------------------------------------------------------------------------------------"  << std::endl;
        LOG_INFO_IF(startUpTrackingLogger, stream.str());
    }
    else
    {
        prio = atoi((attr->value_).c_str());
        delete attr;  // It is up to the caller of "extractAttribute" to delete the attributeXML object
    }
    return prio;
}

bool ThreadPriorityConfigurationFromFile::getMaximumPrio(int32_t &maxPrio) const
{
    int32_t prio;
    //all elements which define a priority-attribute
    std::string xpathExpr = "//*[@" + priorityAttributeName + "]";
    std::vector<ElementXML*>* elementXMLCol = xmlParser_.extractElementsFromXPath(xpathExpr);

    if (elementXMLCol == NULL )//no prio-element found
    {
        return false;
    }
    else
    {
        std::vector<ElementXML*>::iterator elementIter;
        std::vector<AttributeXML*>::iterator atributeIter;
        for(elementIter=elementXMLCol->begin();elementIter!=elementXMLCol->end();elementIter++)
        {
            std::vector<AttributeXML*> attrCol = (*elementIter)->attributeList_;
            for (atributeIter = attrCol.begin(); atributeIter != attrCol.end(); atributeIter++)
            {
                if((*atributeIter)->name_ == priorityAttributeName)
                {
                    prio = atoi( ((*atributeIter)->value_).c_str() );
                    if( prio > maxPrio)
                        maxPrio = prio;
                }
            }
        }
        delete elementXMLCol;  // It is up to the caller of "extractAttribute" to delete the attributeXML object
    }

    return true;
}

int32_t ThreadPriorityConfigurationFromCCDB::getPrioCMW() const
{
    return 0;
}

int32_t ThreadPriorityConfigurationFromCCDB::getPrioPersistence() const
{
    return 0;
}

int32_t  ThreadPriorityConfigurationFromCCDB::getPrioNotificationConsumer() const
{
    return 0;
}

int32_t ThreadPriorityConfigurationFromCCDB::getPrioRTScheduler(const std::string& name) const
{
    return 0;
}

int32_t ThreadPriorityConfigurationFromCCDB::getPrioEventSource(const std::string& name) const
{
    return 0;
}

int32_t ThreadPriorityConfigurationFromCCDB::getPrioNotificationthread(const std::string& className, const std::string& notificationThreadKey) const
{
    return 0;
}

bool ThreadPriorityConfigurationFromCCDB::getMaximumPrio(int32_t &maxPrio) const
{
    return 0;
}

} // fesa