Transaction.h

Go to the documentation of this file.

 
#ifndef __ROGUE_INTERFACES_MEMORY_TRANSACTION_H__
#define __ROGUE_INTERFACES_MEMORY_TRANSACTION_H__
#include "rogue/Directives.h"
 
#include <stdint.h>
 
#include <condition_variable>
#include <map>
#include <memory>
#include <mutex>
#include <string>
#include <thread>
 
#include "rogue/EnableSharedFromThis.h"
#include "rogue/Logging.h"
 
#ifndef NO_PYTHON
    #include <boost/python.hpp>
#endif
 
namespace rogue {
namespace interfaces {
namespace memory {
 
class TransactionLock;
class Transaction;
class Master;
class Hub;
 
//         using TransactionIDVec = std::vector<uint32_t>;
//         using TransactionQueue = std::queue<std::shared_ptr<rogue::interfaces::memory::Transaction>>;
using TransactionMap = std::map<uint32_t, std::shared_ptr<rogue::interfaces::memory::Transaction>>;
 
class Transaction : public rogue::EnableSharedFromThis<rogue::interfaces::memory::Transaction> {
    friend class TransactionLock;
    friend class Master;
    friend class Hub;
 
  public:
    typedef uint8_t* iterator;
 
  private:
    // Class instance counter
    static uint32_t classIdx_;
 
    // Class instance lock
    static std::mutex classMtx_;
 
    // Conditional
    std::condition_variable cond_;
 
  protected:
    // Transaction timeout
    struct timeval timeout_;
 
    // Transaction end time
    struct timeval endTime_;
 
    // Transaction start time
    struct timeval startTime_;
 
    // Transaction warn time
    struct timeval warnTime_;
 
#ifndef NO_PYTHON
    // Transaction python buffer
    Py_buffer pyBuf_;
#endif
 
    // Python buffer is valid
    bool pyValid_;
 
    // Iterator (mapped to uint8_t * for now)
    iterator iter_;
 
    // Transaction address
    uint64_t address_;
 
    // Transaction size
    uint32_t size_;
 
    // Transaction type
    uint32_t type_;
 
    // Transaction error
    std::string error_;
 
    // Transaction id
    uint32_t id_;
 
    // Done state
    bool done_;
 
    // Transaction lock
    std::mutex lock_;
 
    // Sub-transactions vector
    TransactionMap subTranMap_;
 
    // Done creating subtransactions for this transaction
    bool doneCreatingSubTransactions_;
 
    // Identify if it's a parent or a sub transaction
    bool isSubTransaction_;
 
    std::shared_ptr<rogue::Logging> log_;
 
    // Weak pointer to parent transaction, where applicable
    std::weak_ptr<rogue::interfaces::memory::Transaction> parentTransaction_;
 
    static std::shared_ptr<rogue::interfaces::memory::Transaction> create(struct timeval timeout);
 
    // Wait for the transaction to complete, called by Master
    std::string wait();
 
  public:
    // Setup class for use in python
    static void setup_python();
 
    explicit Transaction(struct timeval timeout);
 
    // Destroy the Transaction.
    ~Transaction();
 
    std::shared_ptr<rogue::interfaces::memory::TransactionLock> lock();
 
    bool expired();
 
    uint32_t id();
 
    uint64_t address();
 
    uint32_t size();
 
    uint32_t type();
 
    std::shared_ptr<rogue::interfaces::memory::Transaction> createSubTransaction();
 
    void doneSubTransactions();
 
    void refreshTimer(std::shared_ptr<rogue::interfaces::memory::Transaction> reference);
 
    void done();
 
    void errorStr(std::string error);
 
    void error(const char* fmt, ...);
 
    uint8_t* begin();
 
    uint8_t* end();
 
#ifndef NO_PYTHON
 
    void getData(boost::python::object p, uint32_t offset);
 
    void setData(boost::python::object p, uint32_t offset);
#endif
};
 
typedef std::shared_ptr<rogue::interfaces::memory::Transaction> TransactionPtr;
 
}  // namespace memory
}  // namespace interfaces
}  // namespace rogue
 
#endif