ComputingPowerRequestStrategy.h

Go to the documentation of this file.

/*
 * This file is part of ArmarX.
 *
 * Copyright (C) 2011-2016, High Performance Humanoid Technologies (H2T), Karlsruhe Institute of Technology (KIT), all rights reserved.
 *
 * ArmarX is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 * ArmarX is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 *
 * @package    RobotComponents
 * @author     Raphael Grimm ( raphael dot grimm at kit dot edu )
 * @date       2015
 * @copyright  http://www.gnu.org/licenses/gpl.txt
 *             GNU General Public License
 */
#pragma once
 
#include <chrono>
#include <numeric>
 
#include <ArmarXCore/core/exceptions/local/ExpressionException.h>
#include <ArmarXCore/core/system/FactoryCollectionBase.h>
 
#include <RobotComponents/interface/components/MotionPlanning/ResourceRequestStrategies/ComputingPowerRequestStrategy.h>
 
namespace armarx::cprs
{
    /**
     * @brief Implementation of ComputingPowerRequestStrategyBase
     * @see ComputingPowerRequestStrategyBase
     */
    class ComputingPowerRequestStrategy:
        virtual public ComputingPowerRequestStrategyBase
    {
    public:
        /**
         * @brief Dtor
         */
        ~ComputingPowerRequestStrategy() override = default;
 
        /**
         * @brief Default implementation. Does nothing.
         * @see ComputingPowerRequestStrategyBase::setCurrentStateAsInitialState
         */
        void setCurrentStateAsInitialState(const ::Ice::Current& = Ice::emptyCurrent) override
        {
        }
 
        /**
         * @brief Default implementation. Does nothing.
         * @see ComputingPowerRequestStrategyBase::updateNodeCount
         */
        void updateNodeCount(Ice::Long, const Ice::Current& = Ice::emptyCurrent) override
        {
        }
        /**
         * @brief Default implementation. Does nothing.
         * @see ComputingPowerRequestStrategyBase::updateTaskStatus
         */
        void updateTaskStatus(armarx::TaskStatus::Status, const Ice::Current& = Ice::emptyCurrent) override
        {
        }
 
        /**
         * @brief Default implementation. Does nothing.
         * @see ComputingPowerRequestStrategyBase::allocatedComputingPower
         */
        void allocatedComputingPower(const Ice::Current& = Ice::emptyCurrent) override
        {
        }
 
        /**
         * @brief Default implementation. Does nothing.
         * @see ComputingPowerRequestStrategyBase::updateNodeCreations
         */
        void updateNodeCreations(Ice::Long, Ice::Long, const Ice::Current& = Ice::emptyCurrent) override
        {
        }
 
        /**
         * @brief Returns whether new computing power should be allocated.
         * Pure virtual.
         * @see ComputingPowerRequestStrategyBase::shouldAllocateComputingPower
         * @return Whether new computing power should be allocated.
         */
        bool shouldAllocateComputingPower(const ::Ice::Current& = Ice::emptyCurrent) override = 0;
    };
    using ComputingPowerRequestStrategyPtr = IceInternal::Handle<ComputingPowerRequestStrategy>;
 
