LoadBalance.hpp

Go to the documentation of this file.

#ifndef LOAD_BALANCE_HPP
#define LOAD_BALANCE_HPP

#include "CBroker.hpp"
#include "CDevice.hpp"
#include "CPeerNode.hpp"
#include "PeerSets.hpp"
#include "IDGIModule.hpp"
#include "messages/ModuleMessage.pb.h"

#include <map>
#include <set>
#include <string>
#include <boost/shared_ptr.hpp>
#include <boost/date_time/posix_time/posix_time_types.hpp>

namespace freedm {
namespace broker {
namespace lb {

class LBAgent
    : public IDGIModule
{
public:
    LBAgent();
    int Run();
private:
    enum State { SUPPLY, DEMAND, NORMAL };
    //     
    ModuleMessage MessageStateChange(std::string state);
    ModuleMessage MessageDraftRequest();
    ModuleMessage MessageDraftAge(float age);
    ModuleMessage MessageDraftSelect(float amount);
    ModuleMessage MessageDraftAccept(float amount);
    ModuleMessage MessageTooLate(float amount);
    ModuleMessage MessageStateCollection();
    ModuleMessage MessageCollectedState(float state);
    
    ModuleMessage PrepareForSending(const LoadBalancingMessage & m, std::string recipient = "lb");
    void SendToPeerSet(const PeerSet & ps, const ModuleMessage & m);

    void HandleIncomingMessage(boost::shared_ptr<const ModuleMessage> m, CPeerNode peer);
    void HandleStateChange(const StateChangeMessage & m, CPeerNode peer);
    void HandleDraftRequest(const DraftRequestMessage & m, CPeerNode peer);
    void HandleDraftAge(const DraftAgeMessage & m, CPeerNode peer);
    void HandleDraftSelect(const DraftSelectMessage & m, CPeerNode peer);
    void HandleDraftAccept(const DraftAcceptMessage & m, CPeerNode peer);
    void HandleTooLate(const TooLateMessage & m);
    void HandlePeerList(const gm::PeerListMessage & m, CPeerNode peer);
    void HandleCollectedState(const sc::CollectedStateMessage & m);
    void HandleCollectedState(const CollectedStateMessage & m);
    
    void MoveToPeerSet(PeerSet & ps, CPeerNode peer);
    
    void LoadManage(const boost::system::error_code & error);
    void FirstRound(const boost::system::error_code & error);
    void DraftStandard(const boost::system::error_code & error);
    
    void ScheduleNextRound();
    void ReadDevices();
    void UpdateState();
    void LoadTable();
    void SendDraftRequest();
    void SendDraftAge(CPeerNode peer);
    void SendDraftSelect(CPeerNode peer, float step);
    void SendDraftAccept(CPeerNode peer, float step);
    void SendTooLate(CPeerNode peer, float step);
    void SetPStar(float pstar);
    void SetDESD(float desd);
    void ScheduleStateCollection();
    void Synchronize(float k);
    bool InvariantCheck();

    const boost::posix_time::time_duration ROUND_TIME;
    const boost::posix_time::time_duration REQUEST_TIMEOUT;

    CBroker::TimerHandle m_RoundTimer;
    CBroker::TimerHandle m_WaitTimer;

    PeerSet m_AllPeers;
    PeerSet m_InSupply;
    PeerSet m_InDemand;
    PeerSet m_InNormal;

    State m_State;

    float m_Gateway;
    float m_NetGeneration;
    float m_PredictedGateway;
    float m_MigrationStep;
    float m_PowerDifferential;

    bool m_Synchronized;

    std::string m_Leader;
    std::map<std::string, float> m_DraftAge;
};

} // namespace lb
} // namespace broker
} // namespace freedm

#endif // LOAD_BALANCE_HPP