Prbs.h

Go to the documentation of this file.

 
#ifndef __ROGUE_UTILITIES_PRBS_H__
#define __ROGUE_UTILITIES_PRBS_H__
#include "rogue/Directives.h"
 
#include <stdint.h>
 
#include <atomic>
#include <memory>
#include <thread>
 
#include "rogue/interfaces/stream/Master.h"
#include "rogue/interfaces/stream/Slave.h"
 
namespace rogue {
namespace utilities {
 
class Prbs : public rogue::interfaces::stream::Slave, public rogue::interfaces::stream::Master {
    // Max size
    static const uint32_t MaxBytes = 64;
 
    // PRBS taps
    uint8_t* taps_;
 
    // PRBS tap count
    uint32_t tapCnt_;
 
    // Data width in bytes
    uint32_t width_;
 
    // Data width in bytes
    uint32_t byteWidth_;
 
    // Min size
    uint32_t minSize_;
 
    // Lock
    std::mutex pMtx_;
 
    // rx sequence tracking
    uint32_t rxSeq_;
 
    // RX Error count
    uint32_t rxErrCount_;
 
    // Rx count
    uint32_t rxCount_;
 
    // Rx bytes
    uint64_t rxBytes_;
 
    // tx sequence tracking
    uint32_t txSeq_;
 
    // Transmit size
    uint32_t txSize_;
 
    // TX Error count
    uint32_t txErrCount_;
 
    // TX count
    uint32_t txCount_;
 
    // TX bytes
    uint64_t txBytes_;
 
    // Check payload
    bool checkPl_;
 
    // Gen payload
    bool genPl_;
 
    // Send count
    bool sendCount_;
 
    // Receive enable
    bool rxEnable_;
 
    // Tx Rate Period in microseconds
    uint32_t txPeriod_;
 
    // Stats
    uint32_t lastRxCount_;
    uint64_t lastRxBytes_;
    struct timeval lastRxTime_;
    double rxRate_;
    double rxBw_;
 
    uint32_t lastTxCount_;
    uint64_t lastTxBytes_;
    struct timeval lastTxTime_;
    double txRate_;
    double txBw_;
 
    // Logger
    std::shared_ptr<rogue::Logging> rxLog_;
    std::shared_ptr<rogue::Logging> txLog_;
 
  protected:
    std::thread* txThread_ = nullptr;
    std::atomic<bool> threadEn_{false};
 
  private:
    // Internal computation
    void flfsr(uint8_t* data);
 
    // Thread background
    void runThread();
 
    static double updateTime(struct timeval* last);
 
  public:
    static std::shared_ptr<rogue::utilities::Prbs> create();
 
    static void setup_python();
 
    Prbs();
 
    ~Prbs();
 
    void setWidth(uint32_t width);
 
    void setTaps(uint32_t tapCnt, uint8_t* taps);
 
#ifndef NO_PYTHON
    void setTapsPy(boost::python::object p);
#endif
 
    void sendCount(bool state);
 
    void genFrame(uint32_t size);
 
    void enable(uint32_t size);
 
    void disable();
 
    bool getRxEnable();
 
    void setRxEnable(bool state);
 
    uint32_t getRxErrors();
 
    uint32_t getRxCount();
 
    uint64_t getRxBytes();
 
    double getRxRate();
 
    double getRxBw();
 
    double getTxRate();
 
    void setTxPeriod(uint32_t txPeriod);
 
    uint32_t getTxPeriod();
 
    double getTxBw();
 
    uint32_t getTxErrors();
 
    uint32_t getTxCount();
 
    uint64_t getTxBytes();
 
    void checkPayload(bool state);
 
    void genPayload(bool state);
 
    void resetCount();
 
    void acceptFrame(std::shared_ptr<rogue::interfaces::stream::Frame> frame);
};
 
// Convenience
typedef std::shared_ptr<rogue::utilities::Prbs> PrbsPtr;
 
}  // namespace utilities
}  // namespace rogue
#endif