    /**
     * @brief Implementation of CompoundedRequestStrategyBase
     * @see CompoundedRequestStrategyBase
     */
    class CompoundedRequestStrategy:
        virtual public CompoundedRequestStrategyBase,
        virtual public ComputingPowerRequestStrategy
    {
    public:
        /**
         * @brief Ctor
         * @param requestStrategies The strategies forming this compound.
         */
        CompoundedRequestStrategy(const ComputingPowerRequestStrategyBaseList& requestStrategies): CompoundedRequestStrategyBase(requestStrategies) {}
 
        /**
         * @brief Calls this function for all compounded strategies.
         * @see ComputingPowerRequestStrategyBase::setCurrentStateAsInitialState
         */
        void setCurrentStateAsInitialState(const ::Ice::Current& = Ice::emptyCurrent) override;
        /**
         * @brief Calls this function for all compounded strategies.
         * @see ComputingPowerRequestStrategyBase::updateNodeCount
         * @param count The new node count
         */
        void updateNodeCount(Ice::Long count, const Ice::Current& = Ice::emptyCurrent) override;
 
        /**
         * @brief Calls this function for all compounded strategies.
         * @see ComputingPowerRequestStrategyBase::updateTaskStatus
         * @param newStatus The new status
         */
        void updateTaskStatus(armarx::TaskStatus::Status newStatus, const Ice::Current& = Ice::emptyCurrent) override;
 
        /**
         * @brief Calls this function for all compounded strategies.
         * @see ComputingPowerRequestStrategyBase::allocatedComputingPower
         */
        void allocatedComputingPower(const Ice::Current& = Ice::emptyCurrent) override;
 
        /**
         * @brief Passes this call to all sub strategies.
         * @see ComputingPowerRequestStrategyBase::updateNodeCreations
         * @param nodesCreated Number of created nodes.
         * @param tries Number of tries to create nodes.
         */
        void updateNodeCreations(Ice::Long nodesCreated, Ice::Long tries, const Ice::Current& = Ice::emptyCurrent) override;
 
    protected:
        //for object factory
        template<class Base, class Derived> friend class armarx::GenericFactory;
        /**
         * @brief Ctor used for object factories.
         */
        CompoundedRequestStrategy() = default;
    };
 
    /**
     * @brief Implementation of AndBase
     * @see AndBase
     */
    class And:
        virtual public AndBase,
        virtual public CompoundedRequestStrategy
    {
    public:
        /**
         * @brief Ctor
         * @param requestStrategies The strategies forming this compound.
         */
        And(const ComputingPowerRequestStrategyBaseList& requestStrategies):
            AndBase(requestStrategies),
            CompoundedRequestStrategy(requestStrategies)
        {}
        /**
         * @brief Returns true if all compounded strategies return true.
         * @return True if all compounded strategies return true.
         */
        bool shouldAllocateComputingPower(const ::Ice::Current& = Ice::emptyCurrent) override;
    protected:
        //for object factory
        template<class Base, class Derived> friend class armarx::GenericFactory;
        /**
         * @brief Ctor used for object factories.
         */
        And() = default;
    };
    using AndPtr = IceInternal::Handle<And>;
 
    /**
     * @brief Implementation of OrBase
     * @see OrBase
     */
    class Or:
        virtual public OrBase,
        virtual public CompoundedRequestStrategy
    {
    public:
        /**
         * @brief Ctor
         * @param requestStrategies The strategies forming this compound.
         */
        Or(const ComputingPowerRequestStrategyBaseList& requestStrategies):
            OrBase(requestStrategies),
            CompoundedRequestStrategy(requestStrategies)
        {}
        /**
         * @brief Returns true if any compounded strategies returns true.
         * @return True if all compounded strategies return true.
         */
        bool shouldAllocateComputingPower(const ::Ice::Current& = Ice::emptyCurrent) override
        {
            return std::any_of(requestStrategies.begin(), requestStrategies.end(),
                               [](ComputingPowerRequestStrategyBasePtr & s)
            {
                return s->shouldAllocateComputingPower();
            }
                              );
        }
    protected:
        //for object factory
        template<class Base, class Derived> friend class armarx::GenericFactory;
        /**
         * @brief Ctor used for object factories.
         */
        Or() = default;
    };
    using OrPtr = IceInternal::Handle<Or>;
 
