qkd-buffer.h

Go to the documentation of this file.

/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
 * Copyright (c) 2020 DOTFEESA www.tk.etf.unsa.ba
 *
 * This program 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;
 *
 * This program 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, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 * Author: Miralem Mehic <miralem.mehic@ieee.org>
 */
 
#ifndef QKDBUFFER_H
#define QKDBUFFER_H
 
#include <queue>
#include "ns3/packet.h"
#include "ns3/object.h"
#include "ns3/ipv4-header.h"
#include "ns3/traced-value.h"
#include "ns3/trace-source-accessor.h"
#include "ns3/event-id.h"
#include "ns3/qkd-key.h"
#include "ns3/node.h"
#include <vector>
#include <map>
 
namespace ns3 {
 
  class QKDBuffer: public Object {
    public:
 
    static
    const uint32_t QKDSTATUS_READY = 0; 
    static
    const uint32_t QKDSTATUS_WARNING = 1; 
    static
    const uint32_t QKDSTATUS_CHARGING = 2; 
    static
    const uint32_t QKDSTATUS_EMPTY = 3; 
 
    struct data {
      uint32_t value;
      uint32_t position;
    };
 
    struct KeyStorage {
      Ptr <Node> alice;
      Ptr <Node> bob;
      std::map < uint32_t, QKDKey > keys;
      double publicChannelMetric;
      double quantumChannelMetric;
    };
 
    static TypeId GetTypeId(void);
 
    QKDBuffer();
 
    virtual~QKDBuffer();
 
    void Init(
      Ptr <Node> srcNode,
      Ptr <Node> dstNode,
      uint32_t Mmin,
      uint32_t Mthr,
      uint32_t Mmax,
      uint32_t Mcurrent,
      bool useRealStorages
    );
 
    void Dispose(void);
 
    bool AddNewKey(Ptr <QKDKey> key, uint32_t keyTransformed);
 
    uint32_t FetchState(void);
 
    uint32_t FetchPreviousState(void);
 
    void CheckState(void);
 
    void KeyCalculation();
 
    /*
     *   \brief Get the time difference between the current time and time at which
     *   last key charging process finished.
     *
     *   \return The time difference.
     */
    int64_t FetchDeltaTime();
 
    int64_t FetchLastKeyChargingTimeDuration();
 
    double FetchAverageKeyChargingTimePeriod();
 
    uint32_t FetchMaxNumberOfRecordedKeyChargingTimePeriods();
 
    uint32_t GetMCurrentPrevious(void) const;
 
    uint32_t GetMthr(void) const;
 
    void SetMthr(uint32_t thr);
 
    void InitTotalGraph() const;
 
    uint32_t GetId(void) const;
 
    void SetSrcNode(Ptr <Node> );
 
    Ptr <Node> GetSrcNode();
 
    void SetDstNode(Ptr <Node> );
 
    Ptr <Node> GetDstNode();
 
    void SetIndex(uint32_t);
    uint32_t GetIndex();
 
    bool operator == (QKDBuffer
      const & o) const;
 
    Ptr <Node> m_srcNode; 
    Ptr <Node> m_dstNode; 
    uint32_t m_bufferID; 
    static uint32_t nBuffers; 
 
    uint32_t GetKeySize();
 
    uint64_t GetKeyCountBit();
 
    uint64_t GetReadyKeyCountBit();
 
    uint64_t GetTargetKeyCountBit();
  
    uint32_t GetKeyCount();
 
    uint32_t GetMinKeyCount();
 
    uint32_t GetMaxKeyCount();
 
    uint64_t GetMaxKeyCountBit();
 
    uint32_t GetMinKeySize();
 
    uint64_t GetMinKeySizeBit();
 
    uint64_t GetMaxKeySizeBit();
 
    uint32_t    GetKeyCount (uint32_t keySize);
 
    bool        ProbeKeyStatus (std::string keyId, QKDKey::QKDKeyState_e keyState);
 
    Ptr<QKDKey>   FetchKeyBySize( const uint32_t& keySize);
 
    Ptr <QKDKey>  FetchKeyByID(std::string keyID);
 
    Ptr <QKDKey>  FetchKeyByID(std::string keyID, uint32_t fillProcessActive);
 
