SrpV3Emulation.h

Go to the documentation of this file.

 
#ifndef __ROGUE_PROTOCOLS_SRP_SRPV3EMULATION_H__
#define __ROGUE_PROTOCOLS_SRP_SRPV3EMULATION_H__
#include "rogue/Directives.h"
 
#include <stdint.h>
 
#include <condition_variable>
#include <map>
#include <memory>
#include <mutex>
#include <queue>
#include <thread>
 
#include "rogue/Logging.h"
#include "rogue/interfaces/stream/Frame.h"
#include "rogue/interfaces/stream/Master.h"
#include "rogue/interfaces/stream/Slave.h"
 
namespace rogue {
namespace protocols {
namespace srp {
 
class SrpV3Emulation : public rogue::interfaces::stream::Master,
                    public rogue::interfaces::stream::Slave {
    std::shared_ptr<rogue::Logging> log_;
 
    static const uint32_t HeadLen = 20;
    static const uint32_t TailLen = 4;
 
    // Memory map type: 4K-aligned base address -> 4K page
    typedef std::map<uint64_t, uint8_t*> MemoryMap;
 
    // Internal memory emulation
    MemoryMap memMap_;
 
    // Memory access mutex
    std::mutex memMtx_;
 
    // Allocation tracking
    uint32_t totAlloc_;
 
    // Worker thread and queue
    std::thread thread_;
    std::queue<std::shared_ptr<rogue::interfaces::stream::Frame> > queue_;
    std::mutex queMtx_;
    std::condition_variable queCond_;
    bool threadEn_;
 
    void runThread();
 
    void processFrame(std::shared_ptr<rogue::interfaces::stream::Frame> frame);
 
  public:
    static std::shared_ptr<rogue::protocols::srp::SrpV3Emulation> create();
 
    static void setup_python();
 
    SrpV3Emulation();
 
    ~SrpV3Emulation();
 
    void stop();
 
    void acceptFrame(std::shared_ptr<rogue::interfaces::stream::Frame> frame);
 
  private:
    uint8_t* allocatePage(uint64_t addr4k);
 
    void readMemory(uint64_t address, uint8_t* data, uint32_t size);
 
    void writeMemory(uint64_t address, const uint8_t* data, uint32_t size);
};
 
// Convenience
typedef std::shared_ptr<rogue::protocols::srp::SrpV3Emulation> SrpV3EmulationPtr;
}  // namespace srp
}  // namespace protocols
}  // namespace rogue
#endif