    /**
     * @brief Implementation of NotBase
     * @see NotBase
     */
    class Not:
        virtual public NotBase,
        virtual public ComputingPowerRequestStrategy
    {
    public:
        /**
         * @brief Ctor
         * @param s The negated strategy.
         */
        Not(const ComputingPowerRequestStrategyBasePtr& s): NotBase(s) {}
 
        /**
         * @brief Passes the call to the contained strategy.
         */
        void setCurrentStateAsInitialState(const ::Ice::Current& = Ice::emptyCurrent) override
        {
            allocStrat->setCurrentStateAsInitialState();
        }
 
        /**
         * @brief Passes the call to the contained strategy.
         * @param count The new node count.
         */
        void updateNodeCount(Ice::Long count, const Ice::Current& = Ice::emptyCurrent) override
        {
            allocStrat->updateNodeCount(count);
        }
 
        /**
         * @brief Passes the call to the contained strategy.
         * @param newStatus The new task status.
         */
        void updateTaskStatus(armarx::TaskStatus::Status newStatus, const Ice::Current& = Ice::emptyCurrent) override
        {
            allocStrat->updateTaskStatus(newStatus);
        }
 
        /**
         * @brief Passes the call to the contained strategy.
         */
        void allocatedComputingPower(const Ice::Current& = Ice::emptyCurrent) override
        {
            allocStrat->allocatedComputingPower();
        }
 
        /**
         * @brief Returns the negatedresult of the contained strategy.
         * @return The negatedresult of the contained strategy.
         */
        bool shouldAllocateComputingPower(const ::Ice::Current& = Ice::emptyCurrent) override
        {
            return !allocStrat->shouldAllocateComputingPower();
        }
 
        /**
         * @brief Passes this call to all sub strategies.
         * @see ComputingPowerRequestStrategyBase::updateNodeCreations
         * @param nodesCreated Number of created nodes.
         * @param tries Number of tries to create nodes.
         */
        void updateNodeCreations(Ice::Long nodesCreated, Ice::Long tries, const Ice::Current& = Ice::emptyCurrent) override
        {
            allocStrat->updateNodeCreations(nodesCreated, tries);
        }
    protected:
        //for object factory
        template<class Base, class Derived> friend class armarx::GenericFactory;
        /**
         * @brief Ctor used for object factories.
         */
        Not() = default;
    };
    using NotPtr = IceInternal::Handle<Not>;
 
    /**
     * @brief Implementation of Always
     * @see Always
     */
    class Always:
        virtual public AlwaysBase,
        virtual public ComputingPowerRequestStrategy
    {
    public:
        /**
         * @brief Always return true.
         * @return true
         */
        bool shouldAllocateComputingPower(const ::Ice::Current& = Ice::emptyCurrent) override
        {
            return true;
        }
    };
    using AlwaysPtr = IceInternal::Handle<Always>;
 
    /**
     * @brief Implementation of NeverBase
     * @see NeverBase
     */
    class Never:
        virtual public NeverBase,
        virtual public ComputingPowerRequestStrategy
    {
    public:
        /**
         * @brief Always return false.
         * @return false
         */
        bool shouldAllocateComputingPower(const ::Ice::Current& = Ice::emptyCurrent) override
        {
            return false;
        }
    };
    using NeverPtr = IceInternal::Handle<Never>;
 