    void            ReserveKey (std::string keyId);
 
    void            ReleaseReservation (std::string keyId);
 
    void            RecordTargetSize (uint32_t size);
 
    Ptr<QKDKey>     SearchOptimalKeyToTransform (uint32_t targetSize);
 
    double GetAverageKeyGenerationRate();
 
    double GetAverageKeyConsumptionRate();
 
    void UpdateKeyConsumptionStatistics(Ptr<QKDKey> key);
 
    void UpdateKeyGenerationStatistics(Ptr<QKDKey> key);
 
  private:
 
    std::vector<uint32_t> m_targetSizeSet; 
    uint32_t m_defaultKeySize; 
    bool m_useRealStorages; //<! Whether to use real storages or virtual buffers (still in development).
    uint32_t m_nextKeyID; 
    std::map < std::string, Ptr <QKDKey> > m_keys; 
 
    uint32_t m_noEntry; 
    uint32_t m_period; 
    uint32_t m_noAddNewValue; 
    uint32_t m_bitsUsedInTimePeriod; 
 
    uint32_t m_recalculateTimePeriod; 
    std::vector < struct QKDBuffer::data > m_previousValues; 
    
    double m_c; 
    bool m_isRisingCurve; 
    uint32_t m_previousStatus; 
    uint32_t m_minKeyBit; 
    uint32_t m_maxKeyBit; 
    uint32_t m_thresholdKeyBit; 
    uint32_t m_minimalKeyCount; 
    uint32_t m_maximalKeyCount; 
 
    TracedCallback < uint32_t > m_thresholdKeyBitChangeTrace; 
    TracedCallback < uint32_t > m_thresholdKeyBitIncreaseTrace; 
    TracedCallback < uint32_t > m_thresholdKeyBitDecreaseTrace; 
 
    uint32_t m_currentKeyBit; 
    uint32_t m_currentKeyBitReally; 
    uint64_t m_currentReadyKeyBit; 
    uint64_t m_currentTargetKeyBit; 
    uint32_t m_currentKeyBitPrevious; 
    int64_t m_lastKeyChargingTimeStamp; 
    int64_t m_lastKeyConsumptionTimeStamp; 
    int64_t m_lastKeyChargingTimeDuration; 
    int64_t m_lastKeyConsumptionTimeDuration; 
    uint32_t m_maxNumberOfRecordedKeyChargingTimePeriods; 
    uint32_t m_maxNumberOfRecordedKeyConsumptionTimePeriods; 
    std::vector < int64_t > m_lastChargedKeySizes; 
    std::vector < int64_t > m_lastConsumedKeySizes; 
    std::vector < int64_t > m_chargingTimePeriods; 
    std::vector < int64_t > m_consumptionTimePeriods; 
    uint32_t m_status; 
    double m_averageKeyChargingTimePeriod; 
    double m_averageKeyConsumptionTimePeriod; 
    double m_averageKeyChargingSize; 
    double m_averageKeyConsumptionSize; 
    double m_averageKeyGenerationRate; 
    double m_averageKeyConsumptionRate; 
    EventId m_calculateRoutingMetric; 
    TracedCallback < Ptr<QKDKey> > m_newKeyAddedTrace; 
    TracedCallback < Ptr<QKDKey> > m_transformedKeyAddedTrace; 
    TracedCallback < Ptr<QKDKey> > m_keyServedTrace; 
    TracedCallback < Ptr<QKDKey> > m_keyReservedTrace; 
    TracedCallback < uint32_t > m_currentKeyBitChangeTrace; 
    TracedCallback < uint32_t > m_currentKeyBitIncreaseTrace; 
    TracedCallback < uint32_t > m_currentKeyBitDecreaseTrace; 
    TracedCallback < uint32_t > m_StatusChangeTrace; 
    TracedCallback < double > m_CMetricChangeTrace; 
    
    TracedCallback < double > m_averageKeyGenerationRateTrace; 
    TracedCallback < double > m_averageKeyConsumptionRateTrace; 
 
    uint32_t m_srcNodeBufferListIndex; 
 
    std::map < uint32_t, QKDBuffer::KeyStorage > m_destinations; //<! A map of QKD destinations and respective QKD buffers.
 
  };
}
 
#endif /* QKDBUFFER_H */