    /**
     * @brief Implementation of ElapsedTimeBase
     * @see ElapsedTimeBase
     */
    class ElapsedTime:
        virtual public ElapsedTimeBase,
        virtual public ComputingPowerRequestStrategy
    {
    public:
        /**
         * @brief The used clock type.
         */
        using Clock = std::chrono::system_clock;
        /**
         * @brief The type of the used time point.
         */
        using TimePoint = Clock::time_point;
 
        /**
         * @brief Ctor
         * @param timeDeltaInSeconds The delta to use.(in seconds)
         * @param skipping Whether skipping is activated.
         */
        ElapsedTime(Ice::Long timeDeltaInSeconds, bool skipping):
            ElapsedTimeBase(timeDeltaInSeconds, skipping),
            allocatedLastTime {}
        {
        }
 
        /**
         * @brief Sets the next time to allocate delta seconds from now.
         */
        void setCurrentStateAsInitialState(const ::Ice::Current& = Ice::emptyCurrent) override
        {
            allocatedLastTime = Clock::now();
        }
 
        /**
         * @brief Sets the next time to allocate depending on the flag skipping.
         * skipping == true: now + delta seconds.
         * skipping == false: the current next time point + delta seconds. (may already passed)
         */
        void allocatedComputingPower(const Ice::Current& = Ice::emptyCurrent) override;
 
        /**
         * @brief Returns true if the last creation timepoint is more than delta seconds away.
         * @return Whether more computing power should be allocated.
         */
        bool shouldAllocateComputingPower(const ::Ice::Current& = Ice::emptyCurrent) override
        {
            return Clock::now() >= allocatedLastTime + std::chrono::seconds {timeDeltaInSeconds};
        }
    protected:
        /**
         * @brief The time point when more power should be allocated again.
         */
        TimePoint allocatedLastTime;
 
        //for object factory
        template<class Base, class Derived> friend class armarx::GenericFactory;
        /**
         * @brief Ctor used for object factories.
         */
        ElapsedTime() = default;
    };
    using ElapsedTimePtr = IceInternal::Handle<ElapsedTime>;
 
 
    /**
     * @brief Implementation of NoNodeCreatedBase
     * @see NoNodeCreatedBase
     */
    class NoNodeCreated:
        virtual public NoNodeCreatedBase,
        virtual public ElapsedTime
    {
    public:
        /**
         * @brief ctor
         * @param timeDeltaInSeconds The delta to use.(in seconds)
         * @param skipping Whether skipping is activated.
         * @param sig The parameter sigma.
         * @param backlogSz The backlog's size.
         */
        NoNodeCreated(Ice::Long timeDeltaInSec, bool skip, float sig, Ice::Long backlogSz):
            NoNodeCreatedBase(timeDeltaInSec, skip, sig, backlogSz),
            ElapsedTime(timeDeltaInSec, skip),
            backlog(backlogSz, 0),
            currentBacklogIndex {0}
        {
            timeDeltaInSeconds = timeDeltaInSec; //somehow does not get set by ctor call
            ARMARX_CHECK_EXPRESSION(timeDeltaInSeconds >= 0);
            ARMARX_CHECK_EXPRESSION(backlogSize >= 0);
        }
 
        /**
         * @brief Updates the number of failed node creations.
         * @param nodesCreated Number of created nodes.
         * @param tries Number of tries to create nodes.
         */
        void updateNodeCreations(Ice::Long nodesCreated, Ice::Long tries, const Ice::Current& = Ice::emptyCurrent) override;
 
        void allocatedComputingPower(const Ice::Current& = Ice::emptyCurrent) override;
 
        /**
         * @brief shouldAllocateComputingPower
         * @return Whrether
         */
        bool shouldAllocateComputingPower(const ::Ice::Current& = Ice::emptyCurrent) override
        {
            const auto perc = std::accumulate(backlog.begin(), backlog.end(), 1.f) / backlog.size();
            const auto usedTimeDelta = timeDeltaInSeconds / (1.f + sigma * perc);
            ARMARX_CHECK_EXPRESSION(usedTimeDelta >= 0);
            return Clock::now() >= allocatedLastTime + std::chrono::seconds {static_cast<std::size_t>(usedTimeDelta)};
        }
 
        /**
         * @brief Nulls the backlog after the object was transmitted through ice.
         */
        void ice_postUnmarshal() override
        {
            backlog.assign(backlogSize, 0);
        }
 
    protected:
        /**
         * @brief The backlog. chars are used instead of bools since vector<bool> is specialized.
         * contains a 1 if a node creation failed and 0 if it was successfull;
         */
        std::vector<char> backlog;
        /**
         * @brief The current index in the backlog. (used to determine which variables will be overwritten)
         */
        std::size_t currentBacklogIndex;
 
        //for object factory
        template<class Base, class Derived> friend class armarx::GenericFactory;
        /**
         * @brief Ctor used for object factories.
         */
        NoNodeCreated() = default;
    };
    using NoNodeCreatedPtr = IceInternal::Handle<NoNodeCreated>;
 
    /**
     * @brief Implementation of TotalNodeCountBase
     * @see TotalNodeCountBase
     */
    class TotalNodeCount:
        virtual public TotalNodeCountBase,
        virtual public ComputingPowerRequestStrategy
    {
    public:
        /**
         * @brief Ctor
         * @param nodeCountDelta The delta to use.
         * @param skipping Whether skipping is activated.
         */
        TotalNodeCount(Ice::Long nodeCountDelta, bool skipping):
            TotalNodeCountBase(nodeCountDelta, skipping),
            allocateNextTime {0},
            nodeCount {0}
        {
        }
 
        /**
         * @brief Updates the internal node count.
         * @param newCount The new node count.
         */
        void updateNodeCount(Ice::Long newCount, const Ice::Current& = Ice::emptyCurrent) override
        {
            nodeCount = newCount;
        }
 
        /**
         * @brief Sets the next creation count to allocate depending on the flag skipping.
         * skipping == true: current count + delta.
         * skipping == false: the current next creation count + delta. (may be smaller than the current count)
         */
        void allocatedComputingPower(const Ice::Current& = Ice::emptyCurrent) override;
 
        /**
         * @brief Returns true if the the current count is >= the next creation count.
         * @return Whether more computing power should be allocated.
         */
        bool shouldAllocateComputingPower(const ::Ice::Current& = Ice::emptyCurrent) override
        {
            return nodeCount >= allocateNextTime;
        }
 
    protected:
        /**
         * @brief The count when to allocate more power.
         */
        Ice::Long allocateNextTime;
        /**
         * @brief The current node count.
         */
        Ice::Long nodeCount;
 
        //for object factory
        template<class Base, class Derived> friend class armarx::GenericFactory;
        /**
         * @brief Ctor used for object factories.
         */
        TotalNodeCount(): allocateNextTime {0}, nodeCount {0} {}
    };
    using TotalNodeCountPtr = IceInternal::Handle<TotalNodeCount>;
 
    /**
     * @brief Implementation of TaskStatusBase
     * @see TaskStatusBase
     */
    class TaskStatus:
        virtual public TaskStatusBase,
        virtual public ComputingPowerRequestStrategy
    {
    public:
        /**
         * @brief Ctor
         * @param strategyPerTaskStatus Task status to sub strategy map.
         */
        TaskStatus(TaskStatusMap strategyPerTaskStatus):
            TaskStatusBase(strategyPerTaskStatus),
            current {nullptr}
        {
        }
 
        /**
         * @brief Passes this call to all sub strategies.
         * @param count The new count
         */
        void updateNodeCount(Ice::Long count, const Ice::Current& = Ice::emptyCurrent) override;
 
        /**
         * @brief Switches the current strategy and passes this call to all sub strategies.
         * @param newStatus
         */
        void updateTaskStatus(armarx::TaskStatus::Status newStatus, const Ice::Current& = Ice::emptyCurrent) override;
 
        /**
         * @brief Passes this call to all sub strategies.
         */
        void allocatedComputingPower(const Ice::Current& = Ice::emptyCurrent) override;
 
        /**
         * @brief Passes this call to all sub strategies.
         * @see ComputingPowerRequestStrategyBase::updateNodeCreations
         * @param nodesCreated Number of created nodes.
         * @param tries Number of tries to create nodes.
         */
        void updateNodeCreations(Ice::Long nodesCreated, Ice::Long tries, const Ice::Current& = Ice::emptyCurrent) override;
 
        /**
         * @brief Returns the result of the current selected strategy.
         * @return The result of the current selected strategy.
         */
        bool shouldAllocateComputingPower(const ::Ice::Current& = Ice::emptyCurrent) override
        {
            ARMARX_CHECK_EXPRESSION(current);
            return current->shouldAllocateComputingPower();
        }
    protected:
        /**
         * @brief The current strategy in use.
         */
        ComputingPowerRequestStrategyBase* current;
 
        //for object factory
        template<class Base, class Derived> friend class armarx::GenericFactory;
        /**
         * @brief Ctor used for object factories.
         */
        TaskStatus(): current {nullptr} {}
    };
    using TaskStatusPtr = IceInternal::Handle<TaskStatus>;
}